EngineBuilderFactory Class Reference

Engine/ Leg Builder Factory - notice that both engine and leg builders are allowed to maintain a state. More...

#include <ored/portfolio/enginefactory.hpp>

Inheritance diagram for EngineBuilderFactory:

Collaboration diagram for EngineBuilderFactory:

Public Member Functions
void	addEngineBuilder (const std::function< QuantLib::ext::shared_ptr< EngineBuilder >()> &builder, const bool allowOverwrite=false)
void	addAmcEngineBuilder (const std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &cam, const std::vector< Date > &grid)> &builder, const bool allowOverwrite=false)
void	addAmcCgEngineBuilder (const std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< ore::data::ModelCG > &model, const std::vector< Date > &grid)> &builder, const bool allowOverwrite=false)
void	addLegBuilder (const std::function< QuantLib::ext::shared_ptr< LegBuilder >()> &builder, const bool allowOverwrite=false)
std::vector< QuantLib::ext::shared_ptr< EngineBuilder > >	generateEngineBuilders () const
std::vector< QuantLib::ext::shared_ptr< EngineBuilder > >	generateAmcEngineBuilders (const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &cam, const std::vector< Date > &grid) const
std::vector< QuantLib::ext::shared_ptr< EngineBuilder > >	generateAmcCgEngineBuilders (const QuantLib::ext::shared_ptr< ore::data::ModelCG > &model, const std::vector< Date > &grid) const
std::vector< QuantLib::ext::shared_ptr< LegBuilder > >	generateLegBuilders () const

Private Attributes
std::vector< std::function< QuantLib::ext::shared_ptr< EngineBuilder >()> >	engineBuilderBuilders_
std::vector< std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &cam, const std::vector< Date > &grid)> >	amcEngineBuilderBuilders_
std::vector< std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< ore::data::ModelCG > &model, const std::vector< Date > &grid)> >	amcCgEngineBuilderBuilders_
std::vector< std::function< QuantLib::ext::shared_ptr< LegBuilder >()> >	legBuilderBuilders_
boost::shared_mutex	mutex_

Detailed Description

Engine/ Leg Builder Factory - notice that both engine and leg builders are allowed to maintain a state.

Definition at line 174 of file enginefactory.hpp.

Member Function Documentation

addEngineBuilder()

void addEngineBuilder	(	const std::function< QuantLib::ext::shared_ptr< EngineBuilder >()> &	builder,
		const bool	allowOverwrite = false
	)

Definition at line 65 of file enginefactory.cpp.

                                                                       {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    auto tmp = builder();
    auto key = make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
    auto it = std::remove_if(engineBuilderBuilders_.begin(), engineBuilderBuilders_.end(),
                             [&key](std::function<QuantLib::ext::shared_ptr<EngineBuilder>()>& b) {
                                 auto tmp = b();
                                 return key == std::make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
                             });
    QL_REQUIRE(it == engineBuilderBuilders_.end() || allowOverwrite,
               "EngineBuilderFactory::addEngineBuilder(" << tmp->model() << "/" << tmp->engine() << "/"
                                                         << boost::algorithm::join(tmp->tradeTypes(), ",")
                                                         << "): builder for given key already exists.");
    engineBuilderBuilders_.erase(it, engineBuilderBuilders_.end());
    engineBuilderBuilders_.push_back(builder);
}

addAmcEngineBuilder()

void addAmcEngineBuilder	(	const std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &cam, const std::vector< Date > &grid)> &	builder,
		const bool	allowOverwrite = false
	)

Definition at line 83 of file enginefactory.cpp.

                               {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    auto tmp = builder(nullptr, {});
    auto key = make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
    auto it = std::remove_if(
        amcEngineBuilderBuilders_.begin(), amcEngineBuilderBuilders_.end(),
        [&key](std::function<QuantLib::ext::shared_ptr<EngineBuilder>(const QuantLib::ext::shared_ptr<QuantExt::CrossAssetModel>& cam,
                                                              const std::vector<Date>& grid)>& b) {
            auto tmp = b(nullptr, {});
            return key == std::make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
        });
    QL_REQUIRE(it == amcEngineBuilderBuilders_.end() || allowOverwrite,
               "EngineBuilderFactory::addAmcEngineBuilder(" << tmp->model() << "/" << tmp->engine() << "/"
                                                            << boost::algorithm::join(tmp->tradeTypes(), ",")
                                                            << "): builder for given key already exists.");
    amcEngineBuilderBuilders_.erase(it, amcEngineBuilderBuilders_.end());
    amcEngineBuilderBuilders_.push_back(builder);
}

addAmcCgEngineBuilder()

void addAmcCgEngineBuilder	(	const std::function< QuantLib::ext::shared_ptr< EngineBuilder >(const QuantLib::ext::shared_ptr< ore::data::ModelCG > &model, const std::vector< Date > &grid)> &	builder,
		const bool	allowOverwrite = false
	)

