BasicReferenceDataManager Class Reference

Basic Concrete impl that loads an big XML and keeps data in memory. More...

#include <ored/portfolio/referencedata.hpp>

Inheritance diagram for BasicReferenceDataManager:

Collaboration diagram for BasicReferenceDataManager:

Public Member Functions
	BasicReferenceDataManager ()
	BasicReferenceDataManager (const string &filename)
void	appendData (const string &filename)
QuantLib::ext::shared_ptr< ReferenceDatum >	buildReferenceDatum (const string &refDataType)
void	fromXML (XMLNode *node) override
XMLNode *	toXML (ore::data::XMLDocument &doc) const override
void	clear ()
bool	hasData (const string &type, const string &id, const QuantLib::Date &asof=QuantLib::Null< QuantLib::Date >()) override
QuantLib::ext::shared_ptr< ReferenceDatum >	getData (const string &type, const string &id, const QuantLib::Date &asof=QuantLib::Null< QuantLib::Date >()) override
void	add (const QuantLib::ext::shared_ptr< ReferenceDatum > &referenceDatum) override
QuantLib::ext::shared_ptr< ReferenceDatum >	addFromXMLNode (XMLNode *node, const std::string &id=std::string(), const QuantLib::Date &validFrom=QuantLib::Null< QuantLib::Date >())
Public Member Functions inherited from ReferenceDataManager
virtual	~ReferenceDataManager ()
virtual bool	hasData (const string &type, const string &id, const QuantLib::Date &asof=QuantLib::Null< QuantLib::Date >())=0
virtual QuantLib::ext::shared_ptr< ReferenceDatum >	getData (const string &type, const string &id, const QuantLib::Date &asof=QuantLib::Null< QuantLib::Date >())=0
virtual void	add (const QuantLib::ext::shared_ptr< ReferenceDatum > &referenceDatum)=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)
	Parse from XML string. More...
std::string	toXMLString () const
	Parse from XML string. More...

Protected Member Functions
std::tuple< QuantLib::Date, QuantLib::ext::shared_ptr< ReferenceDatum > >	latestValidFrom (const string &type, const string &id, const QuantLib::Date &asof) const
void	check (const string &type, const string &id, const QuantLib::Date &asof) const

Protected Attributes
map< std::pair< string, string >, std::map< QuantLib::Date, QuantLib::ext::shared_ptr< ReferenceDatum > > >	data_
std::set< std::tuple< string, string, QuantLib::Date > >	duplicates_
map< std::pair< string, string >, std::map< QuantLib::Date, string > >	buildErrors_

Detailed Description

Basic Concrete impl that loads an big XML and keeps data in memory.

Definition at line 560 of file referencedata.hpp.

Constructor & Destructor Documentation

BasicReferenceDataManager() [1/2]

BasicReferenceDataManager

(

)

Definition at line 562 of file referencedata.hpp.

{}

BasicReferenceDataManager() [2/2]

BasicReferenceDataManager

(

const string &

filename

)

Definition at line 563 of file referencedata.hpp.

{ fromFile(filename); }

Here is the call graph for this function:

Member Function Documentation

appendData()

void appendData

(

const string &

filename

)

Definition at line 566 of file referencedata.hpp.

{ fromFile(filename); }

Here is the call graph for this function:

buildReferenceDatum()

QuantLib::ext::shared_ptr< ReferenceDatum > buildReferenceDatum

(

const string &

refDataType

)

Definition at line 688 of file referencedata.cpp.

                                                                                                              {
    auto refData = ReferenceDatumFactory::instance().build(refDataType);
    QL_REQUIRE(refData,
               "Reference data type " << refDataType << " has not been registered with the reference data factory.");
    return refData;
}

Here is the caller graph for this function:

fromXML()

void fromXML ( XMLNode *  node )

overridevirtual

Implements XMLSerializable.

Definition at line 620 of file referencedata.cpp.

                                                     {
    XMLUtils::checkNode(node, "ReferenceData");
    for (XMLNode* child = XMLUtils::getChildNode(node, "ReferenceDatum"); child;
         child = XMLUtils::getNextSibling(child, "ReferenceDatum")) {
        addFromXMLNode(child);
    }
}

Here is the call graph for this function:

toXML()

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

overridevirtual

Implements XMLSerializable.

Definition at line 695 of file referencedata.cpp.

                                                                {
    XMLNode* node = doc.allocNode("ReferenceData");
    for (const auto& kv : data_) {
        for (const auto& [_, refData] : kv.second) {
            XMLUtils::appendNode(node, refData->toXML(doc));
        }
    }
    return node;
}

Here is the call graph for this function:

clear()

void clear

(

)

Definition at line 574 of file referencedata.hpp.

{ data_.clear(); }

hasData()

bool hasData ( const string &  type, const string &  id, const QuantLib::Date &  asof = QuantLib::Null<QuantLib::Date>()  )

overridevirtual

Implements ReferenceDataManager.

Definition at line 732 of file referencedata.cpp.

                                                                                                      {
    Date asofDate = asof;
    if (asofDate == QuantLib::Null<QuantLib::Date>()) {
        asofDate = Settings::instance().evaluationDate();
    }
    auto [validFrom, refData] = latestValidFrom(type, id, asofDate);
    check(type, id, validFrom);
    return refData != nullptr;
}

Here is the call graph for this function:

getData()

QuantLib::ext::shared_ptr< ReferenceDatum > getData ( const string &  type, const string &  id, const QuantLib::Date &  asof = QuantLib::Null<QuantLib::Date>()  )

