ScriptedTrade Class Reference

#include <ored/portfolio/scriptedtrade.hpp>

Inheritance diagram for ScriptedTrade:

Collaboration diagram for ScriptedTrade:

Public Member Functions
	ScriptedTrade (const std::string &tradeType="ScriptedTrade", const Envelope &env=Envelope())
	ScriptedTrade (const Envelope &env, const std::vector< ScriptedTradeEventData > &events, const std::vector< ScriptedTradeValueTypeData > &numbers, const std::vector< ScriptedTradeValueTypeData > &indices, const std::vector< ScriptedTradeValueTypeData > &currencies, const std::vector< ScriptedTradeValueTypeData > &daycounters, const std::map< std::string, ScriptedTradeScriptData > &script, const std::string &productTag, const std::string &tradeType="ScriptedTrade")
	ScriptedTrade (const Envelope &env, const std::vector< ScriptedTradeEventData > &events, const std::vector< ScriptedTradeValueTypeData > &numbers, const std::vector< ScriptedTradeValueTypeData > &indices, const std::vector< ScriptedTradeValueTypeData > &currencies, const std::vector< ScriptedTradeValueTypeData > &daycounters, const std::string &scriptName, const std::string &tradeType="ScriptedTrade")
void	clear ()
void	build (const QuantLib::ext::shared_ptr< EngineFactory > &) override
QuantLib::Real	notional () const override
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...
std::string	notionalCurrency () const override
void	fromXML (XMLNode *node) override
XMLNode *	toXML (ore::data::XMLDocument &doc) const override
void	build (const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const PremiumData &premiumData, const Real premiumMultiplier)
std::map< ore::data::AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const override
virtual void	setIsdaTaxonomyFields ()
const std::vector< ScriptedTradeEventData > &	events () const
const std::vector< ScriptedTradeValueTypeData > &	numbers () const
const std::vector< ScriptedTradeValueTypeData > &	indices () const
const std::vector< ScriptedTradeValueTypeData > &	currencies () const
const std::vector< ScriptedTradeValueTypeData > &	daycounters () const
const std::map< std::string, ScriptedTradeScriptData > &	script () const
const std::string &	productTag () const
const std::string &	scriptName () const
const std::string &	simmProductClass () const
const std::string &	scheduleProductClass () const
const ScriptedTradeScriptData &	script (const std::string &purpose, const bool fallBackOnEmptyPurpose=true) const
Public Member Functions inherited from Trade
	Trade ()
	Default constructor. More...
	Trade (const string &tradeType, const Envelope &env=Envelope(), const TradeActions &ta=TradeActions())
	Base class constructor. More...
virtual	~Trade ()
	Default destructor. More...
virtual void	build (const QuantLib::ext::shared_ptr< EngineFactory > &)=0
virtual std::map< std::string, RequiredFixings::FixingDates >	fixings (const QuantLib::Date &settlementDate=QuantLib::Date()) const
const RequiredFixings &	requiredFixings () const
virtual std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const
void	reset ()
	Reset trade, clear all base class data. This does not reset accumulated timings for this trade. More...
void	resetPricingStats (const std::size_t numberOfPricings=0, const boost::timer::nanosecond_type cumulativePricingTime=0)
	Reset accumulated timings to given values. More...
string &	id ()
	Set the trade id. More...
void	setEnvelope (const Envelope &envelope)
	Set the envelope with counterparty and portfolio info. More...
void	setAdditionalData (const std::map< std::string, boost::any > &additionalData)
TradeActions &	tradeActions ()
	Set the trade actions. More...
const string &	id () const
const string &	tradeType () const
const Envelope &	envelope () const
const set< string > &	portfolioIds () const
const TradeActions &	tradeActions () const
const QuantLib::ext::shared_ptr< InstrumentWrapper > &	instrument () const
const std::vector< QuantLib::Leg > &	legs () const
const std::vector< string > &	legCurrencies () const
const std::vector< bool > &	legPayers () const
const string &	npvCurrency () const
const Date &	maturity () const
virtual bool	isExpired (const Date &d)
const string &	issuer () const
template<typename T >
T	additionalDatum (const std::string &tag) const
	returns any additional datum. More...
virtual const std::map< std::string, boost::any > &	additionalData () const
	returns all additional data returned by the trade once built More...
