EngineData Class Reference

Pricing engine description. More...

#include <ored/portfolio/enginedata.hpp>

Inheritance diagram for EngineData:

Collaboration diagram for EngineData:

Public Member Functions
	EngineData ()
	Default constructor. More...
Inspectors
bool	hasProduct (const string &productName)
const string &	model (const string &productName) const
const map< string, string > &	modelParameters (const string &productName) const
const string &	engine (const string &productName) const
const map< string, string > &	engineParameters (const string &productName) const
const std::map< std::string, std::string > &	globalParameters () const
vector< string >	products () const
	Return all products. More...
Setters
string &	model (const string &productName)
map< string, string > &	modelParameters (const string &productName)
string &	engine (const string &productName)
map< string, string > &	engineParameters (const string &productName)
std::map< std::string, std::string > &	globalParameters ()
void	clear ()
	Clear all data. 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...

Serialisation
map< string, string >	model_
map< string, map< string, string > >	modelParams_
map< string, string >	engine_
map< string, map< string, string > >	engineParams_
std::map< std::string, std::string >	globalParams_
virtual void	fromXML (XMLNode *node) override
virtual XMLNode *	toXML (XMLDocument &doc) const override

Detailed Description

Pricing engine description.

Definition at line 41 of file enginedata.hpp.

Constructor & Destructor Documentation

EngineData()

EngineData

(

)

Default constructor.

Definition at line 44 of file enginedata.hpp.

{}

Member Function Documentation

hasProduct()

bool hasProduct

(

const string &

productName

)

Definition at line 118 of file enginedata.cpp.

{ return (model_.find(productName) != model_.end()); }

model() [1/2]

const string & model

(

const string &

productName

)

const

Definition at line 49 of file enginedata.hpp.

{ return model_.at(productName); }

Here is the caller graph for this function:

modelParameters() [1/2]

const map< string, string > & modelParameters

(

const string &

productName

)

const

Definition at line 50 of file enginedata.hpp.

{ return modelParams_.at(productName); }

Here is the caller graph for this function:

engine() [1/2]

const string & engine

(

const string &

productName

)

const

Definition at line 51 of file enginedata.hpp.

{ return engine_.at(productName); }

Here is the caller graph for this function:

engineParameters() [1/2]

const map< string, string > & engineParameters

(

const string &

productName

)

const

Definition at line 52 of file enginedata.hpp.

                                                                                 {
        return engineParams_.at(productName);
    }

Here is the caller graph for this function:

globalParameters() [1/2]

const std::map< std::string, std::string > & globalParameters

(

)

const

Definition at line 55 of file enginedata.hpp.

{ return globalParams_; }

products()

vector< string > products

(

)

const

Return all products.

Definition at line 120 of file enginedata.cpp.

                                          {
    vector<string> res;
    for (auto it : model_)
        res.push_back(it.first);
    return res;
}

Here is the caller graph for this function:

model() [2/2]

string & model

(

const string &

productName

)

Definition at line 63 of file enginedata.hpp.

{ return model_[productName]; }

modelParameters() [2/2]

map< string, string > & modelParameters

(

const string &

productName

)

Definition at line 64 of file enginedata.hpp.

{ return modelParams_[productName]; }

engine() [2/2]

string & engine

(

const string &

productName

)

Definition at line 65 of file enginedata.hpp.

{ return engine_[productName]; }

engineParameters() [2/2]

map< string, string > & engineParameters

(

const string &

productName

)

Definition at line 66 of file enginedata.hpp.

{ return engineParams_[productName]; }

globalParameters() [2/2]

std::map< std::string, std::string > & globalParameters

(

)

Definition at line 67 of file enginedata.hpp.

{ return globalParams_; }

clear()

void clear

(

)

Clear all data.

Definition at line 28 of file enginedata.cpp.

                       {
    modelParams_.clear();
    model_.clear();
    engine_.clear();
    engineParams_.clear();
    globalParams_.clear();
}

fromXML()

void fromXML ( XMLNode *  node )

overridevirtual

Implements XMLSerializable.

