Serializable Flexi-Swap. More...

#include <ored/portfolio/flexiswap.hpp>

Inheritance diagram for FlexiSwap:

Collaboration diagram for FlexiSwap:

Public Member Functions
	FlexiSwap ()

	FlexiSwap (const ore::data::Envelope &env, const std::vector< ore::data::LegData > &swap, const std::vector< double > &lowerNotionalBounds, const std::vector< std::string > &lowerNotionalBoundsDates, const std::string &optionLongShort)

	FlexiSwap (const ore::data::Envelope &env, const std::vector< ore::data::LegData > &swap, const std::string &noticePeriod, const std::string &noticeCalendar, const std::string &noticeConvention, const std::vector< std::string > &exerciseDates, const std::vector< std::string > &exerciseTypes, const std::vector< double > &exerciseValues, const std::string &optionLongShort)

void	build (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &) override

Inspectors
const std::vector< ore::data::LegData > &	swap () const

const std::vector< double > &	lowerNotionalBounds () const

const std::vector< std::string > &	lowerNotionalBoundsDates () const

const std::string &	noticePeriod () const

const std::string &	noticeCalendar () const

const std::string &	noticeConvention () const

const std::vector< std::string > &	exerciseDates () const

const std::vector< std::string > &	exerciseTypes () const

const std::vector< double > &	exerciseValues () const

const std::string &	optionLongShort () const

Public Member Functions inherited from Trade
	Trade ()
	Default constructor. More...

	Trade (const string &tradeType, const Envelope &env=Envelope(), const TradeActions &ta=TradeActions())
	Base class constructor. More...

virtual	~Trade ()
	Default destructor. More...

virtual void	build (const QuantLib::ext::shared_ptr< EngineFactory > &)=0

virtual std::map< std::string, RequiredFixings::FixingDates >	fixings (const QuantLib::Date &settlementDate=QuantLib::Date()) const

const RequiredFixings &	requiredFixings () const

virtual std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const

void	reset ()
	Reset trade, clear all base class data. This does not reset accumulated timings for this trade. More...

void	resetPricingStats (const std::size_t numberOfPricings=0, const boost::timer::nanosecond_type cumulativePricingTime=0)
	Reset accumulated timings to given values. More...

string &	id ()
	Set the trade id. More...

void	setEnvelope (const Envelope &envelope)
	Set the envelope with counterparty and portfolio info. More...

void	setAdditionalData (const std::map< std::string, boost::any > &additionalData)

TradeActions &	tradeActions ()
	Set the trade actions. More...

const string &	id () const

const string &	tradeType () const

const Envelope &	envelope () const

const set< string > &	portfolioIds () const

const TradeActions &	tradeActions () const

const QuantLib::ext::shared_ptr< InstrumentWrapper > &	instrument () const

const std::vector< QuantLib::Leg > &	legs () const

const std::vector< string > &	legCurrencies () const

const std::vector< bool > &	legPayers () const

const string &	npvCurrency () const

virtual QuantLib::Real	notional () const
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...

virtual string	notionalCurrency () const

const Date &	maturity () const

virtual bool	isExpired (const Date &d)

const string &	issuer () const

template<typename T >
T	additionalDatum (const std::string &tag) const
	returns any additional datum. More...

virtual const std::map< std::string, boost::any > &	additionalData () const
	returns all additional data returned by the trade once built More...

const std::string &	sensitivityTemplate () const

void	validate () const
	Utility to validate that everything that needs to be set in this base class is actually set. More...

virtual bool	hasCashflows () const

boost::timer::nanosecond_type	getCumulativePricingTime () const
	Get cumulative timing spent on pricing. More...

std::size_t	getNumberOfPricings () const
	Get number of pricings. More...

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
std::vector< ore::data::LegData >	swap_

std::vector< double >	lowerNotionalBounds_

std::vector< std::string >	lowerNotionalBoundsDates_

std::string	noticePeriod_

std::string	noticeCalendar_

std::string	noticeConvention_

std::vector< std::string >	exerciseDates_

std::vector< std::string >	exerciseTypes_

std::vector< double >	exerciseValues_

std::string	optionLongShort_

std::string	floatingIndex_
	Store the name of the floating leg index. More...

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

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