Definition at line 105 of file enginefactory.cpp.

                               {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    auto tmp = builder(nullptr, {});
    auto key = make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
    auto it = std::remove_if(
        amcCgEngineBuilderBuilders_.begin(), amcCgEngineBuilderBuilders_.end(),
        [&key](std::function<QuantLib::ext::shared_ptr<EngineBuilder>(const QuantLib::ext::shared_ptr<ore::data::ModelCG>& model,
                                                              const std::vector<Date>& grid)>& b) {
            auto tmp = b(nullptr, {});
            return key == std::make_tuple(tmp->model(), tmp->engine(), tmp->tradeTypes());
        });
    QL_REQUIRE(it == amcCgEngineBuilderBuilders_.end() || allowOverwrite,
               "EngineBuilderFactory::addAmcCgEngineBuilder(" << tmp->model() << "/" << tmp->engine() << "/"
                                                              << boost::algorithm::join(tmp->tradeTypes(), ",")
                                                              << "): builder for given key already exists.");
    amcCgEngineBuilderBuilders_.erase(it, amcCgEngineBuilderBuilders_.end());
    amcCgEngineBuilderBuilders_.push_back(builder);
}

addLegBuilder()

void addLegBuilder	(	const std::function< QuantLib::ext::shared_ptr< LegBuilder >()> &	builder,
		const bool	allowOverwrite = false
	)

Definition at line 127 of file enginefactory.cpp.

                                                                    {
    boost::unique_lock<boost::shared_mutex> lock(mutex_);
    auto key = builder()->legType();
    auto it =
        std::remove_if(legBuilderBuilders_.begin(), legBuilderBuilders_.end(),
                       [&key](std::function<QuantLib::ext::shared_ptr<LegBuilder>()>& b) { return key == b()->legType(); });
    QL_REQUIRE(it == legBuilderBuilders_.end() || allowOverwrite,
               "EngineBuilderFactory::addLegBuilder(" << key << "): builder for given key already exists.");
    legBuilderBuilders_.erase(it, legBuilderBuilders_.end());
    legBuilderBuilders_.push_back(builder);
}

generateEngineBuilders()

std::vector< QuantLib::ext::shared_ptr< EngineBuilder > > generateEngineBuilders

(

)

const

Definition at line 140 of file enginefactory.cpp.

                                                                                                   {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    std::vector<QuantLib::ext::shared_ptr<EngineBuilder>> result;
    for (auto const& b : engineBuilderBuilders_)
        result.push_back(b());
    return result;
}

generateAmcEngineBuilders()

std::vector< QuantLib::ext::shared_ptr< EngineBuilder > > generateAmcEngineBuilders	(	const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &	cam,
		const std::vector< Date > &	grid
	)		const

Definition at line 149 of file enginefactory.cpp.

                                                                                   {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    std::vector<QuantLib::ext::shared_ptr<EngineBuilder>> result;
    for (auto const& b : amcEngineBuilderBuilders_)
        result.push_back(b(cam, grid));
    return result;
}

generateAmcCgEngineBuilders()

std::vector< QuantLib::ext::shared_ptr< EngineBuilder > > generateAmcCgEngineBuilders	(	const QuantLib::ext::shared_ptr< ore::data::ModelCG > &	model,
		const std::vector< Date > &	grid
	)		const

Definition at line 159 of file enginefactory.cpp.

                                                                                     {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    std::vector<QuantLib::ext::shared_ptr<EngineBuilder>> result;
    for (auto const& b : amcCgEngineBuilderBuilders_)
        result.push_back(b(model, grid));
    return result;
}

generateLegBuilders()

std::vector< QuantLib::ext::shared_ptr< LegBuilder > > generateLegBuilders

(

)

const

Definition at line 168 of file enginefactory.cpp.

                                                                                             {
    boost::shared_lock<boost::shared_mutex> lock(mutex_);
    std::vector<QuantLib::ext::shared_ptr<LegBuilder>> result;
    for (auto const& b : legBuilderBuilders_)
        result.push_back(b());
    return result;
}

Member Data Documentation

engineBuilderBuilders_

std::vector<std::function<QuantLib::ext::shared_ptr<EngineBuilder>()> > engineBuilderBuilders_

private

Definition at line 175 of file enginefactory.hpp.

amcEngineBuilderBuilders_

std::vector<std::function<QuantLib::ext::shared_ptr<EngineBuilder>(const QuantLib::ext::shared_ptr<QuantExt::CrossAssetModel>& cam, const std::vector<Date>& grid)> > amcEngineBuilderBuilders_

private

Definition at line 178 of file enginefactory.hpp.

amcCgEngineBuilderBuilders_

std::vector<std::function<QuantLib::ext::shared_ptr<EngineBuilder>(const QuantLib::ext::shared_ptr<ore::data::ModelCG>& model, const std::vector<Date>& grid)> > amcCgEngineBuilderBuilders_

private

Definition at line 181 of file enginefactory.hpp.

legBuilderBuilders_

std::vector<std::function<QuantLib::ext::shared_ptr<LegBuilder>()> > legBuilderBuilders_

private

Definition at line 182 of file enginefactory.hpp.

mutex_

boost::shared_mutex mutex_

mutableprivate

Definition at line 183 of file enginefactory.hpp.