const std::string &	sensitivityTemplate () const
void	validate () const
	Utility to validate that everything that needs to be set in this base class is actually set. More...
virtual bool	hasCashflows () const
boost::timer::nanosecond_type	getCumulativePricingTime () const
	Get cumulative timing spent on pricing. More...
std::size_t	getNumberOfPricings () const
	Get number of pricings. More...
Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()
virtual void	fromXML (XMLNode *node)=0
virtual XMLNode *	toXML (XMLDocument &doc) const =0
void	fromFile (const std::string &filename)
void	toFile (const std::string &filename) const
void	fromXMLString (const std::string &xml)
	Parse from XML string. More...
std::string	toXMLString () const
	Parse from XML string. More...

Protected Attributes
std::vector< ScriptedTradeEventData >	events_
std::vector< ScriptedTradeValueTypeData >	numbers_
std::vector< ScriptedTradeValueTypeData >	indices_
std::vector< ScriptedTradeValueTypeData >	currencies_
std::vector< ScriptedTradeValueTypeData >	daycounters_
std::map< std::string, ScriptedTradeScriptData >	script_
std::string	productTag_
std::string	scriptName_
std::string	simmProductClass_
std::string	scheduleProductClass_
Protected Attributes inherited from Trade
string	tradeType_
QuantLib::ext::shared_ptr< InstrumentWrapper >	instrument_
std::vector< QuantLib::Leg >	legs_
std::vector< string >	legCurrencies_
std::vector< bool >	legPayers_
string	npvCurrency_
QuantLib::Real	notional_
string	notionalCurrency_
Date	maturity_
string	issuer_
string	sensitivityTemplate_
bool	sensitivityTemplateSet_ = false
std::size_t	savedNumberOfPricings_ = 0
boost::timer::nanosecond_type	savedCumulativePricingTime_ = 0
RequiredFixings	requiredFixings_
std::map< std::string, boost::any >	additionalData_

Additional Inherited Members
Protected Member Functions inherited from Trade
Date	addPremiums (std::vector< QuantLib::ext::shared_ptr< Instrument > > &instruments, std::vector< Real > &multipliers, const Real tradeMultiplier, const PremiumData &premiumData, const Real premiumMultiplier, const Currency &tradeCurrency, const QuantLib::ext::shared_ptr< EngineFactory > &factory, const string &configuration)
void	setLegBasedAdditionalData (const Size legNo, Size resultLegId=Null< Size >()) const
void	setSensitivityTemplate (const EngineBuilder &builder)
void	setSensitivityTemplate (const std::string &id)

Detailed Description

Definition at line 202 of file scriptedtrade.hpp.

Constructor & Destructor Documentation

ScriptedTrade() [1/3]

ScriptedTrade	(	const std::string &	tradeType = "ScriptedTrade",
		const Envelope &	env = Envelope()
	)

Definition at line 205 of file scriptedtrade.hpp.

        : Trade(tradeType, env) {}

ScriptedTrade() [2/3]

ScriptedTrade	(	const Envelope &	env,
		const std::vector< ScriptedTradeEventData > &	events,
		const std::vector< ScriptedTradeValueTypeData > &	numbers,
		const std::vector< ScriptedTradeValueTypeData > &	indices,
		const std::vector< ScriptedTradeValueTypeData > &	currencies,
		const std::vector< ScriptedTradeValueTypeData > &	daycounters,
		const std::map< std::string, ScriptedTradeScriptData > &	script,
		const std::string &	productTag,
		const std::string &	tradeType = "ScriptedTrade"
	)

Definition at line 208 of file scriptedtrade.hpp.

        : Trade(tradeType, env), events_(events), numbers_(numbers), indices_(indices), currencies_(currencies),
          daycounters_(daycounters), script_(script), productTag_(productTag) {}

ScriptedTrade() [3/3]

ScriptedTrade	(	const Envelope &	env,
		const std::vector< ScriptedTradeEventData > &	events,
		const std::vector< ScriptedTradeValueTypeData > &	numbers,
		const std::vector< ScriptedTradeValueTypeData > &	indices,
		const std::vector< ScriptedTradeValueTypeData > &	currencies,
		const std::vector< ScriptedTradeValueTypeData > &	daycounters,
		const std::string &	scriptName,
		const std::string &	tradeType = "ScriptedTrade"
	)