Additional Inherited Members
Protected Member Functions inherited from Trade
Date	addPremiums (std::vector< QuantLib::ext::shared_ptr< Instrument > > &instruments, std::vector< Real > &multipliers, const Real tradeMultiplier, const PremiumData &premiumData, const Real premiumMultiplier, const Currency &tradeCurrency, const QuantLib::ext::shared_ptr< EngineFactory > &factory, const string &configuration)

void	setLegBasedAdditionalData (const Size legNo, Size resultLegId=Null< Size >()) const

void	setSensitivityTemplate (const EngineBuilder &builder)

void	setSensitivityTemplate (const std::string &id)

Protected Attributes inherited from Trade
string	tradeType_

QuantLib::ext::shared_ptr< InstrumentWrapper >	instrument_

std::vector< QuantLib::Leg >	legs_

std::vector< string >	legCurrencies_

std::vector< bool >	legPayers_

string	npvCurrency_

QuantLib::Real	notional_

string	notionalCurrency_

Date	maturity_

string	issuer_

string	sensitivityTemplate_

bool	sensitivityTemplateSet_ = false

std::size_t	savedNumberOfPricings_ = 0

boost::timer::nanosecond_type	savedCumulativePricingTime_ = 0

RequiredFixings	requiredFixings_

std::map< std::string, boost::any >	additionalData_

Detailed Description

Serializable Flexi-Swap.

Definition at line 36 of file flexiswap.hpp.

Constructor & Destructor Documentation

◆ FlexiSwap() [1/3]

FlexiSwap ( )

Definition at line 38 of file flexiswap.hpp.

38: Trade("FlexiSwap") {}

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

◆ FlexiSwap() [2/3]

FlexiSwap	(	const ore::data::Envelope &	env,
		const std::vector< ore::data::LegData > &	swap,
		const std::vector< double > &	lowerNotionalBounds,
		const std::vector< std::string > &	lowerNotionalBoundsDates,
		const std::string &	optionLongShort
	)

the optionality is described by lower notional bounds

Definition at line 41 of file flexiswap.hpp.

44 : Trade("FlexiSwap", env), swap_(swap), lowerNotionalBounds_(lowerNotionalBounds),

45 lowerNotionalBoundsDates_(lowerNotionalBoundsDates), optionLongShort_(optionLongShort) {}

ore::data::FlexiSwap::lowerNotionalBounds_

std::vector< double > lowerNotionalBounds_

Definition: flexiswap.hpp:90

ore::data::FlexiSwap::lowerNotionalBoundsDates_

std::vector< std::string > lowerNotionalBoundsDates_

Definition: flexiswap.hpp:91

ore::data::FlexiSwap::swap_

std::vector< ore::data::LegData > swap_

Definition: flexiswap.hpp:88

ore::data::FlexiSwap::optionLongShort_

std::string optionLongShort_

Definition: flexiswap.hpp:97

◆ FlexiSwap() [3/3]

FlexiSwap	(	const ore::data::Envelope &	env,
		const std::vector< ore::data::LegData > &	swap,
		const std::string &	noticePeriod,
		const std::string &	noticeCalendar,
		const std::string &	noticeConvention,
		const std::vector< std::string > &	exerciseDates,
		const std::vector< std::string > &	exerciseTypes,
		const std::vector< double > &	exerciseValues,
		const std::string &	optionLongShort
	)

the optionality is described by exercise dates / types and values

Definition at line 48 of file flexiswap.hpp.

        : Trade("FlexiSwap", env), swap_(swap), noticePeriod_(noticePeriod), noticeCalendar_(noticeCalendar),
          noticeConvention_(noticeConvention), exerciseDates_(exerciseDates), exerciseTypes_(exerciseTypes),
          exerciseValues_(exerciseValues), optionLongShort_(optionLongShort) {
        QL_REQUIRE(exerciseDates_.size() == exerciseTypes.size(), "exercise dates (" << exerciseDates_.size()
                                                                                     << ") must match exercise types ("
                                                                                     << exerciseTypes.size() << ")");
        QL_REQUIRE(exerciseDates_.size() == exerciseValues.size(),
                   "exercise dates (" << exerciseDates_.size() << ") must match exercise values ("
                                      << exerciseTypes.size() << ")");
    }