overridevirtual

Implements ReferenceDataManager.

Definition at line 742 of file referencedata.cpp.

                                                                                               {
    Date asofDate = asof;
    if (asofDate == QuantLib::Null<QuantLib::Date>()) {
        asofDate = Settings::instance().evaluationDate();
    }
    auto [validFrom, refData] = latestValidFrom(type, id, asofDate);
    check(type, id, validFrom);
    QL_REQUIRE(refData != nullptr, "BasicReferenceDataManager::getData(): No Reference data for type='"
                                       << type << "', id='" << id << "', asof='" << asof << "'");
    return refData;
}

Here is the call graph for this function:

add()

void add ( const QuantLib::ext::shared_ptr< ReferenceDatum > &  referenceDatum )

overridevirtual

Implements ReferenceDataManager.

Definition at line 628 of file referencedata.cpp.

                                                                                   {
    // Add reference datum, it is overwritten if it is already present.
    data_[make_pair(rd->type(), rd->id())][rd->validFrom()] = rd;
}

addFromXMLNode()

QuantLib::ext::shared_ptr< ReferenceDatum > addFromXMLNode	(	XMLNode *	node,
		const std::string &	id = std::string(),
		const QuantLib::Date &	validFrom = QuantLib::Null<QuantLib::Date>()
	)

Definition at line 633 of file referencedata.cpp.

                                                                                                                {
    string refDataType = XMLUtils::getChildValue(node, "Type", false);
    QuantLib::ext::shared_ptr<ReferenceDatum> refData;
 
    if (refDataType.empty()) {
        ALOG("Found referenceDatum without Type - skipping");
        return refData;
    }
 
    string id = inputId.empty() ? XMLUtils::getAttribute(node, "id") : inputId;
    
    string validFromStr = XMLUtils::getAttribute(node, "validFrom");
    QuantLib::Date validFrom;
    if (validFromStr.empty()) {
        validFrom = QuantLib::Date::minDate();
    } else {
        validFrom = ore::data::parseDate(validFromStr);
    }
 
    validFrom = inputValidFrom == QuantLib::Null<QuantLib::Date>() ? validFrom : inputValidFrom;
 
    if (id.empty()) {
        ALOG("Found referenceDatum without id - skipping");
        return refData;
    }
 
    if (auto it = data_.find(make_pair(refDataType, id)); it != data_.end()) {
        if (it->second.count(validFrom) > 0) {
            duplicates_.insert(make_tuple(refDataType, id, validFrom));
            ALOG("Found duplicate referenceDatum for type='" << refDataType << "', id='" << id << "', validFrom='"
                                                             << validFrom << "'");
            return refData;
        }
    }
 
    try {
        refData = buildReferenceDatum(refDataType);
        refData->fromXML(node);
        // set the type and id at top level (is this needed?)
        refData->setType(refDataType);
        refData->setId(id);
        refData->setValidFrom(validFrom);
        data_[make_pair(refDataType, id)][validFrom] = refData;
        TLOG("added referenceDatum for type='" << refDataType << "', id='" << id << "', validFrom='" << validFrom
                                               << "'");
    } catch (const std::exception& e) {
        buildErrors_[make_pair(refDataType, id)][validFrom] = e.what();
        ALOG("Error building referenceDatum for type='" << refDataType << "', id='" << id << "', validFrom='" << validFrom
                                               << "': " << e.what());
    }
 
    return refData;
}

Here is the call graph for this function:

Here is the caller graph for this function:

latestValidFrom()

std::tuple< QuantLib::Date, QuantLib::ext::shared_ptr< ReferenceDatum > > latestValidFrom ( const string &  type, const string &  id, const QuantLib::Date &  asof  ) const

protected

Definition at line 705 of file referencedata.cpp.

                                                                                          {   
    auto it = data_.find(make_pair(type, id));
    if (it != data_.end() && !it->second.empty()){
        auto uB = it->second.upper_bound(asof);
        if (uB != it->second.begin()) {
            return *(--uB);
        } 
    }
    return {QuantLib::Date(), nullptr};
}

Here is the caller graph for this function:

check()

void check ( const string &  type, const string &  id, const QuantLib::Date &  asof  ) const

protected

Definition at line 717 of file referencedata.cpp.

                                                                                                               {
    auto key = make_tuple(type, id, validFrom);
    if (duplicates_.find(key) != duplicates_.end())
        ALOG("BasicReferenceDataManager: duplicate entries for type='" << type << "', id='" << id << "', validFrom='"
                                                                       << validFrom << "'");
    auto err = buildErrors_.find(make_pair(type, id));
    if (err != buildErrors_.end()) {
        for (const auto& [validFrom, error] : err->second) {
            ALOG("BasicReferenceDataManager: Build error for type='" << type << "', id='" << id << "', validFrom='"
                                                                     << validFrom << "': " << error);
        }
    }
        
}

Member Data Documentation

data_

map<std::pair<string, string>, std::map<QuantLib::Date, QuantLib::ext::shared_ptr<ReferenceDatum> > > data_

protected

Definition at line 589 of file referencedata.hpp.

duplicates_

std::set<std::tuple<string, string, QuantLib::Date> > duplicates_

protected

Definition at line 590 of file referencedata.hpp.

buildErrors_

map<std::pair<string, string>, std::map<QuantLib::Date, string> > buildErrors_

protected

Definition at line 591 of file referencedata.hpp.