Definition at line 218 of file scriptedtrade.hpp.

        : Trade(tradeType, env), events_(events), numbers_(numbers), indices_(indices), currencies_(currencies),
          daycounters_(daycounters), scriptName_(scriptName) {}

Member Function Documentation

clear()

void clear

(

)

Definition at line 177 of file scriptedtrade.cpp.

                          {
    events_.clear();
    numbers_.clear();
    indices_.clear();
    currencies_.clear();
    daycounters_.clear();
    scriptName_ = productTag_ = "";
    script_.clear();
}

Here is the caller graph for this function:

build() [1/2]

void build ( const QuantLib::ext::shared_ptr< EngineFactory > &  )

overridevirtual

Build QuantLib/QuantExt instrument, link pricing engine. If build() is called multiple times, reset() should be called between these calls.

Implements Trade.

Reimplemented in TaRF, WindowBarrierOption, and WorstOfBasketSwap.

Definition at line 97 of file scriptedtrade.cpp.

                                                                                   {
    ScriptedTrade::build(engineFactory, PremiumData(), 1.0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

notional()

QuantLib::Real notional ( ) const

overridevirtual

Return the current notional in npvCurrency. See individual sub-classes for the precise definition.

Reimplemented from Trade.

Definition at line 135 of file scriptedtrade.cpp.

                                           {
    if (instrument_->qlInstrument()->isExpired())
        return 0.0;
    // try to get the notional from the additional results of the instrument
    auto st = QuantLib::ext::dynamic_pointer_cast<ScriptedInstrument>(instrument_->qlInstrument(true));
    QL_REQUIRE(st, "internal error: could not cast to ScriptedInstrument");
    try {
        return st->result<Real>("currentNotional");
    } catch (const std::exception& e) {
        if (st->lastCalculationWasValid()) {
            // calculation was valid, just the result is not provided
            DLOG("notional was not retrieved: " << e.what() << ", return null");
        } else {
            // calculation threw an error, propagate this
            QL_FAIL(e.what());
        }
    }
    // if not provided, return null
    return Null<Real>();
}

notionalCurrency()

std::string notionalCurrency ( ) const

overridevirtual

Reimplemented from Trade.

Definition at line 156 of file scriptedtrade.cpp.

                                                {
    if (instrument_->qlInstrument()->isExpired())
        return npvCurrency_;
    // try to get the notional ccy from the additional results of the instrument
    auto st = QuantLib::ext::dynamic_pointer_cast<ScriptedInstrument>(instrument_->qlInstrument(true));
    QL_REQUIRE(st, "internal error: could not cast to ScriptedInstrument");
    try {
        return instrument_->qlInstrument()->result<std::string>("notionalCurrency");
    } catch (const std::exception& e) {
        if (st->lastCalculationWasValid()) {
            // calculation was valid, just the result is not provided
            DLOG("notional ccy was not retrieved: " << e.what() << ", return empty string");
        } else {
            // calculation threw an error, propagate this
            QL_FAIL(e.what());
        }
    }
    // if not provided, return an empty string
    return std::string();
}

fromXML()

void fromXML ( XMLNode *  node )

overridevirtual

Reimplemented from Trade.

Reimplemented in TaRF, WindowBarrierOption, and WorstOfBasketSwap.

Definition at line 252 of file scriptedtrade.cpp.

                                         {
    clear();
    Trade::fromXML(node);
 
    // if we find a ScriptedTradeData node we use this (native format)
 
    XMLNode* tradeDataNode = XMLUtils::getChildNode(node, "ScriptedTradeData");
    if (tradeDataNode) {
        XMLNode* dataNode = XMLUtils::getChildNode(tradeDataNode, "Data");
        QL_REQUIRE(dataNode, "ScriptedTradeData/Data node not found");
        vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(dataNode, "");
        for (auto const n : nodes) {
            if (XMLUtils::getNodeName(n) == "Event") {
                events_.push_back(ScriptedTradeEventData());
                events_.back().fromXML(n);
            } else if (XMLUtils::getNodeName(n) == "Number") {
                numbers_.push_back(ScriptedTradeValueTypeData("Number"));
                numbers_.back().fromXML(n);
            } else if (XMLUtils::getNodeName(n) == "Index") {
                indices_.push_back(ScriptedTradeValueTypeData("Index"));
                indices_.back().fromXML(n);
            } else if (XMLUtils::getNodeName(n) == "Currency") {
                currencies_.push_back(ScriptedTradeValueTypeData("Currency"));
                currencies_.back().fromXML(n);
            } else if (XMLUtils::getNodeName(n) == "Daycounter") {
                daycounters_.push_back(ScriptedTradeValueTypeData("Daycounter"));
                daycounters_.back().fromXML(n);
            }
        }
        if (XMLNode* scriptName = XMLUtils::getChildNode(tradeDataNode, "ScriptName")) {
            scriptName_ = XMLUtils::getNodeValue(scriptName);
        } else if (XMLUtils::getChildNode(tradeDataNode, "Script")) {
            productTag_ = XMLUtils::getChildValue(tradeDataNode, "ProductTag", false);
            auto sn = XMLUtils::getChildrenNodes(tradeDataNode, "Script");
            for (auto const& n : sn) {
                ScriptedTradeScriptData s;
                s.fromXML(n);
                std::string purpose = XMLUtils::getAttribute(n, "purpose");
                script_[purpose] = s;
            }
        } else {
            QL_FAIL("either Script or ScriptName expected");
        }
        return;
    }
 
    // otherwise we look for a xxxData node and interpret the xxx as the script name (freestyle parsing)
 
    for (XMLNode* child = XMLUtils::getChildNode(node); child; child = XMLUtils::getNextSibling(child)) {
        std::string name = XMLUtils::getNodeName(child);
        if (name.size() > 4 && name.substr(name.size() - 4, 4) == "Data") {
            QL_REQUIRE(!tradeDataNode, "multiple child nodes xxxData found");
            tradeDataNode = child;
            scriptName_ = name.substr(0, name.size() - 4);
        }
    }
 
    QL_REQUIRE(tradeDataNode, "expected ScriptedTradeData or xxxData node");
 
    // now loop over the child nodes and populate the script data
    for (XMLNode* child = XMLUtils::getChildNode(tradeDataNode); child; child = XMLUtils::getNextSibling(child)) {
 
        // the name of the node will be the name of the script variable
        std::string varName = XMLUtils::getNodeName(child);
        std::string type = XMLUtils::getAttribute(child, "type");
        QL_REQUIRE(!type.empty(), "no type given for node '" << varName << "'");
 
        std::string scalarValue = XMLUtils::getNodeValue(child);
        if (!scalarValue.empty()) {
            // if we have a value, this is a scalar
            auto native = getNativeTypeAndValue(scalarValue, type);
            if (native.first == NodeType::Event) {
                events_.push_back(ScriptedTradeEventData(varName, native.second));
            } else if (native.first == NodeType::Number) {
                numbers_.push_back(ScriptedTradeValueTypeData("Number", varName, native.second));
            } else if (native.first == NodeType::Index) {
                indices_.push_back(ScriptedTradeValueTypeData("Index", varName, native.second));
            } else if (native.first == NodeType::Currency) {
                currencies_.push_back(ScriptedTradeValueTypeData("Currency", varName, native.second));
            } else if (native.first == NodeType::Daycounter) {
                daycounters_.push_back(ScriptedTradeValueTypeData("Daycounter", varName, native.second));
            } else {
                QL_FAIL("unexpected node type");
            }
        } else {
            // if we don't have a value, this is a vector given by some sub node
            if (XMLNode* v = XMLUtils::getChildNode(child, "ScheduleData")) {
                ScheduleData sched;
                sched.fromXML(v);
                events_.push_back(ScriptedTradeEventData(varName, sched));
            } else if (XMLNode* v = XMLUtils::getChildNode(child, "DerivedSchedule")) {
                events_.push_back(ScriptedTradeEventData(varName, XMLUtils::getChildValue(v, "BaseSchedule", true),
                                                         XMLUtils::getChildValue(v, "Shift", true),
                                                         XMLUtils::getChildValue(v, "Calendar", true),
                                                         XMLUtils::getChildValue(v, "Convention", true)));
            } else if (XMLNode* v = XMLUtils::getChildNode(child, "Value")) {
                auto native = getNativeTypeAndValue(XMLUtils::getNodeValue(v), type);
                QL_REQUIRE(native.first != NodeType::Event, "unexpected even array under node '" << varName << "'");
                std::vector<std::string> arrayValues;
                for (XMLNode* val = XMLUtils::getChildNode(child, "Value"); val;
                     val = XMLUtils::getNextSibling(val, "Value")) {
                    auto v = getNativeTypeAndValue(XMLUtils::getNodeValue(val), type);
                    arrayValues.push_back(v.second);
                }
                if (native.first == NodeType::Number) {
                    numbers_.push_back(ScriptedTradeValueTypeData("Number", varName, arrayValues));
                } else if (native.first == NodeType::Index) {
                    indices_.push_back(ScriptedTradeValueTypeData("Index", varName, arrayValues));
                } else if (native.first == NodeType::Currency) {
                    currencies_.push_back(ScriptedTradeValueTypeData("Currency", varName, arrayValues));
                } else if (native.first == NodeType::Daycounter) {
                    daycounters_.push_back(ScriptedTradeValueTypeData("Daycounter", varName, arrayValues));
                } else {
                    QL_FAIL("unexpected node type");
                }
            } else {
                QL_FAIL("unexpected content under node '" << varName << "'");
            }
        }
    }
}

Here is the call graph for this function:

toXML()

XMLNode * toXML ( ore::data::XMLDocument &  doc ) const

overridevirtual

Reimplemented from Trade.

Reimplemented in TaRF, WindowBarrierOption, and WorstOfBasketSwap.

Definition at line 374 of file scriptedtrade.cpp.

                                                    {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* tradeDataNode = doc.allocNode("ScriptedTradeData");
    XMLUtils::appendNode(node, tradeDataNode);
    if (!scriptName_.empty())
        XMLUtils::addChild(doc, tradeDataNode, "ScriptName", scriptName_);
    else {
        XMLUtils::addChild(doc, tradeDataNode, "ProductTag", productTag_);
        for (auto& s : script_) {
            XMLNode* n = s.second.toXML(doc);
            XMLUtils::addAttribute(doc, n, "purpose", s.first);
            XMLUtils::appendNode(tradeDataNode, n);
        }
    }
    XMLNode* dataNode = doc.allocNode("Data");
    XMLUtils::appendNode(tradeDataNode, dataNode);
    for (auto& x : events_)
        XMLUtils::appendNode(dataNode, x.toXML(doc));
    for (auto& x : numbers_)
        XMLUtils::appendNode(dataNode, x.toXML(doc));
    for (auto& x : indices_)
        XMLUtils::appendNode(dataNode, x.toXML(doc));
    for (auto& x : currencies_)
        XMLUtils::appendNode(dataNode, x.toXML(doc));
    for (auto& x : daycounters_)
        XMLUtils::appendNode(dataNode, x.toXML(doc));
    return node;
}

Here is the call graph for this function:

build() [2/2]

void build	(	const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const PremiumData &	premiumData,
		const Real	premiumMultiplier
	)

Definition at line 39 of file scriptedtrade.cpp.

                                                        {
 
    DLOG("ScriptedTrade::build() called for trade " << id());
 
    auto builder = QuantLib::ext::dynamic_pointer_cast<ScriptedTradeEngineBuilder>(engineFactory->builder("ScriptedTrade"));
 
    QL_REQUIRE(builder, "no builder found for ScriptedTrade");
    auto engine = builder->engine(id(), *this, engineFactory->referenceData(), engineFactory->iborFallbackConfig());
 
    simmProductClass_ = builder->simmProductClass();
    scheduleProductClass_ = builder->scheduleProductClass();
 
    setIsdaTaxonomyFields();
 
    auto qleInstr = QuantLib::ext::make_shared<ScriptedInstrument>(builder->lastRelevantDate());
    qleInstr->setPricingEngine(engine);
 
    npvCurrency_ = builder->npvCurrency();
    maturity_ = builder->lastRelevantDate();
    notional_ = Null<Real>(); // is handled by override of notional()
    notionalCurrency_ = "";   // is handled by override of notionalCurrency()
    legs_.clear();
    legCurrencies_.clear();
    legPayers_.clear();
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    maturity_ = std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, 1.0, premiumData,
                                                premiumMultiplier, parseCurrencyWithMinors(npvCurrency_), engineFactory,
                                                builder->configuration(MarketContext::pricing)));
 
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(qleInstr, 1.0, additionalInstruments, additionalMultipliers);
    
    // add required fixings
    for (auto const& f : builder->fixings()) {
        for (auto const& d : f.second) {
            IndexInfo info(f.first);
            if (info.isInf()) {
                QL_DEPRECATED_DISABLE_WARNING
                requiredFixings_.addZeroInflationFixingDate(d, info.infName(), info.inf()->interpolated(),
                                                            info.inf()->frequency(), info.inf()->availabilityLag(),
                                                            CPI::AsIndex, info.inf()->frequency(), Date::maxDate(), false, false);
                QL_DEPRECATED_ENABLE_WARNING
            } else if (info.isFx()) {
                // for FX we do not know if FX-TAG-CCY1-CCY2 or FX-TAG-CCY2-CCY1 is in the history, require both
                requiredFixings_.addFixingDate(d, f.first, Date::maxDate(), false, false);
                requiredFixings_.addFixingDate(d, inverseFxIndex(f.first), Date::maxDate(), false, false);
            } else {
                requiredFixings_.addFixingDate(d, f.first, Date::maxDate(), false, false);
            }
        }
    }
 
    // set sensitivity template
    setSensitivityTemplate(builder->sensitivityTemplate());
}

