#include <ored/portfolio/bondtotalreturnswap.hpp>

Inheritance diagram for BondTRS:

Collaboration diagram for BondTRS:

Public Member Functions
	BondTRS ()
	Default Constructor. More...

	BondTRS (Envelope env, const BondData &bondData)
	Constructor for coupon bonds. More...

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

virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const override
	Add underlying Bond names. More...

const BondData &	bondData () const

const ScheduleData &	scheduleData () const

const LegData &	fundingLegData () const

const bool	payTotalReturnLeg () const

const Real	initialPrice () const

const bool	useDirtyPrices () const

const std::string &	observationLag () const

const std::string &	observationConvention () const

const std::string &	observationCalendar () const

const std::string &	paymentLag () const

const std::string &	paymentConvention () const

const std::string &	paymentCalendar () const

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

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...

Private Attributes
BondData	originalBondData_

BondData	bondData_

ScheduleData	scheduleData_

LegData	fundingLegData_

bool	payTotalReturnLeg_ = false

Real	initialPrice_ = Null<Real>()

bool	useDirtyPrices_ = true

bool	payBondCashFlowsImmediately_ = false

std::string	observationLag_

std::string	observationConvention_

std::string	observationCalendar_

std::string	paymentLag_

std::string	paymentConvention_

std::string	paymentCalendar_

std::vector< std::string >	paymentDates_

string	fxIndex_ = ""

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

Definition at line 35 of file bondtotalreturnswap.hpp.

Constructor & Destructor Documentation

◆ BondTRS() [1/2]

BondTRS ( )

Default Constructor.

Definition at line 38 of file bondtotalreturnswap.hpp.

38: Trade("BondTRS") {}

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

◆ BondTRS() [2/2]

BondTRS	(	Envelope	env,
		const BondData &	bondData
	)

Constructor for coupon bonds.

Definition at line 41 of file bondtotalreturnswap.hpp.

42 : Trade("BondTRS", env), originalBondData_(bondData), bondData_(bondData) {}

ore::data::BondTRS::bondData_

BondData bondData_

Definition: bondtotalreturnswap.hpp:70

ore::data::BondTRS::originalBondData_

BondData originalBondData_

Definition: bondtotalreturnswap.hpp:70

Member Function Documentation

◆ build()

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

overridevirtual

Build QuantLib/QuantExt instrument, link pricing engine. If build() is called multiple times, reset() should be called between these calls.

Implements Trade.