Member Function Documentation

◆ build()

void build ( const QuantLib::ext::shared_ptr< ore::data::EngineFactory > & )

override

Definition at line 36 of file flexiswap.cpp.

                                                                               {
 
    LOG("FlexiSwap::build() for id \"" << id() << "\" called.");
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = string("Interest Rate");
    additionalData_["isdaBaseProduct"] = string("Exotic");
    additionalData_["isdaSubProduct"] = string("");  
    additionalData_["isdaTransaction"] = string("");  
 
    QL_REQUIRE(swap_.size() == 2, "swap must have 2 legs");
    QL_REQUIRE(swap_[0].currency() == swap_[1].currency(), "swap must be single currency");
 
    string ccy_str = swap_[0].currency();
    Currency currency = parseCurrency(ccy_str);
 
    Size fixedLegIndex, floatingLegIndex;
    if (swap_[0].legType() == "Floating" && swap_[1].legType() == "Fixed") {
        floatingLegIndex = 0;
        fixedLegIndex = 1;
    } else if (swap_[1].legType() == "Floating" && swap_[0].legType() == "Fixed") {
        floatingLegIndex = 1;
        fixedLegIndex = 0;
    } else {
        QL_FAIL("Invalid leg types " << swap_[0].legType() << " + " << swap_[1].legType());
    }
 
    QuantLib::ext::shared_ptr<FixedLegData> fixedLegData =
        QuantLib::ext::dynamic_pointer_cast<FixedLegData>(swap_[fixedLegIndex].concreteLegData());
    QuantLib::ext::shared_ptr<FloatingLegData> floatingLegData =
        QuantLib::ext::dynamic_pointer_cast<FloatingLegData>(swap_[floatingLegIndex].concreteLegData());
 
    QL_REQUIRE(fixedLegData != nullptr, "expected fixed leg data");
    QL_REQUIRE(floatingLegData != nullptr, "expected floating leg data");
 
    QuantLib::ext::shared_ptr<EngineBuilder> tmp = engineFactory->builder("FlexiSwap");
    auto builder = QuantLib::ext::dynamic_pointer_cast<FlexiSwapBGSEngineBuilderBase>(tmp);
    QL_REQUIRE(builder, "No Flexi-Swap Builder found for \"" << id() << "\"");
 
    Schedule fixedSchedule = makeSchedule(swap_[fixedLegIndex].schedule());
    Schedule floatingSchedule = makeSchedule(swap_[floatingLegIndex].schedule());
    vector<Real> fixedNominal = buildScheduledVectorNormalised(
        swap_[fixedLegIndex].notionals(), swap_[fixedLegIndex].notionalDates(), fixedSchedule, 0.0);
    vector<Real> floatNominal = buildScheduledVectorNormalised(
        swap_[floatingLegIndex].notionals(), swap_[floatingLegIndex].notionalDates(), floatingSchedule, 0.0);
    vector<Real> fixedRate =
        buildScheduledVectorNormalised(fixedLegData->rates(), fixedLegData->rateDates(), fixedSchedule, 0.0);
    vector<Real> spreads = buildScheduledVectorNormalised(floatingLegData->spreads(), floatingLegData->spreadDates(),
                                                          floatingSchedule, 0.0);
    vector<Real> gearings = buildScheduledVectorNormalised(floatingLegData->gearings(), floatingLegData->gearingDates(),
                                                           floatingSchedule, 1.0);
    vector<Real> caps = buildScheduledVectorNormalised(floatingLegData->caps(), floatingLegData->capDates(),
                                                       floatingSchedule, (Real)Null<Real>());
    vector<Real> floors = buildScheduledVectorNormalised(floatingLegData->floors(), floatingLegData->floorDates(),
                                                         floatingSchedule, (Real)Null<Real>());
    floatingIndex_ = floatingLegData->index();
    DayCounter fixedDayCounter = parseDayCounter(swap_[fixedLegIndex].dayCounter());
    Handle<IborIndex> index =
        engineFactory->market()->iborIndex(floatingIndex_, builder->configuration(MarketContext::pricing));
    DayCounter floatingDayCounter = parseDayCounter(swap_[floatingLegIndex].dayCounter());
    BusinessDayConvention paymentConvention = parseBusinessDayConvention(swap_[floatingLegIndex].paymentConvention());
    VanillaSwap::Type type = swap_[fixedLegIndex].isPayer() ? VanillaSwap::Payer : VanillaSwap::Receiver;
 
    vector<Real> lowerNotionalBounds = fixedNominal; // default, no optionality
    std::vector<bool> notionalCanBeDecreased(fixedNominal.size(), true);
 
    // check we have at most one optionality description
 
    QL_REQUIRE(lowerNotionalBounds_.empty() || exerciseDates_.empty(),
               "can not have lower notional bounds and exercise dates / types / values specified at the same time");
 
    // optionality is given by lower notional bounds
 
    if (!lowerNotionalBounds_.empty()) {
        lowerNotionalBounds =
            buildScheduledVectorNormalised(lowerNotionalBounds_, lowerNotionalBoundsDates_, fixedSchedule, 0.0);
        DLOG("optionality is given by lower notional bounds");
    }
 
    // optionality is given by exercise dates, types, values
 
    // FIXME this is an approximation, we build an approximate instrument here using the global lower
    // notional bounds; for a correct representation we would need local bounds that depend on the
    // current notional of the swap; see below where the approximation occurs specifically
 
    if (!exerciseDates_.empty()) {
        DLOG("optionality is given by exercise dates, types, values");
 
        // FIXME: we also ignore the notice period at this stage of the implementation, the notice day
        // is always assumed to lie on the fixing date of the corresponding float period of the swap
 
        // start with no optionality
        notionalCanBeDecreased = std::vector<bool>(fixedNominal.size(), false);
 
        // loop over exercise dates and update lower notional bounds belonging to that exercise
        Date previousExerciseDate = Null<Date>();
        for (Size i = 0; i < exerciseDates_.size(); ++i) {
            Date d = parseDate(exerciseDates_[i]);
            QL_REQUIRE(exerciseValues_[i] > 0.0 || close_enough(exerciseValues_[i], 0.0),
                       "exercise value #" << i << " (" << exerciseValues_[i] << ") must be non-negative");
            QL_REQUIRE(i == 0 || previousExerciseDate < d, "exercise dates must be strictly increasing, got "
                                                               << QuantLib::io::iso_date(previousExerciseDate)
                                                               << " and " << QuantLib::io::iso_date(d) << " as #" << i
                                                               << " and #" << i + 1);
            previousExerciseDate = d;
            // determine the fixed period that follows the exercise date
            Size exerciseIdx = std::lower_bound(fixedSchedule.dates().begin(), fixedSchedule.dates().end(), d) -
                               fixedSchedule.dates().begin();
            if (exerciseIdx >= fixedSchedule.dates().size() - 1) {
                DLOG("exercise date "
                     << QuantLib::io::iso_date(d)
                     << " ignored since there is no whole fixed leg period with accrual start >= exercise date");
                continue;
            }
            notionalCanBeDecreased[exerciseIdx] = true;
            if (exerciseTypes_[i] == "ReductionUpToLowerBound") {
                for (Size j = exerciseIdx; j < lowerNotionalBounds.size(); ++j) {
                    lowerNotionalBounds[j] = std::min(lowerNotionalBounds[j], exerciseValues_[i]);
                }
            } else if (exerciseTypes_[i] == "ReductionByAbsoluteAmount" ||
                       exerciseTypes_[i] == "ReductionUpToAbsoluteAmount") {
                // FIXME we just assume that all prepayment option before this one here were exercised
                // and reduce the lower notional bounds by the current exercise amount; we also treat
                // "by" the same as "up to"
                for (Size j = exerciseIdx; j < lowerNotionalBounds.size(); ++j) {
                    lowerNotionalBounds[j] = std::max(lowerNotionalBounds[j] - exerciseValues_[i], 0.0);
                }
            } else {
                QL_FAIL("exercise type '" << exerciseTypes_[i]
                                          << "' unknown, expected ReductionUpToLowerBound, ReductionByAbsoluteAmount, "
                                             "ReductionUpToAbsoluteAmount");
            }
        }
    }
 
    DLOG("fixedPeriod#,notional,lowerNotionalBound,canBeReduced");
    for (Size i = 0; i < lowerNotionalBounds.size(); ++i) {
        DLOG(i << "," << fixedNominal.at(i) << "," << lowerNotionalBounds[i] << "," << std::boolalpha
               << notionalCanBeDecreased[i]);
    }
 
    // set up ql instrument
 
    Position::Type optionLongShort = parsePositionType(optionLongShort_);
 
    auto flexiSwap = QuantLib::ext::make_shared<QuantExt::FlexiSwap>(
        type, fixedNominal, floatNominal, fixedSchedule, fixedRate, fixedDayCounter, floatingSchedule, *index, gearings,
        spreads, caps, floors, floatingDayCounter, lowerNotionalBounds, optionLongShort, notionalCanBeDecreased,
        paymentConvention);
 
    auto fixLeg = flexiSwap->leg(0);
    auto fltLeg = flexiSwap->leg(1);
 
    // set coupon pricers if needed (for flow report, discounting swap engine, not used in LGM engine)
 
    bool hasCapsFloors = false;
    for (auto const& k : caps) {
        if (k != Null<Real>())
            hasCapsFloors = true;
    }
    for (auto const& k : floors) {
        if (k != Null<Real>())
            hasCapsFloors = true;
    }
    if (hasCapsFloors) {
        QuantLib::ext::shared_ptr<EngineBuilder> cfBuilder = engineFactory->builder("CapFlooredIborLeg");
        QL_REQUIRE(cfBuilder, "No builder found for CapFlooredIborLeg");
        QuantLib::ext::shared_ptr<CapFlooredIborLegEngineBuilder> cappedFlooredIborBuilder =
            QuantLib::ext::dynamic_pointer_cast<CapFlooredIborLegEngineBuilder>(cfBuilder);
        QL_REQUIRE(cappedFlooredIborBuilder != nullptr, "expected CapFlooredIborLegEngineBuilder");
        QuantLib::ext::shared_ptr<FloatingRateCouponPricer> couponPricer =
            cappedFlooredIborBuilder->engine(IndexNameTranslator::instance().oreName(index->name()));
        QuantLib::setCouponPricer(fltLeg, couponPricer);
    }
 
    // determine expiries and strikes for calibration basket (simple approach, a la summit)
    std::vector<Date> expiryDates;
    std::vector<Real> strikes;
    Date today = Settings::instance().evaluationDate();
    Size legRatio = fltLeg.size() / fixLeg.size(); // no remainder by construction of a flexi swap
    for (Size i = 0; i < fltLeg.size(); ++i) {
        auto fltcpn = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(fltLeg[i]);
        if (fltcpn != nullptr && fltcpn->fixingDate() > today && i % legRatio == 0) {
            expiryDates.push_back(fltcpn->fixingDate());
            auto fixcpn = QuantLib::ext::dynamic_pointer_cast<FixedRateCoupon>(fixLeg[i / legRatio]);
            QL_REQUIRE(fixcpn != nullptr, "FlexiSwap Builder: expected fixed rate coupon");
            strikes.push_back(fixcpn->rate() - fltcpn->spread());
        }
    }
 
    // set pricing engine, init instrument and other trade members
 
    flexiSwap->setPricingEngine(
        builder->engine(id(), "", index.empty() ? ccy_str : IndexNameTranslator::instance().oreName(index->name()),
                        expiryDates, flexiSwap->maturityDate(), strikes));
    setSensitivityTemplate(*builder);
 
    // FIXME this won't work for exposure, currently not supported
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(flexiSwap);
 
    npvCurrency_ = ccy_str;
    notional_ = std::max(currentNotional(fixLeg), currentNotional(fltLeg));
    notionalCurrency_ = ccy_str;
    legCurrencies_ = vector<string>(2, ccy_str);
    legs_ = {fixLeg, fltLeg};
    legPayers_ = {swap_[fixedLegIndex].isPayer(), swap_[floatingLegIndex].isPayer()};
    maturity_ = flexiSwap->maturityDate();
    addToRequiredFixings(fltLeg, QuantLib::ext::make_shared<FixingDateGetter>(requiredFixings_));
}