Here is the call graph for this function:

underlyingIndices()

std::map< ore::data::AssetClass, std::set< std::string > > underlyingIndices ( const QuantLib::ext::shared_ptr< ReferenceDataManager > &  referenceDataManager = nullptr ) const

overridevirtual

Reimplemented from Trade.

Definition at line 226 of file scriptedtrade.cpp.

                                                                                                              {
 
    map<ore::data::AssetClass, set<string>> result;
 
    for (const auto& p : indices_) {
        vector<string> vals;
        if (!p.value().empty())
            vals.push_back(p.value());
        else
            vals = p.values();
 
        for (auto v : vals) {
            if (!v.empty()) {
                IndexInfo ind(v);
                if (ind.isComm()) {
                    result[ore::data::AssetClass::COM].insert(ind.commName());
                } else if (ind.isEq()) {
                    result[ore::data::AssetClass::EQ].insert(ind.eq()->name());
                }
            }
        }
    }
 
    return result;
}

Here is the call graph for this function:

setIsdaTaxonomyFields()

void setIsdaTaxonomyFields ( )

virtual

Reimplemented in Accumulator, Autocallable_01, BasketOption, BasketVarianceSwap, BestEntryOption, PerformanceOption_01, RainbowOption, WindowBarrierOption, and WorstOfBasketSwap.

