Conventions Class Reference

Repository for currency dependent market conventions. More...

#include <ored/configuration/conventions.hpp>

Inheritance diagram for Conventions:

Collaboration diagram for Conventions:

Public Member Functions
	Conventions ()
	Default constructor. More...
QuantLib::ext::shared_ptr< Convention >	get (const string &id) const
std::pair< bool, QuantLib::ext::shared_ptr< Convention > >	get (const std::string &id, const Convention::Type &type) const
std::set< QuantLib::ext::shared_ptr< Convention > >	get (const Convention::Type &type) const
QuantLib::ext::shared_ptr< Convention >	getFxConvention (const string &ccy1, const string &ccy2) const
bool	has (const std::string &id) const
	Checks if we have a convention with the given id. More...
bool	has (const std::string &id, const Convention::Type &type) const
	Checks if we have a convention with the given id and type. More...
void	clear () const
void	add (const QuantLib::ext::shared_ptr< Convention > &convention) const
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, QuantLib::ext::shared_ptr< Convention > >	data_
map< string, std::pair< string, string > >	unparsed_
std::set< string >	used_
boost::shared_mutex	mutex_
virtual void	fromXML (XMLNode *node) override
virtual XMLNode *	toXML (XMLDocument &doc) const override

Detailed Description

Repository for currency dependent market conventions.

Definition at line 113 of file conventions.hpp.

Constructor & Destructor Documentation

Conventions()

Conventions

(

)

Default constructor.

Definition at line 116 of file conventions.hpp.

{}

Member Function Documentation

get() [1/3]

QuantLib::ext::shared_ptr< Convention > get

(

const string &

id

)

const

Returns the convention if found and throws if not