Here is the call graph for this function:

◆ swap()

const std::vector< ore::data::LegData > & swap ( ) const

Definition at line 67 of file flexiswap.hpp.

67{ return swap_; }

◆ lowerNotionalBounds()

const std::vector< double > & lowerNotionalBounds ( ) const

Definition at line 69 of file flexiswap.hpp.

69{ return lowerNotionalBounds_; }

◆ lowerNotionalBoundsDates()

const std::vector< std::string > & lowerNotionalBoundsDates ( ) const

Definition at line 70 of file flexiswap.hpp.

70{ return lowerNotionalBoundsDates_; }

◆ noticePeriod()

const std::string & noticePeriod ( ) const

Definition at line 72 of file flexiswap.hpp.

72{ return noticePeriod_; }

◆ noticeCalendar()

const std::string & noticeCalendar ( ) const

Definition at line 73 of file flexiswap.hpp.

73{ return noticeCalendar_; }

◆ noticeConvention()

const std::string & noticeConvention ( ) const

Definition at line 74 of file flexiswap.hpp.

74{ return noticeConvention_; }

◆ exerciseDates()

const std::vector< std::string > & exerciseDates ( ) const

Definition at line 75 of file flexiswap.hpp.

75{ return exerciseDates_; }

◆ exerciseTypes()