Definition at line 101 of file scriptedtrade.cpp.

                                          {
    // ISDA taxonomy, can be overwritten in derived classes
    if (scheduleProductClass_ == "FX") {
        additionalData_["isdaAssetClass"] = string("Foreign Exchange");
        additionalData_["isdaBaseProduct"] = string("Complex Exotic");
        additionalData_["isdaSubProduct"] = string("Generic");
        additionalData_["isdaTransaction"] = string("");
    } else if (scheduleProductClass_ == "Rates") {
        additionalData_["isdaAssetClass"] = string("Interest Rate");
        additionalData_["isdaBaseProduct"] = string("Exotic");
        additionalData_["isdaSubProduct"] = string("");
        additionalData_["isdaTransaction"] = string("");
    } else if (scheduleProductClass_ == "Equity") {
        additionalData_["isdaAssetClass"] = string("Equity");
        additionalData_["isdaBaseProduct"] = string("Other");
        additionalData_["isdaSubProduct"] = string("");
        additionalData_["isdaTransaction"] = string("");
    } else if (scheduleProductClass_ == "Credit") {
        additionalData_["isdaAssetClass"] = string("Credit");
        additionalData_["isdaBaseProduct"] = string("Exotic");
        additionalData_["isdaSubProduct"] = string("Other");
        additionalData_["isdaTransaction"] = string("");
    } else if (scheduleProductClass_ == "Commodity") {
        DLOG("ISDA taxonomy for trade " << id() << " and product class " << scheduleProductClass_
                                        << " follows the Equity template");
        additionalData_["isdaAssetClass"] = string("Commodity");
        additionalData_["isdaBaseProduct"] = string("Other");
        additionalData_["isdaSubProduct"] = string("");
        additionalData_["isdaTransaction"] = string("");
    } else {
        DLOG("ISDA taxonomy not set for trade " << id() << " and product class " << scheduleProductClass_);
    }
}

