TradeStrike Class Reference

#include <ored/portfolio/tradestrike.hpp>

Collaboration diagram for TradeStrike:

Classes
struct	StrikeYield

Public Types
enum class	Type { Price , Yield }
typedef TradeMonetary	StrikePrice

Public Member Functions
	TradeStrike ()
	TradeStrike (Type type, const QuantLib::Real &value)
	TradeStrike (const QuantLib::Real &value, const std::string &currency)
	TradeStrike (const QuantLib::Real &value, QuantLib::Compounding compounding)
QuantLib::Real	value () const
Type	type () const
std::string	currency ()
const QuantLib::Compounding &	compounding ()
StrikePrice &	strikePrice () const
StrikeYield &	strikeYield () const
void	setValue (const QuantLib::Real &value)
void	setCurrency (const std::string &currency)
void	fromXML (XMLNode *node, const bool isRequired=true, const bool allowYieldStrike=false)
XMLNode *	toXML (XMLDocument &doc) const
const bool	empty () const

Private Attributes
boost::variant< StrikeYield, StrikePrice >	strike_
Type	type_
bool	onlyStrike_ = false
bool	noStrikePriceNode_ = false

Detailed Description

Definition at line 30 of file tradestrike.hpp.

Member Typedef Documentation

StrikePrice

typedef TradeMonetary StrikePrice

Definition at line 37 of file tradestrike.hpp.

Member Enumeration Documentation

Type

enum class Type

strong

Enumerator
Price
Yield

Definition at line 32 of file tradestrike.hpp.

                    {
        Price,
        Yield
    };

Constructor & Destructor Documentation

TradeStrike() [1/4]

TradeStrike

(

)

Definition at line 47 of file tradestrike.hpp.

: type_(Type::Price) {};

TradeStrike() [2/4]

TradeStrike	(	Type	type,
		const QuantLib::Real &	value
	)

Definition at line 35 of file tradestrike.cpp.

                                                             : type_(type) { 
    if (type_ == Type::Price)
        strike_ = TradeMonetary(value);
    else
        strike_ = StrikeYield(value);
}

Here is the call graph for this function:

TradeStrike() [3/4]

TradeStrike	(	const QuantLib::Real &	value,
		const std::string &	currency
	)

Definition at line 42 of file tradestrike.cpp.

                                                                             : type_(Type::Price) {
    strike_ = TradeMonetary(value, currency);
}

Here is the call graph for this function:

TradeStrike() [4/4]

TradeStrike	(	const QuantLib::Real &	value,
		QuantLib::Compounding	compounding
	)

Definition at line 46 of file tradestrike.cpp.

                                                                                   : type_(Type::Yield) {
    strike_ = StrikeYield(value, compounding);
}

Here is the call graph for this function:

Member Function Documentation

value()

QuantLib::Real value

(

)

const

Definition at line 115 of file tradestrike.cpp.

                                      { 
    return boost::apply_visitor(StrikeValue(), strike_); 
}

Here is the caller graph for this function:

type()

Type type

(

)

const

Definition at line 53 of file tradestrike.hpp.

{ return type_; };

currency()

std::string currency

(

)

Definition at line 119 of file tradestrike.cpp.

                                {
    QL_REQUIRE(type_ == Type::Price, "TradeStrike currency only valid when Strike type is Price");
    return strikePrice().currency();
}

Here is the call graph for this function:

Here is the caller graph for this function:

compounding()

const QuantLib::Compounding & compounding

(

)

Definition at line 124 of file tradestrike.cpp.

                                                    {
    QL_REQUIRE(type_ == Type::Yield, "TradeStrike currency only valid when Strike type is Yield");
    return strikeYield().compounding;
}

Here is the call graph for this function:

Here is the caller graph for this function:

strikePrice()

StrikePrice & strikePrice

(

)

const

Definition at line 57 of file tradestrike.hpp.

{ return boost::get<StrikePrice>(strike_); }

Here is the caller graph for this function:

strikeYield()

StrikeYield & strikeYield

(

)

const

Definition at line 58 of file tradestrike.hpp.