const std::vector< std::string > & exerciseTypes ( ) const

Definition at line 76 of file flexiswap.hpp.

76{ return exerciseTypes_; }

◆ exerciseValues()

const std::vector< double > & exerciseValues ( ) const

Definition at line 77 of file flexiswap.hpp.

77{ return exerciseValues_; }

◆ optionLongShort()

const std::string & optionLongShort ( ) const

Definition at line 79 of file flexiswap.hpp.

79{ return optionLongShort_; }

◆ fromXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 246 of file flexiswap.cpp.

                                     {
    Trade::fromXML(node);
    XMLNode* swapNode = XMLUtils::getChildNode(node, "FlexiSwapData");
    QL_REQUIRE(swapNode, "FlexiSwap::fromXML(): FlexiSwapData not found");
    // optionality given by lower notional bounds
    lowerNotionalBounds_ = XMLUtils::getChildrenValuesWithAttributes<Real>(
        swapNode, "LowerNotionalBounds", "Notional", "startDate", lowerNotionalBoundsDates_, &parseReal);
    // optionality given by exercise dates, types and values
    noticePeriod_ = noticeCalendar_ = noticeConvention_ = "";
    exerciseDates_.clear();
    exerciseTypes_.clear();
    exerciseValues_.clear();
    XMLNode* prepayNode = XMLUtils::getChildNode(swapNode, "Prepayment");
    if (prepayNode) {
        noticePeriod_ = XMLUtils::getChildValue(prepayNode, "NoticePeriod", false);
        noticeCalendar_ = XMLUtils::getChildValue(prepayNode, "NoticeCalendar", false);
        noticeConvention_ = XMLUtils::getChildValue(prepayNode, "NoticeConvention", false);
        XMLNode* optionsNode = XMLUtils::getChildNode(prepayNode, "PrepaymentOptions");
        if (optionsNode) {
            auto prepayOptionNodes = XMLUtils::getChildrenNodes(optionsNode, "PrepaymentOption");
            for (auto const n : prepayOptionNodes) {
                exerciseDates_.push_back(XMLUtils::getChildValue(n, "ExerciseDate", true));
                exerciseTypes_.push_back(XMLUtils::getChildValue(n, "Type", true));
                exerciseValues_.push_back(parseReal(XMLUtils::getChildValue(n, "Value", true)));
            }
        }
    }
    // long short flag
    optionLongShort_ = XMLUtils::getChildValue(swapNode, "OptionLongShort", true);
    // underlying legs
    swap_.clear();
    vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(swapNode, "LegData");
    for (Size i = 0; i < nodes.size(); i++) {
        LegData ld; // we do not allow ORE+ leg types anyway
        ld.fromXML(nodes[i]);
        swap_.push_back(ld);
    }
}