Here is the caller graph for this function:

events()

const std::vector< ScriptedTradeEventData > & events

(

)

const

Definition at line 249 of file scriptedtrade.hpp.

{ return events_; }

Here is the caller graph for this function:

numbers()

const std::vector< ScriptedTradeValueTypeData > & numbers

(

)

const

Definition at line 250 of file scriptedtrade.hpp.

{ return numbers_; }

Here is the caller graph for this function:

indices()

const std::vector< ScriptedTradeValueTypeData > & indices

(

)

const

Definition at line 251 of file scriptedtrade.hpp.

{ return indices_; }

Here is the caller graph for this function:

currencies()

const std::vector< ScriptedTradeValueTypeData > & currencies

(

)

const

Definition at line 252 of file scriptedtrade.hpp.

{ return currencies_; }

Here is the caller graph for this function:

daycounters()

const std::vector< ScriptedTradeValueTypeData > & daycounters

(

)

const

Definition at line 253 of file scriptedtrade.hpp.

{ return daycounters_; }

Here is the caller graph for this function:

script() [1/2]

const std::map< std::string, ScriptedTradeScriptData > & script

(

)

const

Definition at line 254 of file scriptedtrade.hpp.

{ return script_; }

Here is the caller graph for this function:

productTag()

const std::string & productTag