Definition at line 36 of file enginedata.cpp.

                                      {
    XMLUtils::checkNode(root, "PricingEngines");
 
    // Get global parameters if there are any
    if (XMLNode* node = XMLUtils::getChildNode(root, "GlobalParameters")) {
        DLOG("Processing the GlobalParameters node");
        globalParams_ = XMLUtils::getChildrenAttributesAndValues(node, "Parameter", "name", false);
    }
 
    for (XMLNode* node = XMLUtils::getChildNode(root, "Product"); node;
         node = XMLUtils::getNextSibling(node, "Product")) {
        std::string productName = XMLUtils::getAttribute(node, "type");
 
        model_[productName] = XMLUtils::getChildValue(node, "Model");
        DLOG("EngineData product=" << productName << " model=" << model_[productName]);
 
        XMLNode* modelParams = XMLUtils::getChildNode(node, "ModelParameters");
        map<string, string> modelParamMap;
        for (XMLNode* paramNode = XMLUtils::getChildNode(modelParams, "Parameter"); paramNode;
             paramNode = XMLUtils::getNextSibling(paramNode, "Parameter")) {
            string paramName = XMLUtils::getAttribute(paramNode, "name");
            string paramValue = XMLUtils::getNodeValue(paramNode);
            modelParamMap[paramName] = paramValue;
            DLOG("EngineData product=" << productName << " paramName=" << paramName << " paramValue=" << paramValue);
        }
        modelParams_[productName] = modelParamMap;
 
        engine_[productName] = XMLUtils::getChildValue(node, "Engine");
        DLOG("EngineData product=" << productName << " engine=" << engine_[productName]);
 
        XMLNode* engineParams = XMLUtils::getChildNode(node, "EngineParameters");
        map<string, string> engineParamMap;
        for (XMLNode* paramNode = XMLUtils::getChildNode(engineParams, "Parameter"); paramNode;
             paramNode = XMLUtils::getNextSibling(paramNode, "Parameter")) {
            string paramName = XMLUtils::getAttribute(paramNode, "name");
            string paramValue = XMLUtils::getNodeValue(paramNode);
            engineParamMap[paramName] = paramValue;
            DLOG("EngineData product=" << productName << " paramName=" << paramName << " paramValue=" << paramValue);
        }
        engineParams_[productName] = engineParamMap;
    }
}

Here is the call graph for this function:

toXML()

XMLNode * toXML ( XMLDocument &  doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 79 of file enginedata.cpp.

                                                 {
 
    XMLNode* pricingEnginesNode = doc.allocNode("PricingEngines");
 
    // Add global parameters to XML
    XMLNode* globalParamsNode = XMLUtils::addChild(doc, pricingEnginesNode, "GlobalParameters");
    for (const auto& kv : globalParams_) {
        XMLNode* n = doc.allocNode("Parameter", kv.second);
        XMLUtils::addAttribute(doc, n, "name", kv.first);
        XMLUtils::appendNode(globalParamsNode, n);
        TLOG("Added pair [" << kv.first << "," << kv.second << "] to the GlobalParameters node");
    }
 
    for (auto modelIterator = model_.begin(); modelIterator != model_.end(); modelIterator++) {
 
        XMLNode* productNode = XMLUtils::addChild(doc, pricingEnginesNode, "Product");
        XMLUtils::addAttribute(doc, productNode, "type", modelIterator->first);
        auto engineIterator = engine_.find(modelIterator->first);
        XMLUtils::addChild(doc, productNode, "Model", modelIterator->second);
        XMLUtils::addChild(doc, productNode, "Engine", engineIterator->second);
        XMLNode* modelParametersNode = XMLUtils::addChild(doc, productNode, "ModelParameters");
        for (auto modelParamsIterator = modelParams_.find(modelIterator->first)->second.begin();
             modelParamsIterator != modelParams_.find(modelIterator->first)->second.end(); modelParamsIterator++) {
            XMLNode* parameterNode = doc.allocNode("Parameter", modelParamsIterator->second);
            XMLUtils::appendNode(modelParametersNode, parameterNode);
            XMLUtils::addAttribute(doc, parameterNode, "name", modelParamsIterator->first);
        }
        XMLNode* engineParametersNode = XMLUtils::addChild(doc, productNode, "EngineParameters");
        for (auto engineParamsIterator = engineParams_.find(modelIterator->first)->second.begin();
             engineParamsIterator != engineParams_.find(modelIterator->first)->second.end(); engineParamsIterator++) {
            XMLNode* parameterNode = doc.allocNode("Parameter", engineParamsIterator->second);
            XMLUtils::appendNode(engineParametersNode, parameterNode);
            XMLUtils::addAttribute(doc, parameterNode, "name", engineParamsIterator->first);
        }
    }
    return pricingEnginesNode;
}

Here is the call graph for this function:

Member Data Documentation

model_

map<string, string> model_

private

Definition at line 80 of file enginedata.hpp.

modelParams_

map<string, map<string, string> > modelParams_

private

Definition at line 81 of file enginedata.hpp.

engine_

map<string, string> engine_

private

Definition at line 82 of file enginedata.hpp.

engineParams_

map<string, map<string, string> > engineParams_

private

Definition at line 83 of file enginedata.hpp.

globalParams_

std::map<std::string, std::string> globalParams_

private

Definition at line 84 of file enginedata.hpp.