Here is the call graph for this function:

◆ toXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 285 of file flexiswap.cpp.

                                                {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* swapNode = doc.allocNode("FlexiSwapData");
    XMLUtils::appendNode(node, swapNode);
    // optionality given by lower notional bounds
    if (!lowerNotionalBounds_.empty()) {
        XMLUtils::addChildrenWithOptionalAttributes(doc, swapNode, "LowerNotionalBounds", "Notional",
                                                    lowerNotionalBounds_, "startDate", lowerNotionalBoundsDates_);
    }
    // optionality given by exercise dates, types and values
    if (!exerciseDates_.empty()) {
        XMLNode* prepayNode = doc.allocNode("Prepayment");
        XMLUtils::appendNode(swapNode, prepayNode);
        if (!noticePeriod_.empty())
            XMLUtils::addChild(doc, prepayNode, "NoticePeriod", noticePeriod_);
        if (!noticeCalendar_.empty())
            XMLUtils::addChild(doc, prepayNode, "NoticeCalendar", noticeCalendar_);
        if (!noticeConvention_.empty())
            XMLUtils::addChild(doc, prepayNode, "NoticeConvention", noticeConvention_);
        XMLNode* optionsNode = doc.allocNode("PrepaymentOptions");
        XMLUtils::appendNode(prepayNode, optionsNode);
        for (Size i = 0; i < exerciseDates_.size(); ++i) {
            XMLNode* exerciseNode = doc.allocNode("PrepaymentOption");
            XMLUtils::appendNode(optionsNode, exerciseNode);
            XMLUtils::addChild(doc, exerciseNode, "ExerciseDate", exerciseDates_.at(i));
            XMLUtils::addChild(doc, exerciseNode, "Type", exerciseTypes_.at(i));
            XMLUtils::addChild(doc, exerciseNode, "Value", exerciseValues_.at(i));
        }
    }
    // long short option flag
    XMLUtils::addChild(doc, swapNode, "OptionLongShort", optionLongShort_);
    // underlying legs
    for (Size i = 0; i < swap_.size(); i++)
        XMLUtils::appendNode(swapNode, swap_[i].toXML(doc));
    return node;
}

