FloatingLegBuilder Class Reference

#include <ored/portfolio/legbuilders.hpp>

Inheritance diagram for FloatingLegBuilder:

Collaboration diagram for FloatingLegBuilder:

Public Member Functions
	FloatingLegBuilder ()
Leg	buildLeg (const LegData &data, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, RequiredFixings &requiredFixings, const string &configuration, const QuantLib::Date &openEndDateReplacement=Null< Date >(), const bool useXbsCurves=false) const override
Public Member Functions inherited from LegBuilder
	LegBuilder (const string &legType)
virtual	~LegBuilder ()
virtual Leg	buildLeg (const LegData &data, const QuantLib::ext::shared_ptr< EngineFactory > &, RequiredFixings &requiredFixings, const string &configuration, const QuantLib::Date &openEndDateReplacement=Null< Date >(), const bool useXbsCurves=false) const =0
const string &	legType () const

Detailed Description

Definition at line 52 of file legbuilders.hpp.

Constructor & Destructor Documentation

FloatingLegBuilder()

FloatingLegBuilder

(

)

Definition at line 54 of file legbuilders.hpp.

: LegBuilder("Floating") {}

Member Function Documentation

buildLeg()

Leg buildLeg ( const LegData &  data, const QuantLib::ext::shared_ptr< EngineFactory > &  engineFactory, RequiredFixings &  requiredFixings, const string &  configuration, const QuantLib::Date &  openEndDateReplacement = Null<Date>(), const bool  useXbsCurves = false  ) const

overridevirtual

Implements LegBuilder.

Definition at line 79 of file legbuilders.cpp.

                                                                                                            {
    auto floatData = QuantLib::ext::dynamic_pointer_cast<FloatingLegData>(data.concreteLegData());
    QL_REQUIRE(floatData, "Wrong LegType, expected Floating");
    string indexName = floatData->index();
    auto index = *engineFactory->market()->iborIndex(indexName, configuration);
    
    auto ois = QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(index);
    Leg result;
    if (ois != nullptr) {
        QuantLib::ext::shared_ptr<OvernightIndex> idx = ois;
        if (!floatData->historicalFixings().empty())
            idx = QuantLib::ext::make_shared<OvernightIndexWithFixingOverride>(ois, floatData->historicalFixings());
        result = makeOISLeg(data, idx, engineFactory, true, openEndDateReplacement);
    } else {
        auto bma = QuantLib::ext::dynamic_pointer_cast<QuantExt::BMAIndexWrapper>(index);
        if (bma != nullptr)
            result = makeBMALeg(data, bma, engineFactory, openEndDateReplacement);
        else {
            QuantLib::ext::shared_ptr<IborIndex> idx = index;
            if (!floatData->historicalFixings().empty())
                idx = QuantLib::ext::make_shared<IborIndexWithFixingOverride>(index, floatData->historicalFixings());
            result = makeIborLeg(data, idx, engineFactory, true, openEndDateReplacement);
        }
    }
    applyIndexing(result, data, engineFactory, requiredFixings, openEndDateReplacement, useXbsCurves);
    addToRequiredFixings(result, QuantLib::ext::make_shared<FixingDateGetter>(requiredFixings));
 
    // handle fx resetting Ibor leg
 
    if (data.legType() == "Floating" && !data.isNotResetXCCY()) {
        QL_REQUIRE(!data.fxIndex().empty(), "FloatingRateLegBuilder: need fx index for fx resetting leg");
        auto fxIndex = buildFxIndex(data.fxIndex(), data.currency(), data.foreignCurrency(), engineFactory->market(),
                                    configuration, true);       
 
        // If the domestic notional value is not specified, i.e. there are no notionals specified in the leg
        // data, then all coupons including the first will be FX linked. If the first coupon's FX fixing date
        // is in the past, a FX fixing will be used to determine the first domestic notional. If the first
        // coupon's FX fixing date is in the future, the first coupon's domestic notional will be determined
        // by the FX forward rate on that future fixing date.
 
        Size j = 0;
        if (data.notionals().size() == 0) {
            DLOG("Building FX Resettable with unspecified domestic notional");
        } else {
            // First coupon a plain floating rate coupon i.e. it is not FX linked because the initial notional is
            // known. But, we need to add it to additionalLegs_ so that we don't miss the first coupon's ibor fixing
            LOG("Building FX Resettable with first domestic notional specified explicitly");
            j = 1;
        }
 
        // Make the necessary FX linked floating rate coupons
        for (; j < result.size(); ++j) {
            QuantLib::ext::shared_ptr<FloatingRateCoupon> coupon =
                QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(result[j]);            
            Date fixingDate = fxIndex->fixingCalendar().advance(coupon->accrualStartDate(),
                                                                -static_cast<Integer>(fxIndex->fixingDays()), Days);
            QuantLib::ext::shared_ptr<FloatingRateFXLinkedNotionalCoupon> fxLinkedCoupon =
                QuantLib::ext::make_shared<FloatingRateFXLinkedNotionalCoupon>(fixingDate, data.foreignAmount(), 
                    fxIndex, coupon);
            // set the same pricer
            fxLinkedCoupon->setPricer(coupon->pricer());
            result[j] = fxLinkedCoupon;
 
            // Add the FX fixing to the required fixings
            requiredFixings.addFixingDate(fixingDate, data.fxIndex(), fxLinkedCoupon->date());
        }
    }
 
    return result;
}

Here is the call graph for this function: