SimmBasicNameMapper Class Reference

#include <orea/simm/simmbasicnamemapper.hpp>

Inheritance diagram for SimmBasicNameMapper:

Collaboration diagram for SimmBasicNameMapper:

Public Member Functions
std::string	qualifier (const std::string &externalName) const override
std::string	validTo (const std::string &externalName) const
	Qualifier mapping expiry (ISO date), may be blank and interpreted as QL::maxDate() More...
QuantLib::Date	validToDate (const std::string &externalName) const
	Qualifier mapping expiry (QuantLib date) More...
std::string	validFrom (const std::string &externalName) const
	Qualifier mapping start date (ISO date), may be blank and interpreted as QL::minDate() More...
QuantLib::Date	validFromDate (const std::string &externalName) const
	Qualifier mapping startDate (QuantLib date) More...
bool	hasQualifier (const std::string &externalName) const override
	Has qualifier. More...
bool	hasValidQualifier (const std::string &externalName, const QuantLib::Date &referenceDate) const
	Has qualifier that is valid w.r.t. given reference date. More...
std::string	externalName (const std::string &qualifier) const override
	reverse lookup on qualifier More...
Public Member Functions inherited from SimmNameMapper
virtual	~SimmNameMapper ()
	Destructor. More...
virtual std::string	qualifier (const std::string &externalName) const =0
virtual bool	hasQualifier (const std::string &externalName) const =0
virtual std::string	externalName (const std::string &qualifier) const =0
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)
std::string	toXMLString () const

Serialisation
std::map< std::string, std::string >	mapping_
std::map< std::string, std::string >	validFrom_
std::map< std::string, std::string >	validTo_
ore::data::XMLNode *	toXML (ore::data::XMLDocument &doc) const override
void	fromXML (ore::data::XMLNode *node) override
void	addMapping (const std::string &externalName, const std::string &qualifier, const std::string &validFrom="", const std::string &validTo="")
	Add a single mapping. More...

Detailed Description

Definition at line 35 of file simmbasicnamemapper.hpp.

Member Function Documentation

qualifier()

string qualifier ( const std::string &  externalName ) const

overridevirtual

Return the SIMM Qualifier for a given external name.

Warning:

If the externalName cannot be mapped to a qualifier the externalName itself is returned. In this way, the mapper is basic and places the burden on the caller to call it only when a mapping is needed.

Implements SimmNameMapper.

Definition at line 35 of file simmbasicnamemapper.cpp.

                                                                      {
    // Returns mapping if there is one found else returns the externalName
    auto m = mapping_.find(externalName);
    if (m != mapping_.end()) {
        Date vt = validToDate(externalName);
        Date vf = validFromDate(externalName);
        Date today = Settings::instance().evaluationDate();
        if (vt >= today && vf <= today)
            return m->second;
        else {
            ALOG("Name mapping for external name " << externalName << " is expired");
            return externalName;
        }
    } else {
        return externalName;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

validTo()

string validTo

(

const std::string &

externalName

)

const

Qualifier mapping expiry (ISO date), may be blank and interpreted as QL::maxDate()

Definition at line 53 of file simmbasicnamemapper.cpp.

                                                                    {
    // Returns mapping expiry date string
    auto v = validTo_.find(externalName);
    if (v  != validTo_.end())
        return v->second;
    else
        return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

validToDate()

Date validToDate

(

const std::string &

externalName

)

const

Qualifier mapping expiry (QuantLib date)

Definition at line 71 of file simmbasicnamemapper.cpp.

                                                                      {
    // Returns mapping expiry date
    string valid = validTo_.at(externalName);
    if (!valid.empty())
        return ore::data::parseDate(valid);
    else
        return Date::maxDate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

validFrom()

string validFrom

(

const std::string &

externalName

)

const

Qualifier mapping start date (ISO date), may be blank and interpreted as QL::minDate()

Definition at line 62 of file simmbasicnamemapper.cpp.

                                                                      {
    // Returns mapping start date string
    auto v = validFrom_.find(externalName);
    if (v != validFrom_.end())
        return v->second;
    else
        return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

validFromDate()

Date validFromDate

(

const std::string &

externalName

)

const

Qualifier mapping startDate (QuantLib date)

Definition at line 80 of file simmbasicnamemapper.cpp.

                                                                        {
    // Returns mapping start date
    string valid = validFrom_.at(externalName);
    if (!valid.empty())
        return ore::data::parseDate(valid);
    else
        return Date::minDate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

hasQualifier()

bool hasQualifier ( const std::string &  externalName ) const

overridevirtual

Has qualifier.

Implements SimmNameMapper.

Definition at line 89 of file simmbasicnamemapper.cpp.

{ return mapping_.count(externalName) > 0; }

Here is the call graph for this function:

Here is the caller graph for this function:

hasValidQualifier()

bool hasValidQualifier	(	const std::string &	externalName,
		const QuantLib::Date &	referenceDate
	)		const

Has qualifier that is valid w.r.t. given reference date.

Definition at line 91 of file simmbasicnamemapper.cpp.

                                                                                     {
    return hasQualifier(externalName) && validFromDate(externalName) <= referenceDate &&
           referenceDate <= validToDate(externalName);
}

Here is the call graph for this function:

externalName()

std::string externalName ( const std::string &  qualifier ) const

overridevirtual

reverse lookup on qualifier

Implements SimmNameMapper.

Definition at line 97 of file simmbasicnamemapper.cpp.

                                                                            {
    for (auto it = mapping_.begin(); it != mapping_.end(); ++it)
        if (it->second == qualifier)
            return it->first;
    return qualifier;
}

Here is the call graph for this function:

Here is the caller graph for this function:

toXML()

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

overridevirtual

Implements XMLSerializable.

Definition at line 152 of file simmbasicnamemapper.cpp.

                                                                 {
 
    LOG("Start toXML for SIMM name mappings");
 
    XMLNode* node = doc.allocNode("SIMMNameMappings");
    for (const auto& kv : mapping_) {
        XMLNode* mappingNode = doc.allocNode("Mapping");
        string vt = validTo(kv.first);
        if (vt != "")
            XMLUtils::addChild(doc, mappingNode, "ValidTo", vt);
        string vf = validFrom(kv.first);
        if (vf != "")
            XMLUtils::addChild(doc, mappingNode, "ValidFrom", vf);
        XMLUtils::addChild(doc, mappingNode, "Name", kv.first);
        XMLUtils::addChild(doc, mappingNode, "Qualifier", kv.second);
        XMLUtils::appendNode(node, mappingNode);
    }
 
    LOG("Finished toXML for SIMM name mappings");
 
    return node;
}

Here is the call graph for this function:

fromXML()

void fromXML ( ore::data::XMLNode *  node )

overridevirtual

Implements XMLSerializable.

Definition at line 104 of file simmbasicnamemapper.cpp.

                                               {
    XMLUtils::checkNode(node, "SIMMNameMappings");
 
    // Every time a call to fromXML is made, the map is cleared
    mapping_.clear();
 
    LOG("Start parsing SIMMNameMappings");
 
    for (XMLNode* mappingNode = XMLUtils::getChildNode(node, "Mapping"); mappingNode;
         mappingNode = XMLUtils::getNextSibling(mappingNode, "Mapping")) {
 
        string validTo = XMLUtils::getChildValue(mappingNode, "ValidTo", false);
        string validFrom = XMLUtils::getChildValue(mappingNode, "ValidFrom", false);
        string name = XMLUtils::getChildValue(mappingNode, "Name", false);
        string qualifier = XMLUtils::getChildValue(mappingNode, "Qualifier", false);
        if (name == "" || qualifier == "") {
            ALOG("skip name mapping for name '" << name << "' and qualifier '" << qualifier << "'"); 
            continue;
        }
        
        if (validTo != "") {
            // Check whether the provided validTo attribute is a valid date, ALERT and ignore if it is not
            try {
                ore::data::parseDate(validTo);
             } catch(std::exception&) {
                ALOG("Cannot parse name mapping validTo " << validTo << " for qualifier " << qualifier << ", ignore");
                validTo = "";
            }
        }  
 
        if (validFrom != "") {
            // Check whether the provided validTo attribute is a valid date, ALERT and ignore if it is not
            try {
                ore::data::parseDate(validFrom);
             } catch(std::exception&) {
                ALOG("Cannot parse name mapping validFrom " << validFrom << " for qualifier " << qualifier << ", ignore");
                validFrom = "";
            }
        }  
 
        mapping_[name] = qualifier;
        validTo_[name] = validTo;
        validFrom_[name] = validFrom;
    }
 
    LOG("Finished parsing SIMMNameMappings");
}

Here is the call graph for this function:

addMapping()

void addMapping	(	const std::string &	externalName,
		const std::string &	qualifier,
		const std::string &	validFrom = "",
		const std::string &	validTo = ""
	)

Add a single mapping.

Definition at line 175 of file simmbasicnamemapper.cpp.

                                                               {
    // Just overwrite if name already exists
    mapping_[externalName] = qualifier;
    validTo_[externalName] = validTo;
    validFrom_[externalName] = validFrom;
    if (validTo != "") {
        try {
            ore::data::parseDate(validTo);
        } catch (std::exception&) {
            ALOG("Cannot parse name mapping validTo " << validTo << " for qualifier " << qualifier << ", ignore");
            validTo_[externalName] = "";
        }
    }
    if (validFrom != "") {
        try {
            ore::data::parseDate(validFrom);
        } catch (std::exception&) {
            ALOG("Cannot parse name mapping validTo " << validFrom << " for qualifier " << qualifier << ", ignore");
            validFrom_[externalName] = "";
        }
    }
}

Here is the call graph for this function:

Member Data Documentation

mapping_

std::map<std::string, std::string> mapping_

protected

A mapping from external name to SIMM Qualifier

Definition at line 81 of file simmbasicnamemapper.hpp.

validFrom_

std::map<std::string, std::string> validFrom_

protected

Start and expiry date (ISO) of each mapping

Definition at line 85 of file simmbasicnamemapper.hpp.

validTo_

std::map<std::string, std::string> validTo_

protected

Definition at line 85 of file simmbasicnamemapper.hpp.