Definition at line 50 of file bondtotalreturnswap.cpp.

                                                                             {
    DLOG("BondTRS::build() called for trade " << id());
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = string("Credit");
    additionalData_["isdaBaseProduct"] = string("Total Return Swap");
    additionalData_["isdaSubProduct"] = string("");
    additionalData_["isdaTransaction"] = string("");
 
    const QuantLib::ext::shared_ptr<Market> market = engineFactory->market();
    QuantLib::ext::shared_ptr<EngineBuilder> builder_trs = engineFactory->builder("BondTRS");
    bondData_ = originalBondData_;
    bondData_.populateFromBondReferenceData(engineFactory->referenceData());
 
    Schedule schedule = makeSchedule(scheduleData_);
    Calendar calendar = parseCalendar(bondData_.calendar());
 
    auto configuration = builder_trs->configuration(MarketContext::pricing);
    auto legBuilder = engineFactory->legBuilder(fundingLegData_.legType());
 
    // check currency restrictions
 
    QL_REQUIRE(fundingLegData_.currency() != bondData_.currency() || fxIndex_.empty(),
               "if funding leg ccy (" << fundingLegData_.currency() << ") = bond ccy (" << bondData_.currency()
                                      << "), no fx index must be given");
    QL_REQUIRE(fundingLegData_.currency() == bondData_.currency() || !fxIndex_.empty(),
               "if funding leg ccy (" << fundingLegData_.currency() << ") != bond ccy (" << bondData_.currency()
                                      << "), a fx index must be given");
 
    npvCurrency_ = fundingLegData_.currency();
    notionalCurrency_ = bondData_.currency();
 
    // build return leg valuation and payment schedule
    DLOG("build valuation and payment dates vectors");
 
    Period observationLag = observationLag_.empty() ? 0 * Days : parsePeriod(observationLag_);
    Calendar observationCalendar = parseCalendar(observationCalendar_);
    BusinessDayConvention observationConvention =
        observationConvention_.empty() ? Unadjusted : parseBusinessDayConvention(observationConvention_);
 
    PaymentLag paymentLag = parsePaymentLag(paymentLag_);
    Period plPeriod = boost::apply_visitor(PaymentLagPeriod(), paymentLag);
    Calendar paymentCalendar = parseCalendar(paymentCalendar_);
    BusinessDayConvention paymentConvention =
        paymentConvention_.empty() ? Unadjusted : parseBusinessDayConvention(paymentConvention_);
 
    std::vector<Date> valuationDates, paymentDates;
 
    for (auto const& d : schedule.dates()) {
        valuationDates.push_back(observationCalendar.advance(d, -observationLag, observationConvention));
        if (d != schedule.dates().front())
            paymentDates.push_back(paymentCalendar.advance(d, plPeriod, paymentConvention));
    }
 
    if (!paymentDates_.empty()) {
        paymentDates.clear();
        QL_REQUIRE(paymentDates_.size() + 1 == valuationDates.size(),
                   "paymentDates size (" << paymentDates_.size() << ") does no match valuatioDates size ("
                                         << valuationDates.size() << ") minus 1");
        for (auto const& s : paymentDates_)
            paymentDates.push_back(parseDate(s));
    }
 
    DLOG("valuation schedule:");
    for (auto const& d : valuationDates)
        DLOG(ore::data::to_string(d));
 
    DLOG("payment schedule:");
    for (auto const& d : paymentDates)
        DLOG(ore::data::to_string(d));
 
    // build fx index for composite bond trs
 
    QuantLib::ext::shared_ptr<FxIndex> fxIndex;
    if (!fxIndex_.empty()) {
        fxIndex =
            buildFxIndex(fxIndex_, fundingLegData_.currency(), bondData_.currency(), engineFactory->market(),
                         engineFactory->configuration(MarketContext::pricing));
 
    }
 
    // build bond index (absolute prices, conditional on survival set to false)
    BondIndexBuilder bondIndexBuilder(bondData_, useDirtyPrices_, false, NullCalendar(), false, engineFactory);
    auto bondIndex = bondIndexBuilder.bondIndex();
 
    // compute initial price taking into account the possible scaling with priceQuoteBaseValue and 100.0
    Real effectiveInitialPrice = bondIndexBuilder.priceAdjustment(initialPrice_);
    if (effectiveInitialPrice != Null<Real>())
        effectiveInitialPrice = effectiveInitialPrice / 100.0;
 
    // add indexing data from the bond trs leg, if this is desired
 
    if (fundingLegData_.indexingFromAssetLeg()) {
        DLOG("adding indexing information from trs leg to funding leg");
 
        std::vector<string> stringValuationDates;
        for (auto const& d : valuationDates)
            stringValuationDates.push_back(ore::data::to_string(d));
        ScheduleData valuationSchedule(ScheduleDates("", "", "", stringValuationDates, ""));
 
        // add bond indexing
        Indexing bondIndexing("BOND-" + bondIndex->securityName(), "", bondIndex->dirty(), bondIndex->relative(),
                              bondIndex->conditionalOnSurvival(), bondData_.bondNotional(), effectiveInitialPrice,
                              Null<Real>(), valuationSchedule, 0, "", "U", false);
        fundingLegData_.indexing().push_back(bondIndexing);
 
        // add fx indexing, if applicable
        if (!fxIndex_.empty()) {
            Indexing fxIndexing(fxIndex_, "", false, false, false, 1.0, Null<Real>(), Null<Real>(), valuationSchedule,
                                0, "", "U", false);
            fundingLegData_.indexing().push_back(fxIndexing);
        }
 
        // set notional node to 1.0
        fundingLegData_.notionals() = std::vector<Real>(1, 1.0);
        fundingLegData_.notionalDates() = std::vector<std::string>();
 
        // reset flag that told us to pull the indexing information from the equity leg
        fundingLegData_.indexingFromAssetLeg() = false;
    }
 
    // build funding leg (consisting of a coupon leg and (possibly) a notional leg
 
    Leg fundingLeg = legBuilder->buildLeg(fundingLegData_, engineFactory, requiredFixings_, configuration);
    Leg fundingNotionalLeg;
    if (fundingLegData_.notionalInitialExchange() || fundingLegData_.notionalFinalExchange() ||
        fundingLegData_.notionalAmortizingExchange()) {
        Natural fundingLegPayLag = 0;
        fundingNotionalLeg =
            makeNotionalLeg(fundingLeg, fundingLegData_.notionalInitialExchange(),
                            fundingLegData_.notionalFinalExchange(), fundingLegData_.notionalAmortizingExchange(),
                            fundingLegPayLag, parseBusinessDayConvention(fundingLegData_.paymentConvention()),
                            parseCalendar(fundingLegData_.paymentCalendar()));
    }
 
    QL_REQUIRE(fundingLegData_.isPayer() != payTotalReturnLeg_,
               "funding leg and total return lag are both rec or both pay");
    DLOG("Before bondTRS");
    auto bondTRS = QuantLib::ext::make_shared<QuantExt::BondTRS>(
        bondIndex, bondData_.bondNotional(), effectiveInitialPrice,
        std::vector<QuantLib::Leg>{fundingLeg, fundingNotionalLeg}, payTotalReturnLeg_, valuationDates, paymentDates,
        fxIndex, payBondCashFlowsImmediately_, parseCurrency(fundingLegData_.currency()),
        parseCurrency(bondData_.currency()));
    DLOG("After bondTRS");
    QuantLib::ext::shared_ptr<BondTRSEngineBuilder> trsBondBuilder =
        QuantLib::ext::dynamic_pointer_cast<BondTRSEngineBuilder>(builder_trs);
    QL_REQUIRE(trsBondBuilder, "No Builder found for BondTRS: " << id());
    bondTRS->setPricingEngine(trsBondBuilder->engine(fundingLegData_.currency()));
    setSensitivityTemplate(*trsBondBuilder);
    instrument_.reset(new VanillaInstrument(bondTRS));
    // maturity_ = std::max(valuationDates.back(), paymentDates.back());
    maturity_ = bondIndex->bond()->maturityDate();
    notional_ = bondIndex->bond()->notional() * bondData_.bondNotional();
 
    // cashflows will be generated as additional results in the pricing engine
 
    legs_ = {};
    legCurrencies_ = {};
    legPayers_ = {};
 
    // add required bond and fx fixings for return calculation
    addToRequiredFixings(bondTRS->returnLeg(), QuantLib::ext::make_shared<FixingDateGetter>(requiredFixings_));
    bondIndexBuilder.addRequiredFixings(requiredFixings_, bondTRS->returnLeg());
 
    // add required fx fixings for bond cashflow conversion (see the engine for details)
 
    if (!fxIndex_.empty()) {
        for (auto const& c : bondIndex->bond()->cashflows()) {
            requiredFixings_.addFixingDate(fxIndex->fixingCalendar().adjust(c->date(), Preceding), fxIndex_, c->date());
        }
    }
 
    if (bondData_.isInflationLinked() && useDirtyPrices()) {
        auto inflationIndices = extractAllInflationUnderlyingFromBond(bondIndex->bond());
        for (const auto& cf : bondTRS->returnLeg()) {
            auto tcf = QuantLib::ext::dynamic_pointer_cast<TRSCashFlow>(cf);
            if (tcf != nullptr) {
                for (const auto& [key, index] : inflationIndices) {
                    auto [name, interpolation, couponFrequency, observationLag] = key;
                    std::string oreName = IndexNameTranslator::instance().oreName(name);
                    requiredFixings_.addZeroInflationFixingDate(
                        tcf->fixingStartDate() - observationLag, oreName, false, index->frequency(),
                        index->availabilityLag(), interpolation, couponFrequency, Date::maxDate(), false, false);
                }
            }
        }
    }
}