(

)

const

Definition at line 255 of file scriptedtrade.hpp.

{ return productTag_; }

Here is the caller graph for this function:

scriptName()

const std::string & scriptName

(

)

const

Definition at line 256 of file scriptedtrade.hpp.

{ return scriptName_; }

Here is the caller graph for this function:

simmProductClass()

const std::string & simmProductClass

(

)

const

Definition at line 257 of file scriptedtrade.hpp.

{ return simmProductClass_; }

scheduleProductClass()

const std::string & scheduleProductClass

(

)

const

Definition at line 258 of file scriptedtrade.hpp.

{ return scheduleProductClass_; }

script() [2/2]

const ScriptedTradeScriptData & script	(	const std::string &	purpose,
		const bool	fallBackOnEmptyPurpose = true
	)		const

Definition at line 403 of file scriptedtrade.cpp.

                                                                                              {
    auto s1 = script_.find(purpose);
    if (s1 != script_.end())
        return s1->second;
    if (fallBackOnEmptyPurpose) {
        auto s2 = script_.find("");
        if (s2 != script_.end())
            return s2->second;
    }
    QL_FAIL("ScriptedTrade::script(): script with purpose '"
            << purpose << "' not found, fall back on empty purpose was " << std::boolalpha << fallBackOnEmptyPurpose);
}

Member Data Documentation

events_

std::vector<ScriptedTradeEventData> events_

protected

Definition at line 265 of file scriptedtrade.hpp.

numbers_

std::vector<ScriptedTradeValueTypeData> numbers_

protected

Definition at line 266 of file scriptedtrade.hpp.

indices_

std::vector<ScriptedTradeValueTypeData> indices_

protected

Definition at line 267 of file scriptedtrade.hpp.

currencies_

std::vector<ScriptedTradeValueTypeData> currencies_

protected

Definition at line 268 of file scriptedtrade.hpp.

daycounters_

std::vector<ScriptedTradeValueTypeData> daycounters_

protected

Definition at line 269 of file scriptedtrade.hpp.

script_

std::map<std::string, ScriptedTradeScriptData> script_

protected

Definition at line 271 of file scriptedtrade.hpp.

productTag_

std::string productTag_

protected

Definition at line 272 of file scriptedtrade.hpp.

scriptName_

std::string scriptName_

protected

Definition at line 274 of file scriptedtrade.hpp.

simmProductClass_

std::string simmProductClass_

protected

Definition at line 277 of file scriptedtrade.hpp.

scheduleProductClass_

std::string scheduleProductClass_

protected

Definition at line 278 of file scriptedtrade.hpp.