Here is the call graph for this function:

Member Data Documentation

◆ swap_

std::vector<ore::data::LegData> swap_

private

Definition at line 88 of file flexiswap.hpp.

◆ lowerNotionalBounds_

std::vector<double> lowerNotionalBounds_

private

Definition at line 90 of file flexiswap.hpp.

◆ lowerNotionalBoundsDates_

std::vector<std::string> lowerNotionalBoundsDates_

private

Definition at line 91 of file flexiswap.hpp.

◆ noticePeriod_

std::string noticePeriod_

private

Definition at line 93 of file flexiswap.hpp.

◆ noticeCalendar_

std::string noticeCalendar_

private

Definition at line 93 of file flexiswap.hpp.

◆ noticeConvention_

std::string noticeConvention_

private

Definition at line 93 of file flexiswap.hpp.

◆ exerciseDates_

std::vector<std::string> exerciseDates_

private

Definition at line 94 of file flexiswap.hpp.

◆ exerciseTypes_

std::vector<std::string> exerciseTypes_

private

Definition at line 94 of file flexiswap.hpp.

◆ exerciseValues_

std::vector<double> exerciseValues_

private

Definition at line 95 of file flexiswap.hpp.

◆ optionLongShort_

std::string optionLongShort_

private

Definition at line 97 of file flexiswap.hpp.

◆ floatingIndex_

std::string floatingIndex_

private

Store the name of the floating leg index.

Definition at line 100 of file flexiswap.hpp.

Public Member Functions

Serialisation

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FlexiSwap() [1/3]

◆ FlexiSwap() [2/3]

◆ FlexiSwap() [3/3]

Member Function Documentation

◆ build()

◆ swap()

◆ lowerNotionalBounds()

◆ lowerNotionalBoundsDates()

◆ noticePeriod()

◆ noticeCalendar()

◆ noticeConvention()

◆ exerciseDates()

◆ exerciseTypes()

◆ exerciseValues()

◆ optionLongShort()

◆ fromXML()

◆ toXML()

Member Data Documentation

◆ swap_

◆ lowerNotionalBounds_

◆ lowerNotionalBoundsDates_

◆ noticePeriod_

◆ noticeCalendar_

◆ noticeConvention_

◆ exerciseDates_

◆ exerciseTypes_

◆ exerciseValues_

◆ optionLongShort_

◆ floatingIndex_