CurrencyConfig Class Reference

Currency configuration. More...

#include <ored/configuration/currencyconfig.hpp>

Inheritance diagram for CurrencyConfig:

Collaboration diagram for CurrencyConfig:

Public Member Functions
	CurrencyConfig ()
const vector< ConfigurableCurrency > &	getCurrencies () const
	check out any configured currencies More...
void	fromXML (XMLNode *node) override
XMLNode *	toXML (XMLDocument &doc) const override
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...

Private Attributes
vector< ConfigurableCurrency >	currencies_

Detailed Description

Currency configuration.

Allows reading a list of currency specifications from XML rather than hard coding each in QuantExt/QuantLib

Definition at line 49 of file currencyconfig.hpp.

Constructor & Destructor Documentation

CurrencyConfig()

CurrencyConfig

(

)

Definition at line 30 of file currencyconfig.cpp.

{}

Member Function Documentation

getCurrencies()

const vector< ConfigurableCurrency > & getCurrencies

(

)

const

check out any configured currencies

Definition at line 55 of file currencyconfig.hpp.

{ return currencies_; }

fromXML()

void fromXML ( XMLNode *  node )

overridevirtual

Implements XMLSerializable.

Definition at line 32 of file currencyconfig.cpp.

                                              {
    currencies_.clear();
    XMLUtils::checkNode(baseNode, "CurrencyConfig");
 
    for (auto node : XMLUtils::getChildrenNodes(baseNode, "Currency")) {
        string name = XMLUtils::getChildValue(node, "Name", false);
        string isoCode = XMLUtils::getChildValue(node, "ISOCode", false);
    auto tmp = parseListOfValues(XMLUtils::getChildValue(node, "MinorUnitCodes", false));
        std::set<std::string> minorUnitCodes(tmp.begin(), tmp.end());
        try {
            DLOG("Loading external currency configuration for " << isoCode);
            Integer numericCode = parseInteger(XMLUtils::getChildValue(node, "NumericCode", false));
            string symbol = XMLUtils::getChildValue(node, "Symbol", false);
            string fractionSymbol = XMLUtils::getChildValue(node, "Symbol", false);
            Integer fractionsPerUnit = parseInteger(XMLUtils::getChildValue(node, "FractionsPerUnit", false));
            Rounding::Type roundingType = parseRoundingType(XMLUtils::getChildValue(node, "RoundingType", false));
            Integer precision = parseInteger(XMLUtils::getChildValue(node, "RoundingPrecision", false));
            // the digit where we switch form roundng down to rounding up, typically 5 and used across all
            // Integer digit = parseInteger(XMLUtils::getChildValue(node, "Digit", false));
            string format = XMLUtils::getChildValue(node, "Format", false);
            QuantExt::ConfigurableCurrency::Type currencyType = parseCurrencyType(XMLUtils::getChildValue(node, "CurrencyType", false, "Major"));
            Rounding rounding(precision, roundingType);
            QuantExt::ConfigurableCurrency c(name, isoCode, numericCode, symbol, fractionSymbol, fractionsPerUnit,
                                             rounding, format, minorUnitCodes, currencyType);
            DLOG("loading configuration for currency code " << isoCode);
 
            switch (currencyType) { 
                case QuantExt::ConfigurableCurrency::Type::Crypto:
                    CurrencyParser::instance().addCrypto(c.code(), c);
                    break;
                case QuantExt::ConfigurableCurrency::Type::Metal:
                    CurrencyParser::instance().addMetal(c.code(), c);
                    break;
                default:
                    CurrencyParser::instance().addCurrency(c.code(), c);
                    break;
            }
            currencies_.push_back(c);
 
        } catch (std::exception&) {
            ALOG("error loading currency config for name " << name << " iso code " << isoCode);
        }
    }
}

Here is the call graph for this function:

toXML()

XMLNode * toXML ( XMLDocument &  doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 77 of file currencyconfig.cpp.

                                                     {
    XMLNode* node = doc.allocNode("CurrencyConfig");
    for (auto ccy : currencies_) {
        XMLNode* ccyNode = XMLUtils::addChild(doc, node, "Currency");
        XMLUtils::addChild(doc, ccyNode, "Name", ccy.name());
        XMLUtils::addChild(doc, ccyNode, "ISOCode", ccy.code());
        XMLUtils::addGenericChildAsList(
            doc, ccyNode, "MinorUnitCodes",
            std::vector<std::string>(ccy.minorUnitCodes().begin(), ccy.minorUnitCodes().end()));
        XMLUtils::addChild(doc, ccyNode, "NumericCode", to_string(ccy.numericCode()));
        XMLUtils::addChild(doc, ccyNode, "Symbol", ccy.symbol());
        XMLUtils::addChild(doc, ccyNode, "FractionSymbol", ccy.fractionSymbol());
        XMLUtils::addChild(doc, ccyNode, "RoundingType", to_string(ccy.rounding().type()));
        XMLUtils::addChild(doc, ccyNode, "RoundingPrecision", to_string(ccy.rounding().precision()));
        // XMLUtils::addChild(doc, ccyNode, "Digit", to_string(ccy.rounding().roundingDigit()));
        XMLUtils::addChild(doc, ccyNode, "Format", ccy.format());
        XMLUtils::addChild(doc, ccyNode, "CurrencyType", to_string(ccy.currencyType()));
    }
    return node;
}

Here is the call graph for this function:

Member Data Documentation

currencies_

vector<ConfigurableCurrency> currencies_

private

Definition at line 61 of file currencyconfig.hpp.