Definition at line 2585 of file conventions.cpp.

                                                                         {
 
    {
        boost::shared_lock<boost::shared_mutex> lock(mutex_);
        if (auto it = data_.find(id); it != data_.end()) {
            used_.insert(id);
            return it->second;
        }
        if (auto it = data_.find(flip(id)); it != data_.end()) {
            used_.insert(flip(id));
            return it->second;
        }
    }
 
    std::string type, unparsed;
    {
        boost::unique_lock<boost::shared_mutex> lock(mutex_);
        if (auto it = unparsed_.find(id); it != unparsed_.end()) {
            std::tie(type, unparsed) = it->second;
            unparsed_.erase(id);
        } else if (auto it = unparsed_.find(flip(id)); it != unparsed_.end()) {
            std::tie(type, unparsed) = it->second;
            unparsed_.erase(flip(id));
        }
    }
 
    if (unparsed.empty()) {
        QL_FAIL("Convention '" << id << "' not found.");
    }
 
    QuantLib::ext::shared_ptr<Convention> convention;
    if (type == "Zero") {
        convention = QuantLib::ext::make_shared<ZeroRateConvention>();
    } else if (type == "Deposit") {
        convention = QuantLib::ext::make_shared<DepositConvention>();
    } else if (type == "Future") {
        convention = QuantLib::ext::make_shared<FutureConvention>();
    } else if (type == "FRA") {
        convention = QuantLib::ext::make_shared<FraConvention>();
    } else if (type == "OIS") {
        convention = QuantLib::ext::make_shared<OisConvention>();
    } else if (type == "Swap") {
        convention = QuantLib::ext::make_shared<IRSwapConvention>();
    } else if (type == "AverageOIS") {
        convention = QuantLib::ext::make_shared<AverageOisConvention>();
    } else if (type == "TenorBasisSwap") {
        convention = QuantLib::ext::make_shared<TenorBasisSwapConvention>();
    } else if (type == "TenorBasisTwoSwap") {
        convention=QuantLib::ext::make_shared<TenorBasisTwoSwapConvention>();
    } else if (type == "BMABasisSwap") {
        convention = QuantLib::ext::make_shared<BMABasisSwapConvention>();
    } else if (type == "CrossCurrencyBasis") {
        convention=QuantLib::ext::make_shared<CrossCcyBasisSwapConvention>();
    } else if (type == "CrossCurrencyFixFloat") {
        convention=QuantLib::ext::make_shared<CrossCcyFixFloatSwapConvention>();
    } else if (type == "CDS") {
        convention=QuantLib::ext::make_shared<CdsConvention>();
    } else if (type == "SwapIndex") {
        convention=QuantLib::ext::make_shared<SwapIndexConvention>();
    } else if (type == "InflationSwap") {
        convention=QuantLib::ext::make_shared<InflationSwapConvention>();
    } else if (type == "CmsSpreadOption") {
        convention=QuantLib::ext::make_shared<CmsSpreadOptionConvention>();
    } else if (type == "CommodityForward") {
        convention = QuantLib::ext::make_shared<CommodityForwardConvention>();
    } else if (type == "CommodityFuture") {
        convention = QuantLib::ext::make_shared<CommodityFutureConvention>();
    } else if (type == "FxOption") {
        convention = QuantLib::ext::make_shared<FxOptionConvention>();
    } else if (type == "ZeroInflationIndex") {
        convention = QuantLib::ext::make_shared<ZeroInflationIndexConvention>();
    } else if (type == "BondYield") {
        convention = QuantLib::ext::make_shared<BondYieldConvention>();
    } else {
        QL_FAIL("Convention '" << id << "' has unknown type '" + type + "' not recognized.");
    }
 
    try {
        DLOG("Building Convention " << id);
        convention->fromXMLString(unparsed);
        add(convention);
        used_.insert(id);
    } catch (exception& e) {
        WLOG("Convention '" << id << "' could not be built: " << e.what());
        QL_FAIL("Convention '" << id << "' could not be built: " << e.what());
    }
 
    return convention;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get() [2/3]

pair< bool, QuantLib::ext::shared_ptr< Convention > > get	(	const std::string &	id,
		const Convention::Type &	type
	)		const

Get a convention with the given id and type. If no convention of the given type with the given id is found, the first element of the returned pair is false and the second element is a nullptr. If a convention is found, the first element of the returned pair is true and the second element holds the convention.

Definition at line 2691 of file conventions.cpp.

                                                                                                                 {
    try {
        auto c = get(id);
        if (c->type() == type) {
            used_.insert(id);
            return std::make_pair(true, c);
        }
    } catch (const std::exception& e) {
    }
    return make_pair(false, nullptr);
}

Here is the call graph for this function:

get() [3/3]

std::set< QuantLib::ext::shared_ptr< Convention > > get

(

const Convention::Type &

type

)

const

Get all conventions of a given type

Definition at line 2703 of file conventions.cpp.

                                                                                           {
    std::set<QuantLib::ext::shared_ptr<Convention>> result;
    std::set<std::string> unparsedIds;
    std::string typeStr = ore::data::to_string(type);
    {
        boost::shared_lock<boost::shared_mutex> lock(mutex_);
        for (auto const& d : data_) {
            if (d.second->type() == type) {
                used_.insert(d.first);
                result.insert(d.second);
            }
        }
        for (auto const& u : unparsed_) {
            if (u.second.first == typeStr)
                unparsedIds.insert(u.first);
        }
    }
    for (auto const& id : unparsedIds) {
        result.insert(get(id));
    }
    return result;
}

Here is the call graph for this function:

getFxConvention()

QuantLib::ext::shared_ptr< Convention > getFxConvention	(	const string &	ccy1,
		const string &	ccy2
	)		const

Find a convention for an FX pair

Definition at line 2675 of file conventions.cpp.

                                                                                                           {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    for (auto c : data_) {
        auto fxCon = QuantLib::ext::dynamic_pointer_cast<FXConvention>(c.second);
        if (fxCon) {
            string source = fxCon->sourceCurrency().code();
            string target = fxCon->targetCurrency().code();
            if ((source == ccy1 && target == ccy2) || (target == ccy1 && source == ccy2)) {
                used_.insert(c.first);
                return fxCon;
            }
        }
    }
    QL_FAIL("FX convention for ccys '" << ccy1 << "' and '" << ccy2 << "' not found.");
}

has() [1/2]

bool has

(

const std::string &

id

)

const

Checks if we have a convention with the given id.

Definition at line 2726 of file conventions.cpp.

                                            {
    try {
        get(id);
    } catch (const std::exception& e) {
        return false;
    }
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    return data_.find(id) != data_.end() || unparsed_.find(id) != unparsed_.end() ||
           data_.find(flip(id)) != data_.end() || unparsed_.find(flip(id)) != unparsed_.end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

has() [2/2]

bool has	(	const std::string &	id,
		const Convention::Type &	type
	)		const

Checks if we have a convention with the given id and type.

Definition at line 2737 of file conventions.cpp.

                                                                           {
    return get(id, type).first;
}

Here is the call graph for this function:

clear()

void clear

(

)

const

Clear all conventions

Definition at line 2558 of file conventions.cpp.

                              {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    data_.clear();
}

add()

void add

(

const QuantLib::ext::shared_ptr< Convention > &

convention

)

const

Add a convention. This will overwrite an existing convention with the same id

Definition at line 2741 of file conventions.cpp.

                                                                               {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    const string& id = convention->id();
    QL_REQUIRE(data_.find(id) == data_.end(), "Convention already exists for id " << id);
    data_[id] = convention;
}

Here is the caller graph for this function:

fromXML()

void fromXML ( XMLNode *  node )

overridevirtual

Implements XMLSerializable.

Definition at line 2493 of file conventions.cpp.

                                       {
    XMLUtils::checkNode(node, "Conventions");
 
    for (XMLNode* child = XMLUtils::getChildNode(node); child; child = XMLUtils::getNextSibling(child)) {
 
        string type = XMLUtils::getNodeName(child);
        QuantLib::ext::shared_ptr<Convention> convention;
 
        /* we need to build conventions of type
 
           - IborIndex
           - OvernightIndex
           - FX
 
           immediately because
 
           - for IborIndex other conventions depend on it via parseIborIndex() calls
           - the id of IborIndex convention is changed during build (period is normalized)
           - FX conventions are searched by currencies, not id */
 
        if (type == "IborIndex") {
            convention = QuantLib::ext::make_shared<IborIndexConvention>();
        } else if (type == "FX") {
            convention = QuantLib::ext::make_shared<FXConvention>();
        } else if (type == "OvernightIndex") {
            convention = QuantLib::ext::make_shared<OvernightIndexConvention>();
        }
 
        string id = "unknown";
        if (convention) {
            try {
                id = XMLUtils::getChildValue(child, "Id", true);
                DLOG("Building Convention " << id);
                convention->fromXML(child);
                add(convention);
            } catch (const std::exception& e) {
                WLOG("Exception parsing convention "
                     << id << ": " << e.what() << ". This is only a problem if this convention is used later on.");
            }
        } else {
            try {
                id = XMLUtils::getChildValue(child, "Id", true);
                DLOG("Reading Convention " << id);
                unparsed_[id] = std::make_pair(type, XMLUtils::toString(child));
            } catch (const std::exception& e) {
                WLOG("Exception during retrieval of convention "
                     << id << ": " << e.what() << ". This is only a problem if this convention is used later on.");
            }
        }
    }
}

Here is the call graph for this function:

toXML()

XMLNode * toXML ( XMLDocument &  doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 2545 of file conventions.cpp.

                                                  {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
 
    XMLNode* conventionsNode = doc.allocNode("Conventions");
 
    map<string, QuantLib::ext::shared_ptr<Convention>>::const_iterator it;
    for (it = data_.begin(); it != data_.end(); ++it) {
        if (used_.find(it->first) != used_.end())
            XMLUtils::appendNode(conventionsNode, it->second->toXML(doc));
    }
    return conventionsNode;
}

Here is the call graph for this function:

Member Data Documentation

data_

map<string, QuantLib::ext::shared_ptr<Convention> > data_

mutableprivate

Definition at line 154 of file conventions.hpp.

unparsed_

map<string, std::pair<string, string> > unparsed_

mutableprivate

Definition at line 155 of file conventions.hpp.

used_

std::set<string> used_

mutableprivate

Definition at line 156 of file conventions.hpp.

mutex_

boost::shared_mutex mutex_

mutableprivate

Definition at line 157 of file conventions.hpp.