Here is the call graph for this function:

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 239 of file bondtotalreturnswap.cpp.

                                   {
    Trade::fromXML(node);
    XMLNode* bondTRSNode = XMLUtils::getChildNode(node, "BondTRSData");
    QL_REQUIRE(bondTRSNode, "No BondTRSData Node");
    originalBondData_.fromXML(XMLUtils::getChildNode(bondTRSNode, "BondData"));
    bondData_ = originalBondData_;
 
    XMLNode* bondTRSDataNode = XMLUtils::getChildNode(bondTRSNode, "TotalReturnData");
    QL_REQUIRE(bondTRSDataNode, "No bondTRSDataNode Node");
 
    payTotalReturnLeg_ = parseBool(XMLUtils::getChildValue(bondTRSDataNode, "Payer", true));
 
    scheduleData_.fromXML(XMLUtils::getChildNode(bondTRSDataNode, "ScheduleData"));
 
    observationLag_ = XMLUtils::getChildValue(bondTRSDataNode, "ObservationLag");
    observationConvention_ = XMLUtils::getChildValue(bondTRSDataNode, "ObservationConvention");
    observationCalendar_ = XMLUtils::getChildValue(bondTRSDataNode, "ObservationCalendar");
 
    paymentLag_ = XMLUtils::getChildValue(bondTRSDataNode, "PaymentLag");
    paymentConvention_ = XMLUtils::getChildValue(bondTRSDataNode, "PaymentConvention");
    paymentCalendar_ = XMLUtils::getChildValue(bondTRSDataNode, "PaymentCalendar");
    paymentDates_ = XMLUtils::getChildrenValues(bondTRSDataNode, "PaymentDates", "PaymentDate");
 
    initialPrice_ = Null<Real>();
    if (auto n = XMLUtils::getChildNode(bondTRSDataNode, "InitialPrice"))
        initialPrice_ = parseReal(XMLUtils::getNodeValue(n));
    std::string priceType = XMLUtils::getChildValue(bondTRSDataNode, "PriceType", true);
    if (priceType == "Dirty")
        useDirtyPrices_ = true;
    else if (priceType == "Clean")
        useDirtyPrices_ = false;
    else {
        QL_FAIL("PriceType (" << priceType << ") must be Clean or Dirty");
    }
 
    XMLNode* fxt = XMLUtils::getChildNode(bondTRSDataNode, "FXTerms");
    if (fxt)
        fxIndex_ = XMLUtils::getChildValue(fxt, "FXIndex", true);
 
    payBondCashFlowsImmediately_ =
        XMLUtils::getChildValueAsBool(bondTRSDataNode, "PayBondCashFlowsImmediately", false, false);
 
    XMLNode* bondTRSFundingNode = XMLUtils::getChildNode(bondTRSNode, "FundingData");
    XMLNode* fLegNode = XMLUtils::getChildNode(bondTRSFundingNode, "LegData");
    fundingLegData_ = LegData();
    fundingLegData_.fromXML(fLegNode);
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 287 of file bondtotalreturnswap.cpp.

                                              {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* bondTRSNode = doc.allocNode("BondTRSData");
    XMLUtils::appendNode(node, bondTRSNode);
    XMLUtils::appendNode(bondTRSNode, originalBondData_.toXML(doc));
 
    XMLNode* trsDataNode = doc.allocNode("TotalReturnData");
    XMLUtils::appendNode(bondTRSNode, trsDataNode);
    XMLUtils::addChild(doc, trsDataNode, "Payer", payTotalReturnLeg_);
 
    if (initialPrice_ != Null<Real>())
        XMLUtils::addChild(doc, trsDataNode, "InitialPrice", initialPrice_);
    XMLUtils::addChild(doc, trsDataNode, "PriceType", useDirtyPrices_ ? "Dirty" : "Clean");
 
    if (!observationLag_.empty())
        XMLUtils::addChild(doc, trsDataNode, "ObservationLag", observationLag_);
    if (!observationConvention_.empty())
        XMLUtils::addChild(doc, trsDataNode, "ObservationConvention", observationConvention_);
    if (!observationCalendar_.empty())
        XMLUtils::addChild(doc, trsDataNode, "ObservationCalendar", observationCalendar_);
 
    if (!paymentLag_.empty())
        XMLUtils::addChild(doc, trsDataNode, "PaymentLag", paymentLag_);
    if (!paymentConvention_.empty())
        XMLUtils::addChild(doc, trsDataNode, "PaymentConvention", paymentConvention_);
    if (!paymentCalendar_.empty())
        XMLUtils::addChild(doc, trsDataNode, "PaymentCalendar", paymentCalendar_);
    if (!paymentDates_.empty())
        XMLUtils::addChildren(doc, trsDataNode, "PaymentDates", "PaymentDate", paymentDates_);
 
    if (!fxIndex_.empty()) {
        XMLNode* fxNode = doc.allocNode("FXTerms");
        XMLUtils::addChild(doc, fxNode, "FXIndex", fxIndex_);
        XMLUtils::appendNode(trsDataNode, fxNode);
    }
 
    XMLUtils::appendNode(trsDataNode, scheduleData_.toXML(doc));
 
    XMLUtils::addChild(doc, trsDataNode, "PayBondCashFlowsImmediately", payBondCashFlowsImmediately_);
 
    XMLNode* fundingDataNode = doc.allocNode("FundingData");
    XMLUtils::appendNode(bondTRSNode, fundingDataNode);
    XMLUtils::appendNode(fundingDataNode, fundingLegData_.toXML(doc));
    return node;
}

Here is the call graph for this function:

◆ underlyingIndices()

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

overridevirtual

Add underlying Bond names.

Reimplemented from Trade.

Definition at line 334 of file bondtotalreturnswap.cpp.

                                                                                                        {
    std::map<AssetClass, std::set<std::string>> result;
    result[AssetClass::BOND] = {bondData_.securityId()};
    return result;
}

◆ bondData()

const BondData & bondData ( ) const

Definition at line 53 of file bondtotalreturnswap.hpp.

53{ return bondData_; }

◆ scheduleData()

const ScheduleData & scheduleData ( ) const

Definition at line 55 of file bondtotalreturnswap.hpp.

55{ return scheduleData_; }

◆ fundingLegData()

const LegData & fundingLegData ( ) const

Definition at line 56 of file bondtotalreturnswap.hpp.

56{ return fundingLegData_; }

◆ payTotalReturnLeg()

const bool payTotalReturnLeg ( ) const

Definition at line 57 of file bondtotalreturnswap.hpp.

57{ return payTotalReturnLeg_; }

◆ initialPrice()

const Real initialPrice ( ) const

Definition at line 58 of file bondtotalreturnswap.hpp.

58{ return initialPrice_; }

◆ useDirtyPrices()

const bool useDirtyPrices ( ) const

Definition at line 59 of file bondtotalreturnswap.hpp.

59{ return useDirtyPrices_; }

◆ observationLag()

const std::string & observationLag ( ) const

Definition at line 60 of file bondtotalreturnswap.hpp.

60{ return observationLag_; }

◆ observationConvention()

const std::string & observationConvention ( ) const

Definition at line 61 of file bondtotalreturnswap.hpp.

61{ return observationConvention_; }

◆ observationCalendar()

const std::string & observationCalendar ( ) const

Definition at line 62 of file bondtotalreturnswap.hpp.

62{ return observationCalendar_; }

◆ paymentLag()

const std::string & paymentLag ( ) const

Definition at line 63 of file bondtotalreturnswap.hpp.

63{ return paymentLag_; }

◆ paymentConvention()

const std::string & paymentConvention ( ) const

Definition at line 64 of file bondtotalreturnswap.hpp.

64{ return paymentConvention_; }

◆ paymentCalendar()

const std::string & paymentCalendar ( ) const

Definition at line 65 of file bondtotalreturnswap.hpp.

65{ return paymentCalendar_; }

◆ paymentDates()

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

Definition at line 66 of file bondtotalreturnswap.hpp.

66{ return paymentDates_; }

Member Data Documentation

◆ originalBondData_

BondData originalBondData_

private

Definition at line 70 of file bondtotalreturnswap.hpp.

◆ bondData_

BondData bondData_

private

Definition at line 70 of file bondtotalreturnswap.hpp.

◆ scheduleData_

ScheduleData scheduleData_

private

Definition at line 73 of file bondtotalreturnswap.hpp.

◆ fundingLegData_

LegData fundingLegData_

private

Definition at line 74 of file bondtotalreturnswap.hpp.

◆ payTotalReturnLeg_

bool payTotalReturnLeg_ = false

private

Definition at line 75 of file bondtotalreturnswap.hpp.

◆ initialPrice_

Real initialPrice_ = Null<Real>()

private

Definition at line 76 of file bondtotalreturnswap.hpp.

◆ useDirtyPrices_

bool useDirtyPrices_ = true

private

Definition at line 77 of file bondtotalreturnswap.hpp.

◆ payBondCashFlowsImmediately_

bool payBondCashFlowsImmediately_ = false

private

Definition at line 78 of file bondtotalreturnswap.hpp.

◆ observationLag_

std::string observationLag_

private

Definition at line 79 of file bondtotalreturnswap.hpp.

◆ observationConvention_

std::string observationConvention_

private

Definition at line 80 of file bondtotalreturnswap.hpp.

◆ observationCalendar_

std::string observationCalendar_

private

Definition at line 81 of file bondtotalreturnswap.hpp.

◆ paymentLag_

std::string paymentLag_

private

Definition at line 82 of file bondtotalreturnswap.hpp.

◆ paymentConvention_

std::string paymentConvention_

private

Definition at line 83 of file bondtotalreturnswap.hpp.

◆ paymentCalendar_

std::string paymentCalendar_

private

Definition at line 84 of file bondtotalreturnswap.hpp.

◆ paymentDates_

std::vector<std::string> paymentDates_

private

Definition at line 85 of file bondtotalreturnswap.hpp.

◆ fxIndex_

string fxIndex_ = ""

private

Definition at line 88 of file bondtotalreturnswap.hpp.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BondTRS() [1/2]

◆ BondTRS() [2/2]

Member Function Documentation

◆ build()

◆ fromXML()

◆ toXML()

◆ underlyingIndices()

◆ bondData()

◆ scheduleData()

◆ fundingLegData()

◆ payTotalReturnLeg()

◆ initialPrice()

◆ useDirtyPrices()

◆ observationLag()

◆ observationConvention()

◆ observationCalendar()

◆ paymentLag()

◆ paymentConvention()

◆ paymentCalendar()

◆ paymentDates()

Member Data Documentation

◆ originalBondData_

◆ bondData_

◆ scheduleData_

◆ fundingLegData_

◆ payTotalReturnLeg_

◆ initialPrice_

◆ useDirtyPrices_

◆ payBondCashFlowsImmediately_

◆ observationLag_

◆ observationConvention_

◆ observationCalendar_

◆ paymentLag_

◆ paymentConvention_

◆ paymentCalendar_

◆ paymentDates_

◆ fxIndex_