{ return boost::get<StrikeYield>(strike_); }

Here is the caller graph for this function:

setValue()

void setValue

(

const QuantLib::Real &

value

)

Definition at line 129 of file tradestrike.cpp.

                                                    {
    if (type_ == Type::Price) {
        strikePrice().setValue(value);
    } else {
        strikeYield().yield = value;    
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setCurrency()

void setCurrency

(

const std::string &

currency

)

Definition at line 137 of file tradestrike.cpp.

                                                       {
    QL_REQUIRE(type_ == Type::Price, "TradeStrike currency only valid when Strike type is Price");
    strikePrice().setCurrency(currency);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fromXML()

void fromXML	(	XMLNode *	node,
		const bool	isRequired = true,
		const bool	allowYieldStrike = false
	)

Definition at line 50 of file tradestrike.cpp.

                                                                                           {
    XMLNode* dataNode = XMLUtils::getChildNode(node, "StrikeData");
    if (dataNode) {
        // first look for StrikeYield node
        if (XMLNode* yieldNode = XMLUtils::getChildNode(dataNode, "StrikeYield")) {
            QL_REQUIRE(allowYieldStrike, "StrikeYield not supported for this trade type.");
            StrikeYield strikeYield;
            strikeYield.yield = XMLUtils::getChildValueAsDouble(yieldNode, "Yield", true);
            strikeYield.compounding =
                parseCompounding(XMLUtils::getChildValue(yieldNode, "Compounding", false, "SimpleThenCompounded"));
            strike_ = strikeYield;
            type_ = Type::Yield;
        } else {
            TradeMonetary strikePrice;
            if (XMLNode* priceNode = XMLUtils::getChildNode(dataNode, "StrikePrice"))
                strikePrice.fromXMLNode(priceNode);
            else {
                // in order to remain backward compatible we also allow to be set up
                // without the StrikePrice node                
                strikePrice.fromXMLNode(dataNode);
                noStrikePriceNode_ = true;                
            }
            strike_ = strikePrice;
            type_ = Type::Price;
        }
    } else {
        // if just a strike is present
        string s = XMLUtils::getChildValue(node, "Strike", isRequired);
        if (!s.empty()) {
            strike_ = TradeMonetary(s);
            type_ = Type::Price;
            onlyStrike_ = true;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

toXML()

XMLNode * toXML

(

XMLDocument &

doc

)

const

Definition at line 86 of file tradestrike.cpp.

                                                  {
    XMLNode* node;
    if (onlyStrike_) {
        // can only happen for a StrikePrice
        auto sp = QuantLib::ext::get<StrikePrice>(strike_);
        node = doc.allocNode("Strike", boost::lexical_cast<std::string>(sp.valueString()));
    } else {
        node = doc.allocNode("StrikeData");
        if (noStrikePriceNode_) {
            // maintain backward compatibility, must be a Strike Type Price to get here
            strikePrice().toXMLNode(doc, node);
        } else {
            XMLNode* subNode;
            if (type_ == Type::Yield) {
                auto yld = strikeYield();
                subNode = doc.allocNode("StrikeYield");
                XMLUtils::addChild(doc, subNode, "Yield", yld.yield);
                XMLUtils::addChild(doc, subNode, "Compounding", to_string(yld.compounding));
            } else {
                auto sp = strikePrice();
                subNode = doc.allocNode("StrikePrice");
                sp.toXMLNode(doc, subNode);
            }
            XMLUtils::appendNode(node, subNode);     
        }
    }
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

const bool empty

(

)

const

Definition at line 142 of file tradestrike.cpp.

                                    {
    try {      
        return value() == Null<Real>();
    } catch (...) {
        return true;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

strike_

boost::variant<StrikeYield, StrikePrice> strike_

mutableprivate

Definition at line 69 of file tradestrike.hpp.

type_

Type type_

private

Definition at line 70 of file tradestrike.hpp.

onlyStrike_

bool onlyStrike_ = false

private

Definition at line 71 of file tradestrike.hpp.

noStrikePriceNode_

bool noStrikePriceNode_ = false

private

Definition at line 72 of file tradestrike.hpp.