#include <ored/configuration/conventions.hpp>

Inheritance diagram for CommodityFutureConvention:

Collaboration diagram for CommodityFutureConvention:

Classes
class	AveragingData

struct	BusinessDaysAfter

struct	CalendarDaysBefore

struct	DayOfMonth
	Classes to differentiate constructors below. More...

class	OffPeakPowerIndexData
	Class to store conventions for creating an off peak power index. More...

struct	OptionExpiryAnchorDateRule

class	ProhibitedExpiry
	Class to hold prohibited expiry information. More...

struct	WeeklyWeekday

Public Types
enum class	AnchorType { DayOfMonth , NthWeekday , CalendarDaysBefore , LastWeekday , BusinessDaysAfter , WeeklyDayOfTheWeek }

enum class	OptionAnchorType { DayOfMonth , NthWeekday , BusinessDaysBefore , LastWeekday , WeeklyDayOfTheWeek }

Public Types inherited from Convention
enum class	Type { Zero , Deposit , Future , FRA , OIS , Swap , AverageOIS , TenorBasisSwap , TenorBasisTwoSwap , BMABasisSwap , FX , CrossCcyBasis , CrossCcyFixFloat , CDS , IborIndex , OvernightIndex , SwapIndex , ZeroInflationIndex , InflationSwap , SecuritySpread , CMSSpreadOption , CommodityForward , CommodityFuture , FxOption , BondYield }
	Supported convention types. More...

Public Member Functions
Constructors
	CommodityFutureConvention ()
	Default constructor. More...

	CommodityFutureConvention (const std::string &id, const DayOfMonth &dayOfMonth, const std::string &contractFrequency, const std::string &calendar, const std::string &expiryCalendar="", QuantLib::Size expiryMonthLag=0, const std::string &oneContractMonth="", const std::string &offsetDays="", const std::string &bdc="", bool adjustBeforeOffset=true, bool isAveraging=false, const OptionExpiryAnchorDateRule &optionExpiryDateRule=OptionExpiryAnchorDateRule(), const std::set< ProhibitedExpiry > &prohibitedExpiries={}, QuantLib::Size optionExpiryMonthLag=0, const std::string &optionBdc="", const std::map< QuantLib::Natural, QuantLib::Natural > &futureContinuationMappings={}, const std::map< QuantLib::Natural, QuantLib::Natural > &optionContinuationMappings={}, const AveragingData &averagingData=AveragingData(), QuantLib::Natural hoursPerDay=QuantLib::Null< QuantLib::Natural >(), const boost::optional< OffPeakPowerIndexData > &offPeakPowerIndexData=boost::none, const std::string &indexName="", const std::string &optionFrequency="")
	Day of month based constructor. More...

	CommodityFutureConvention (const std::string &id, const std::string &nth, const std::string &weekday, const std::string &contractFrequency, const std::string &calendar, const std::string &expiryCalendar="", QuantLib::Size expiryMonthLag=0, const std::string &oneContractMonth="", const std::string &offsetDays="", const std::string &bdc="", bool adjustBeforeOffset=true, bool isAveraging=false, const OptionExpiryAnchorDateRule &optionExpiryDateRule=OptionExpiryAnchorDateRule(), const std::set< ProhibitedExpiry > &prohibitedExpiries={}, QuantLib::Size optionExpiryMonthLag=0, const std::string &optionBdc="", const std::map< QuantLib::Natural, QuantLib::Natural > &futureContinuationMappings={}, const std::map< QuantLib::Natural, QuantLib::Natural > &optionContinuationMappings={}, const AveragingData &averagingData=AveragingData(), QuantLib::Natural hoursPerDay=QuantLib::Null< QuantLib::Natural >(), const boost::optional< OffPeakPowerIndexData > &offPeakPowerIndexData=boost::none, const std::string &indexName="", const std::string &optionFrequency="")
	N-th weekday based constructor. More...

	CommodityFutureConvention (const std::string &id, const CalendarDaysBefore &calendarDaysBefore, const std::string &contractFrequency, const std::string &calendar, const std::string &expiryCalendar="", QuantLib::Size expiryMonthLag=0, const std::string &oneContractMonth="", const std::string &offsetDays="", const std::string &bdc="", bool adjustBeforeOffset=true, bool isAveraging=false, const OptionExpiryAnchorDateRule &optionExpiryDateRule=OptionExpiryAnchorDateRule(), const std::set< ProhibitedExpiry > &prohibitedExpiries={}, QuantLib::Size optionExpiryMonthLag=0, const std::string &optionBdc="", const std::map< QuantLib::Natural, QuantLib::Natural > &futureContinuationMappings={}, const std::map< QuantLib::Natural, QuantLib::Natural > &optionContinuationMappings={}, const AveragingData &averagingData=AveragingData(), QuantLib::Natural hoursPerDay=QuantLib::Null< QuantLib::Natural >(), const boost::optional< OffPeakPowerIndexData > &offPeakPowerIndexData=boost::none, const std::string &indexName="", const std::string &optionFrequency="")
	Calendar days before based constructor. More...

	CommodityFutureConvention (const std::string &id, const BusinessDaysAfter &businessDaysAfter, const std::string &contractFrequency, const std::string &calendar, const std::string &expiryCalendar="", QuantLib::Size expiryMonthLag=0, const std::string &oneContractMonth="", const std::string &offsetDays="", const std::string &bdc="", bool adjustBeforeOffset=true, bool isAveraging=false, const OptionExpiryAnchorDateRule &optionExpiryDateRule=OptionExpiryAnchorDateRule(), const std::set< ProhibitedExpiry > &prohibitedExpiries={}, QuantLib::Size optionExpiryMonthLag=0, const std::string &optionBdc="", const std::map< QuantLib::Natural, QuantLib::Natural > &futureContinuationMappings={}, const std::map< QuantLib::Natural, QuantLib::Natural > &optionContinuationMappings={}, const AveragingData &averagingData=AveragingData(), QuantLib::Natural hoursPerDay=QuantLib::Null< QuantLib::Natural >(), const boost::optional< OffPeakPowerIndexData > &offPeakPowerIndexData=boost::none, const std::string &indexName="", const std::string &optionFrequency="")
	Business days before based constructor. More...

Public Member Functions inherited from Convention
virtual	~Convention ()
	Default destructor. More...

const string &	id () const

Type	type () 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...

Inspectors
AnchorType	anchorType_

QuantLib::Natural	dayOfMonth_

QuantLib::Natural	nth_

QuantLib::Weekday	weekday_

QuantLib::Natural	calendarDaysBefore_

QuantLib::Integer	businessDaysAfter_

QuantLib::Frequency	contractFrequency_

QuantLib::Calendar	calendar_

QuantLib::Calendar	expiryCalendar_

QuantLib::Month	oneContractMonth_

QuantLib::Integer	offsetDays_

QuantLib::BusinessDayConvention	bdc_

std::string	strDayOfMonth_

std::string	strNth_

std::string	strWeekday_

std::string	strCalendarDaysBefore_

std::string	strBusinessDaysAfter_

std::string	strContractFrequency_

std::string	strCalendar_

std::string	strExpiryCalendar_

QuantLib::Size	expiryMonthLag_

std::string	strOneContractMonth_

std::string	strOffsetDays_

std::string	strBdc_

bool	adjustBeforeOffset_

bool	isAveraging_

std::set< ProhibitedExpiry >	prohibitedExpiries_

QuantLib::Size	optionExpiryMonthLag_

QuantLib::BusinessDayConvention	optionBdc_

std::string	strOptionBdc_

std::map< QuantLib::Natural, QuantLib::Natural >	futureContinuationMappings_

std::map< QuantLib::Natural, QuantLib::Natural >	optionContinuationMappings_

AveragingData	averagingData_

QuantLib::Natural	hoursPerDay_

boost::optional< OffPeakPowerIndexData >	offPeakPowerIndexData_

std::string	indexName_

std::string	strOptionContractFrequency_

OptionAnchorType	optionAnchorType_

std::string	strOptionExpiryOffset_

std::string	strOptionExpiryDay_

std::string	strOptionNth_

std::string	strOptionWeekday_

QuantLib::Frequency	optionContractFrequency_

QuantLib::Natural	optionExpiryOffset_

QuantLib::Natural	optionNth_

QuantLib::Weekday	optionWeekday_

QuantLib::Natural	optionExpiryDay_

std::set< QuantLib::Month >	validContractMonths_

std::string	savingsTime_

bool	balanceOfTheMonth_

std::string	balanceOfTheMonthPricingCalendarStr_

Calendar	balanceOfTheMonthPricingCalendar_

std::string	optionUnderlyingFutureConvention_
	Option Underlying Future convention. More...

AnchorType	anchorType () const

QuantLib::Natural	dayOfMonth () const

QuantLib::Natural	nth () const

QuantLib::Weekday	weekday () const

QuantLib::Natural	calendarDaysBefore () const

QuantLib::Integer	businessDaysAfter () const

QuantLib::Frequency	contractFrequency () const

const QuantLib::Calendar &	calendar () const

const QuantLib::Calendar &	expiryCalendar () const

QuantLib::Size	expiryMonthLag () const

QuantLib::Month	oneContractMonth () const

QuantLib::Integer	offsetDays () const

QuantLib::BusinessDayConvention	businessDayConvention () const

bool	adjustBeforeOffset () const

bool	isAveraging () const

QuantLib::Natural	optionExpiryOffset () const

const std::set< ProhibitedExpiry > &	prohibitedExpiries () const

QuantLib::Size	optionExpiryMonthLag () const

QuantLib::Natural	optionExpiryDay () const

QuantLib::BusinessDayConvention	optionBusinessDayConvention () const

const std::map< QuantLib::Natural, QuantLib::Natural > &	futureContinuationMappings () const

const std::map< QuantLib::Natural, QuantLib::Natural > &	optionContinuationMappings () const

const AveragingData &	averagingData () const

QuantLib::Natural	hoursPerDay () const

const boost::optional< OffPeakPowerIndexData > &	offPeakPowerIndexData () const

const std::string &	indexName () const

QuantLib::Frequency	optionContractFrequency () const

OptionAnchorType	optionAnchorType () const

QuantLib::Natural	optionNth () const

QuantLib::Weekday	optionWeekday () const

const std::string &	savingsTime () const

const std::set< QuantLib::Month > &	validContractMonths () const

bool	balanceOfTheMonth () const

Calendar	balanceOfTheMonthPricingCalendar () const

const std::string &	optionUnderlyingFutureConvention () const

void	fromXML (XMLNode *node) override
	Serialisation. More...

XMLNode *	toXML (XMLDocument &doc) const override

void	build () override
	Implementation. More...

Frequency	parseAndValidateFrequency (const std::string &strFrequency)
	Populate and check frequency. More...

bool	validateBdc (const ProhibitedExpiry &pe) const
	Validate the business day conventions in the ProhibitedExpiry. More...

Additional Inherited Members
Protected Member Functions inherited from Convention
	Convention ()

	Convention (const string &id, Type type)

Protected Attributes inherited from Convention
Type	type_

string	id_

Detailed Description

Container for storing commodity future conventions

Definition at line 1317 of file conventions.hpp.

Member Enumeration Documentation

◆ AnchorType

enum class AnchorType

strong

The anchor day type of commodity future convention

Enumerator
DayOfMonth
NthWeekday
CalendarDaysBefore
LastWeekday
BusinessDaysAfter
WeeklyDayOfTheWeek

Definition at line 1321 of file conventions.hpp.

1321{ DayOfMonth, NthWeekday, CalendarDaysBefore, LastWeekday, BusinessDaysAfter, WeeklyDayOfTheWeek };

ore::data::CommodityFutureConvention::AnchorType::NthWeekday

@ NthWeekday

ore::data::CommodityFutureConvention::AnchorType::WeeklyDayOfTheWeek

@ WeeklyDayOfTheWeek

ore::data::CommodityFutureConvention::AnchorType::LastWeekday

@ LastWeekday

◆ OptionAnchorType

enum class OptionAnchorType

strong

Enumerator
DayOfMonth
NthWeekday
BusinessDaysBefore
LastWeekday
WeeklyDayOfTheWeek

Definition at line 1322 of file conventions.hpp.

1322{ DayOfMonth, NthWeekday, BusinessDaysBefore, LastWeekday, WeeklyDayOfTheWeek };

ore::data::CommodityFutureConvention::OptionAnchorType::BusinessDaysBefore

@ BusinessDaysBefore

Constructor & Destructor Documentation

◆ CommodityFutureConvention() [1/5]

CommodityFutureConvention ( )

Default constructor.

Definition at line 1712 of file conventions.cpp.

    : anchorType_(AnchorType::DayOfMonth),
      dayOfMonth_(1),
      nth_(1),
      weekday_(Mon),
      calendarDaysBefore_(0),
      contractFrequency_(Monthly),
      oneContractMonth_(Jan),
      offsetDays_(0),
      bdc_(Following),
      expiryMonthLag_(0),
      adjustBeforeOffset_(false),
      isAveraging_(false),
      optionExpiryMonthLag_(0),
      optionBdc_(Preceding),
      hoursPerDay_(Null<Natural>()),
      optionAnchorType_(OptionAnchorType::BusinessDaysBefore), 
      optionContractFrequency_(Monthly), 
      optionExpiryOffset_(0),
      optionNth_(1), 
      optionWeekday_(Mon),
      optionExpiryDay_(Null<Natural>()), 
      balanceOfTheMonth_(false) {}

◆ CommodityFutureConvention() [2/5]

CommodityFutureConvention	(	const std::string &	id,
		const DayOfMonth &	dayOfMonth,
		const std::string &	contractFrequency,
		const std::string &	calendar,
		const std::string &	expiryCalendar = `""`,
		QuantLib::Size	expiryMonthLag = `0`,
		const std::string &	oneContractMonth = `""`,
		const std::string &	offsetDays = `""`,
		const std::string &	bdc = `""`,
		bool	adjustBeforeOffset = `true`,
		bool	isAveraging = `false`,
		const OptionExpiryAnchorDateRule &	optionExpiryDateRule = `OptionExpiryAnchorDateRule()`,
		const std::set< ProhibitedExpiry > &	prohibitedExpiries = `{}`,
		QuantLib::Size	optionExpiryMonthLag = `0`,
		const std::string &	optionBdc = `""`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	futureContinuationMappings = `{}`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	optionContinuationMappings = `{}`,
		const AveragingData &	averagingData = `AveragingData()`,
		QuantLib::Natural	hoursPerDay = `QuantLib::Null< QuantLib::Natural >()`,
		const boost::optional< OffPeakPowerIndexData > &	offPeakPowerIndexData = `boost::none`,
		const std::string &	indexName = `""`,
		const std::string &	optionFrequency = `""`
	)

Day of month based constructor.

◆ CommodityFutureConvention() [3/5]

CommodityFutureConvention	(	const std::string &	id,
		const std::string &	nth,
		const std::string &	weekday,
		const std::string &	contractFrequency,
		const std::string &	calendar,
		const std::string &	expiryCalendar = `""`,
		QuantLib::Size	expiryMonthLag = `0`,
		const std::string &	oneContractMonth = `""`,
		const std::string &	offsetDays = `""`,
		const std::string &	bdc = `""`,
		bool	adjustBeforeOffset = `true`,
		bool	isAveraging = `false`,
		const OptionExpiryAnchorDateRule &	optionExpiryDateRule = `OptionExpiryAnchorDateRule()`,
		const std::set< ProhibitedExpiry > &	prohibitedExpiries = `{}`,
		QuantLib::Size	optionExpiryMonthLag = `0`,
		const std::string &	optionBdc = `""`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	futureContinuationMappings = `{}`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	optionContinuationMappings = `{}`,
		const AveragingData &	averagingData = `AveragingData()`,
		QuantLib::Natural	hoursPerDay = `QuantLib::Null< QuantLib::Natural >()`,
		const boost::optional< OffPeakPowerIndexData > &	offPeakPowerIndexData = `boost::none`,
		const std::string &	indexName = `""`,
		const std::string &	optionFrequency = `""`
	)

N-th weekday based constructor.

◆ CommodityFutureConvention() [4/5]

CommodityFutureConvention	(	const std::string &	id,
		const CalendarDaysBefore &	calendarDaysBefore,
		const std::string &	contractFrequency,
		const std::string &	calendar,
		const std::string &	expiryCalendar = `""`,
		QuantLib::Size	expiryMonthLag = `0`,
		const std::string &	oneContractMonth = `""`,
		const std::string &	offsetDays = `""`,
		const std::string &	bdc = `""`,
		bool	adjustBeforeOffset = `true`,
		bool	isAveraging = `false`,
		const OptionExpiryAnchorDateRule &	optionExpiryDateRule = `OptionExpiryAnchorDateRule()`,
		const std::set< ProhibitedExpiry > &	prohibitedExpiries = `{}`,
		QuantLib::Size	optionExpiryMonthLag = `0`,
		const std::string &	optionBdc = `""`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	futureContinuationMappings = `{}`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	optionContinuationMappings = `{}`,
		const AveragingData &	averagingData = `AveragingData()`,
		QuantLib::Natural	hoursPerDay = `QuantLib::Null< QuantLib::Natural >()`,
		const boost::optional< OffPeakPowerIndexData > &	offPeakPowerIndexData = `boost::none`,
		const std::string &	indexName = `""`,
		const std::string &	optionFrequency = `""`
	)

Calendar days before based constructor.

◆ CommodityFutureConvention() [5/5]

CommodityFutureConvention	(	const std::string &	id,
		const BusinessDaysAfter &	businessDaysAfter,
		const std::string &	contractFrequency,
		const std::string &	calendar,
		const std::string &	expiryCalendar = `""`,
		QuantLib::Size	expiryMonthLag = `0`,
		const std::string &	oneContractMonth = `""`,
		const std::string &	offsetDays = `""`,
		const std::string &	bdc = `""`,
		bool	adjustBeforeOffset = `true`,
		bool	isAveraging = `false`,
		const OptionExpiryAnchorDateRule &	optionExpiryDateRule = `OptionExpiryAnchorDateRule()`,
		const std::set< ProhibitedExpiry > &	prohibitedExpiries = `{}`,
		QuantLib::Size	optionExpiryMonthLag = `0`,
		const std::string &	optionBdc = `""`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	futureContinuationMappings = `{}`,
		const std::map< QuantLib::Natural, QuantLib::Natural > &	optionContinuationMappings = `{}`,
		const AveragingData &	averagingData = `AveragingData()`,
		QuantLib::Natural	hoursPerDay = `QuantLib::Null< QuantLib::Natural >()`,
		const boost::optional< OffPeakPowerIndexData > &	offPeakPowerIndexData = `boost::none`,
		const std::string &	indexName = `""`,
		const std::string &	optionFrequency = `""`
	)

Business days before based constructor.

Member Function Documentation

◆ anchorType()

AnchorType anchorType ( ) const

Definition at line 1565 of file conventions.hpp.

1565{ return anchorType_; }

Here is the caller graph for this function:

◆ dayOfMonth()

QuantLib::Natural dayOfMonth ( ) const

Definition at line 1566 of file conventions.hpp.

1566{ return dayOfMonth_; }

Here is the caller graph for this function:

◆ nth()

QuantLib::Natural nth ( ) const

Definition at line 1567 of file conventions.hpp.

1567{ return nth_; }

Here is the caller graph for this function:

◆ weekday()

QuantLib::Weekday weekday ( ) const

Definition at line 1568 of file conventions.hpp.

1568{ return weekday_; }

Here is the caller graph for this function:

◆ calendarDaysBefore()

QuantLib::Natural calendarDaysBefore ( ) const

Definition at line 1569 of file conventions.hpp.

1569{ return calendarDaysBefore_; }

Here is the caller graph for this function:

◆ businessDaysAfter()

QuantLib::Integer businessDaysAfter ( ) const

Definition at line 1570 of file conventions.hpp.

1570{ return businessDaysAfter_; }

ore::data::CommodityFutureConvention::businessDaysAfter_

QuantLib::Integer businessDaysAfter_

Definition: conventions.hpp:1623

Here is the caller graph for this function:

◆ contractFrequency()

QuantLib::Frequency contractFrequency ( ) const

Definition at line 1571 of file conventions.hpp.

1571{ return contractFrequency_; }

Here is the caller graph for this function:

◆ calendar()

const QuantLib::Calendar & calendar ( ) const

Definition at line 1572 of file conventions.hpp.

1572{ return calendar_; }

ore::data::CommodityFutureConvention::calendar_

QuantLib::Calendar calendar_

Definition: conventions.hpp:1625

Here is the caller graph for this function:

◆ expiryCalendar()

const QuantLib::Calendar & expiryCalendar ( ) const

Definition at line 1573 of file conventions.hpp.

1573{ return expiryCalendar_; }

ore::data::CommodityFutureConvention::expiryCalendar_

QuantLib::Calendar expiryCalendar_

Definition: conventions.hpp:1626

Here is the caller graph for this function:

◆ expiryMonthLag()

QuantLib::Size expiryMonthLag ( ) const

Definition at line 1574 of file conventions.hpp.

1574{ return expiryMonthLag_; }

Here is the caller graph for this function:

◆ oneContractMonth()

QuantLib::Month oneContractMonth ( ) const

Definition at line 1575 of file conventions.hpp.

1575{ return oneContractMonth_; }

◆ offsetDays()

QuantLib::Integer offsetDays ( ) const

Definition at line 1576 of file conventions.hpp.

1576{ return offsetDays_; }

Here is the caller graph for this function:

◆ businessDayConvention()

QuantLib::BusinessDayConvention businessDayConvention ( ) const

Definition at line 1577 of file conventions.hpp.

1577{ return bdc_; }

Here is the caller graph for this function:

◆ adjustBeforeOffset()

bool adjustBeforeOffset ( ) const

Definition at line 1578 of file conventions.hpp.

1578{ return adjustBeforeOffset_; }

Here is the caller graph for this function:

◆ isAveraging()

bool isAveraging ( ) const

Definition at line 1579 of file conventions.hpp.

1579{ return isAveraging_; }

Here is the caller graph for this function:

◆ optionExpiryOffset()

QuantLib::Natural optionExpiryOffset ( ) const

Definition at line 1580 of file conventions.hpp.

1580{ return optionExpiryOffset_; }

Here is the caller graph for this function:

◆ prohibitedExpiries()

const std::set< ProhibitedExpiry > & prohibitedExpiries ( ) const

Definition at line 1581 of file conventions.hpp.

                                                               {
        return prohibitedExpiries_;
    }

Here is the caller graph for this function:

◆ optionExpiryMonthLag()

QuantLib::Size optionExpiryMonthLag ( ) const

Definition at line 1584 of file conventions.hpp.

1584{ return optionExpiryMonthLag_; }

Here is the caller graph for this function:

◆ optionExpiryDay()

QuantLib::Natural optionExpiryDay ( ) const

Definition at line 1585 of file conventions.hpp.

1585{ return optionExpiryDay_; }

Here is the caller graph for this function:

◆ optionBusinessDayConvention()

QuantLib::BusinessDayConvention optionBusinessDayConvention ( ) const

Definition at line 1586 of file conventions.hpp.

1586{ return optionBdc_; }

Here is the caller graph for this function:

◆ futureContinuationMappings()

const std::map< QuantLib::Natural, QuantLib::Natural > & futureContinuationMappings ( ) const

Definition at line 1587 of file conventions.hpp.

                                                                                       {
        return futureContinuationMappings_;
    }

◆ optionContinuationMappings()

const std::map< QuantLib::Natural, QuantLib::Natural > & optionContinuationMappings ( ) const

Definition at line 1590 of file conventions.hpp.

                                                                                       {
        return optionContinuationMappings_;
    }

◆ averagingData()

const AveragingData & averagingData ( ) const

Definition at line 1593 of file conventions.hpp.

1593{ return averagingData_; }

ore::data::CommodityFutureConvention::averagingData_

AveragingData averagingData_

Definition: conventions.hpp:1652

◆ hoursPerDay()

QuantLib::Natural hoursPerDay ( ) const

Definition at line 1594 of file conventions.hpp.

1594{ return hoursPerDay_; }

◆ offPeakPowerIndexData()

const boost::optional< OffPeakPowerIndexData > & offPeakPowerIndexData ( ) const

Definition at line 1595 of file conventions.hpp.

1595{ return offPeakPowerIndexData_; }

ore::data::CommodityFutureConvention::offPeakPowerIndexData_

boost::optional< OffPeakPowerIndexData > offPeakPowerIndexData_

Definition: conventions.hpp:1654

◆ indexName()

const std::string & indexName ( ) const

Definition at line 1596 of file conventions.hpp.

1596{ return indexName_; }

ore::data::CommodityFutureConvention::indexName_

std::string indexName_

Definition: conventions.hpp:1655

◆ optionContractFrequency()

QuantLib::Frequency optionContractFrequency ( ) const

Definition at line 1597 of file conventions.hpp.

1597{ return optionContractFrequency_; }

Here is the caller graph for this function:

◆ optionAnchorType()

OptionAnchorType optionAnchorType ( ) const

Definition at line 1598 of file conventions.hpp.

1598{ return optionAnchorType_; }

Here is the caller graph for this function:

◆ optionNth()

QuantLib::Natural optionNth ( ) const

Definition at line 1599 of file conventions.hpp.

1599{ return optionNth_; }

Here is the caller graph for this function:

◆ optionWeekday()

QuantLib::Weekday optionWeekday ( ) const

Definition at line 1600 of file conventions.hpp.

1600{ return optionWeekday_; }

Here is the caller graph for this function:

◆ savingsTime()

const std::string & savingsTime ( ) const

Definition at line 1601 of file conventions.hpp.

1601{ return savingsTime_; }

ore::data::CommodityFutureConvention::savingsTime_

std::string savingsTime_

Definition: conventions.hpp:1673

◆ validContractMonths()

const std::set< QuantLib::Month > & validContractMonths ( ) const

Definition at line 1602 of file conventions.hpp.

1602{ return validContractMonths_; }

ore::data::CommodityFutureConvention::validContractMonths_

std::set< QuantLib::Month > validContractMonths_

Definition: conventions.hpp:1672

Here is the caller graph for this function:

◆ balanceOfTheMonth()

bool balanceOfTheMonth ( ) const

Definition at line 1603 of file conventions.hpp.

1603{ return balanceOfTheMonth_; }

◆ balanceOfTheMonthPricingCalendar()

Calendar balanceOfTheMonthPricingCalendar ( ) const

Definition at line 1604 of file conventions.hpp.

1604{ return balanceOfTheMonthPricingCalendar_; }

ore::data::CommodityFutureConvention::balanceOfTheMonthPricingCalendar_

Calendar balanceOfTheMonthPricingCalendar_

Definition: conventions.hpp:1679

◆ optionUnderlyingFutureConvention()

const std::string & optionUnderlyingFutureConvention ( ) const

Definition at line 1605 of file conventions.hpp.

1605{ return optionUnderlyingFutureConvention_; }

ore::data::CommodityFutureConvention::optionUnderlyingFutureConvention_

std::string optionUnderlyingFutureConvention_

Option Underlying Future convention.

Definition: conventions.hpp:1681

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Serialisation.

Implements XMLSerializable.

Definition at line 1858 of file conventions.cpp.

                                                     {
 
    XMLUtils::checkNode(node, "CommodityFuture");
    type_ = Type::CommodityFuture;
    id_ = XMLUtils::getChildValue(node, "Id", true);
 
    // Parse contract frequency first. If it is Daily, we do not need the AnchorDay node.
    strContractFrequency_ = XMLUtils::getChildValue(node, "ContractFrequency", true);
    strOptionContractFrequency_ = XMLUtils::getChildValue(node, "OptionContractFrequency", false);
    if (strOptionContractFrequency_.empty())
        strOptionContractFrequency_ = strContractFrequency_;
 
    contractFrequency_ = parseAndValidateFrequency(strContractFrequency_);
    optionContractFrequency_ = parseAndValidateFrequency(strOptionContractFrequency_);
   
    // Variables related to the anchor day in a given month. Not needed if daily.
    if (contractFrequency_ == Weekly) {
        XMLNode* anchorNode = XMLUtils::getChildNode(node, "AnchorDay");
        if (XMLNode* tmp = XMLUtils::getChildNode(anchorNode, "WeeklyDayOfTheWeek")) {
            anchorType_ = AnchorType::WeeklyDayOfTheWeek;
            strWeekday_ = XMLUtils::getNodeValue(tmp);
        } else {
            QL_FAIL("Failed to parse AnchorDay node, the WeeklyDayOfTheWeek node is required for weekly contract expiries.");
        }
    } else if (contractFrequency_ != Daily || optionContractFrequency_ != Daily) {
        XMLNode* anchorNode = XMLUtils::getChildNode(node, "AnchorDay");
        QL_REQUIRE(anchorNode, "Expected an AnchorDay node in the FutureExpiry convention");
        if (XMLNode* nthNode = XMLUtils::getChildNode(anchorNode, "NthWeekday")) {
            anchorType_ = AnchorType::NthWeekday;
            strNth_ = XMLUtils::getChildValue(nthNode, "Nth", true);
            strWeekday_ = XMLUtils::getChildValue(nthNode, "Weekday", true);
        } else if (XMLNode* tmp = XMLUtils::getChildNode(anchorNode, "DayOfMonth")) {
            anchorType_ = AnchorType::DayOfMonth;
            strDayOfMonth_ = XMLUtils::getNodeValue(tmp);
        } else if (XMLNode* tmp = XMLUtils::getChildNode(anchorNode, "CalendarDaysBefore")) {
            anchorType_ = AnchorType::CalendarDaysBefore;
            strCalendarDaysBefore_ = XMLUtils::getNodeValue(tmp);
        } else if (XMLNode* tmp = XMLUtils::getChildNode(anchorNode, "LastWeekday")) {
            anchorType_ = AnchorType::LastWeekday;
            strWeekday_ = XMLUtils::getNodeValue(tmp);
        } else if (XMLNode* tmp = XMLUtils::getChildNode(anchorNode, "BusinessDaysAfter")) {
            anchorType_ = AnchorType::BusinessDaysAfter;
            strBusinessDaysAfter_ = XMLUtils::getNodeValue(tmp);
        } else {
            QL_FAIL("Failed to parse AnchorDay node");
        }
    }
 
    strCalendar_ = XMLUtils::getChildValue(node, "Calendar", true);
    strExpiryCalendar_ = XMLUtils::getChildValue(node, "ExpiryCalendar", false);
 
    expiryMonthLag_ = 0;
    if (XMLNode* n = XMLUtils::getChildNode(node, "ExpiryMonthLag")) {
        expiryMonthLag_ = parseInteger(XMLUtils::getNodeValue(n));
    }
 
    strOneContractMonth_ = XMLUtils::getChildValue(node, "OneContractMonth", false);
    strOffsetDays_ = XMLUtils::getChildValue(node, "OffsetDays", false);
    strBdc_ = XMLUtils::getChildValue(node, "BusinessDayConvention", false);
 
    adjustBeforeOffset_ = true;
    if (XMLNode* n = XMLUtils::getChildNode(node, "AdjustBeforeOffset")) {
        adjustBeforeOffset_ = parseBool(XMLUtils::getNodeValue(n));
    }
 
    isAveraging_ = false;
    if (XMLNode* n = XMLUtils::getChildNode(node, "IsAveraging")) {
        isAveraging_ = parseBool(XMLUtils::getNodeValue(n));
    }
 
    optionExpiryMonthLag_ = 0;
    if (XMLNode* n = XMLUtils::getChildNode(node, "OptionExpiryMonthLag")) {
        optionExpiryMonthLag_ = parseInteger(XMLUtils::getNodeValue(n));
    }
 
    bool foundOptionExpiryRule = false;
    std::string previouslyFoundOptionExpiryRule = "";
 
    if (XMLNode* n = XMLUtils::getChildNode(node, "OptionExpiryOffset")) {
        QL_REQUIRE(optionContractFrequency_ != Weekly, "OptionExpiryOffset is not allowed for weekly option expiries");
        optionAnchorType_ = OptionAnchorType::BusinessDaysBefore;
        strOptionExpiryOffset_ = XMLUtils::getNodeValue(n);
        foundOptionExpiryRule = true;
        previouslyFoundOptionExpiryRule = "OptionExpiryOffset";
    }
   
    if (XMLNode* n = XMLUtils::getChildNode(node, "OptionExpiryDay")) {
        QL_REQUIRE(!foundOptionExpiryRule, "Expect exactly one option expiry anchor date rule, found "
                                               << previouslyFoundOptionExpiryRule << " and OptionExpiryDay");
        QL_REQUIRE(optionContractFrequency_ != Weekly, "OptionExpiryDay is not allowed for weekly option expiries");
        optionAnchorType_ = OptionAnchorType::DayOfMonth;
        strOptionExpiryDay_ = XMLUtils::getNodeValue(n);
        foundOptionExpiryRule = true;
        previouslyFoundOptionExpiryRule = "OptionExpiryDay";
    }
 
    if (XMLNode* optionNthNode = XMLUtils::getChildNode(node, "OptionNthWeekday")) {
        QL_REQUIRE(!foundOptionExpiryRule, "Expect exactly one option expiry anchor date rule, found "
                                               << previouslyFoundOptionExpiryRule << " and OptionNthWeekday");
        QL_REQUIRE(optionContractFrequency_ != Weekly,
                   "OptionNthWeekday is not allowed for weekly option expiries");
        optionAnchorType_ = OptionAnchorType::NthWeekday;
        strOptionNth_ = XMLUtils::getChildValue(optionNthNode, "Nth", true);
        strOptionWeekday_ = XMLUtils::getChildValue(optionNthNode, "Weekday", true);
        foundOptionExpiryRule = true;
        previouslyFoundOptionExpiryRule = "OptionNthWeekday";
    }  
 
    if (XMLNode* n = XMLUtils::getChildNode(node, "OptionExpiryLastWeekdayOfMonth")) {
        QL_REQUIRE(!foundOptionExpiryRule, "Expect exactly one option expiry anchor date rule, found "
                                               << previouslyFoundOptionExpiryRule << " and OptionExpiryLastWeekdayOfMonth");
        QL_REQUIRE(optionContractFrequency_ != Weekly,
                   "OptionExpiryLastWeekdayOfMonth is not allowed for weekly option expiries");
        optionAnchorType_ = OptionAnchorType::LastWeekday;
        strOptionWeekday_ = XMLUtils::getNodeValue(n);
        foundOptionExpiryRule = true;
        previouslyFoundOptionExpiryRule = "OptionExpiryLastWeekdayOfMonth";
    }
 
    if (XMLNode* n = XMLUtils::getChildNode(node, "OptionExpiryWeeklyDayOfTheWeek")) {
        QL_REQUIRE(!foundOptionExpiryRule, "Expect exactly one option expiry anchor date rule, found "
                                               << previouslyFoundOptionExpiryRule
                                               << " and OptionExpiryWeeklyDayOfTheWeek");
        QL_REQUIRE(optionContractFrequency_ == Weekly,
                   "OptionExpiryWeeklyDayOfTheWeek only allowed for weekly option expiries");
        optionAnchorType_ = OptionAnchorType::WeeklyDayOfTheWeek;
        strOptionWeekday_ = XMLUtils::getNodeValue(n);
        foundOptionExpiryRule = true;
        previouslyFoundOptionExpiryRule = "OptionExpiryWeeklyDayOfTheWeek";
    }
 
 
    if (!foundOptionExpiryRule && optionContractFrequency_ == Weekly) {
        optionAnchorType_ = OptionAnchorType::WeeklyDayOfTheWeek;
        strOptionWeekday_ = strWeekday_;
    } else if (!foundOptionExpiryRule) {
        optionAnchorType_ = OptionAnchorType::BusinessDaysBefore;
        strOptionExpiryOffset_ = "";
    }
 
 
 
    if (XMLNode* n = XMLUtils::getChildNode(node, "ProhibitedExpiries")) {
        auto datesNode = XMLUtils::getChildNode(n, "Dates");
        QL_REQUIRE(datesNode, "ProhibitedExpiries node must have a Dates node.");
        auto dateNodes = XMLUtils::getChildrenNodes(datesNode, "Date");
        for (const auto& dateNode : dateNodes) {
            ProhibitedExpiry pe;
            pe.fromXML(dateNode);
            if (validateBdc(pe)) {
                // First date is inserted, subsequent duplicates are ignored.
                prohibitedExpiries_.insert(pe);
            }
        }
    }
 
    if (contractFrequency_ == Monthly) {
        auto validContractMonthNode = XMLUtils::getChildNode(node, "ValidContractMonths");
        if (validContractMonthNode) {
            auto monthNodes = XMLUtils::getChildrenNodes(validContractMonthNode, "Month");
            for (const auto& month : monthNodes) {
                validContractMonths_.insert(parseMonth(XMLUtils::getNodeValue(month)));
            }
        }
    }
    
    strOptionBdc_ = XMLUtils::getChildValue(node, "OptionBusinessDayConvention", false);
 
    futureContinuationMappings_.clear();
    auto tmp = XMLUtils::getChildrenValues(node, "FutureContinuationMappings",
        "ContinuationMapping", "From", "To", false);
    for (const auto& kv : tmp) {
        futureContinuationMappings_[parseInteger(kv.first)] = parseInteger(kv.second);
    }
 
    optionContinuationMappings_.clear();
    tmp = XMLUtils::getChildrenValues(node, "OptionContinuationMappings",
        "ContinuationMapping", "From", "To", false);
    for (const auto& kv : tmp) {
        optionContinuationMappings_[parseInteger(kv.first)] = parseInteger(kv.second);
    }
 
    if (isAveraging_) {
        if (XMLNode* n = XMLUtils::getChildNode(node, "AveragingData")) {
            averagingData_.fromXML(n);
        }
    }
 
    hoursPerDay_ = Null<Natural>();
    if (XMLNode* n = XMLUtils::getChildNode(node, "HoursPerDay")) {
        hoursPerDay_ = parseInteger(XMLUtils::getNodeValue(n));
    }
 
    if (XMLNode* n = XMLUtils::getChildNode(node, "OffPeakPowerIndexData")) {
        offPeakPowerIndexData_ = OffPeakPowerIndexData();
        offPeakPowerIndexData_->fromXML(n);
    }
 
    indexName_ = XMLUtils::getChildValue(node, "IndexName", false);
 
    savingsTime_ = XMLUtils::getChildValue(node, "SavingsTime", false, "US");
 
    balanceOfTheMonth_ = XMLUtils::getChildValueAsBool(node, "BalanceOfTheMonth", false, false);
 
    balanceOfTheMonthPricingCalendarStr_ = XMLUtils::getChildValue(node, "BalanceOfTheMonthPricingCalendar", false, "");
 
    optionUnderlyingFutureConvention_ = XMLUtils::getChildValue(node, "OptionUnderlyingFutureConvention", false, "");
 
    build();
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 2069 of file conventions.cpp.

                                                                {
 
    XMLNode* node = doc.allocNode("CommodityFuture");
    XMLUtils::addChild(doc, node, "Id", id_);
 
    if (contractFrequency_ != Daily || optionContractFrequency_ != Daily) {
        XMLNode* anchorNode = doc.allocNode("AnchorDay");
        if (anchorType_ == AnchorType::DayOfMonth) {
            XMLUtils::addChild(doc, anchorNode, "DayOfMonth", strDayOfMonth_);
        } else if (anchorType_ == AnchorType::NthWeekday) {
            XMLNode* nthNode = doc.allocNode("NthWeekday");
            XMLUtils::addChild(doc, nthNode, "Nth", strNth_);
            XMLUtils::addChild(doc, nthNode, "Weekday", strWeekday_);
            XMLUtils::appendNode(anchorNode, nthNode);
        } else if (anchorType_ == AnchorType::LastWeekday) {
            XMLUtils::addChild(doc, anchorNode, "LastWeekday", strWeekday_);
        } else if (anchorType_ == AnchorType::BusinessDaysAfter) {
            XMLUtils::addChild(doc, anchorNode, "BusinessDaysAfter", strBusinessDaysAfter_);
        } else if (anchorType_ == AnchorType::WeeklyDayOfTheWeek) {
            XMLUtils::addChild(doc, anchorNode, "WeeklyDayOfTheWeek", strWeekday_);
        } else {
            XMLUtils::addChild(doc, anchorNode, "CalendarDaysBefore", strCalendarDaysBefore_);
        } 
        XMLUtils::appendNode(node, anchorNode);
    }
 
    XMLUtils::addChild(doc, node, "ContractFrequency", strContractFrequency_);
    XMLUtils::addChild(doc, node, "Calendar", strCalendar_);
    if (!strExpiryCalendar_.empty())
        XMLUtils::addChild(doc, node, "ExpiryCalendar", strExpiryCalendar_);
    XMLUtils::addChild(doc, node, "ExpiryMonthLag", static_cast<int>(expiryMonthLag_));
 
    if (!strOneContractMonth_.empty())
        XMLUtils::addChild(doc, node, "OneContractMonth", strOneContractMonth_);
 
    if (!strOffsetDays_.empty())
        XMLUtils::addChild(doc, node, "OffsetDays", strOffsetDays_);
 
    if (!strBdc_.empty())
        XMLUtils::addChild(doc, node, "BusinessDayConvention", strBdc_);
 
    XMLUtils::addChild(doc, node, "AdjustBeforeOffset", adjustBeforeOffset_);
    XMLUtils::addChild(doc, node, "IsAveraging", isAveraging_);
 
    if (optionAnchorType_ == OptionAnchorType::BusinessDaysBefore) {
        if (optionExpiryOffset_>0)
            XMLUtils::addChild(doc, node, "OptionExpiryOffset", strOptionExpiryOffset_);
    } else if (optionAnchorType_ == OptionAnchorType::DayOfMonth) {
        XMLUtils::addChild(doc, node, "OptionExpiryDay", static_cast<int>(optionExpiryDay_));
    } else if (optionAnchorType_ == OptionAnchorType::NthWeekday) {
        XMLNode* nthNode = doc.allocNode("OptionNthWeekday");
        XMLUtils::addChild(doc, nthNode, "Nth", strOptionNth_);
        XMLUtils::addChild(doc, nthNode, "Weekday", strOptionWeekday_);
        XMLUtils::appendNode(node, nthNode);
    } else if (optionAnchorType_ == OptionAnchorType::LastWeekday) {
        XMLUtils::addChild(doc, node, "OptionExpiryLastWeekdayOfMonth", strOptionWeekday_);
    } else if (optionAnchorType_ == OptionAnchorType::WeeklyDayOfTheWeek) {
        XMLUtils::addChild(doc, node, "OptionExpiryWeeklyDayOfTheWeek", strOptionWeekday_);
    }
 
    if (!prohibitedExpiries_.empty()) {
        XMLNode* prohibitedExpiriesNode = doc.allocNode("ProhibitedExpiries");
        XMLNode* datesNode = XMLUtils::addChild(doc, prohibitedExpiriesNode, "Dates");
        for (ProhibitedExpiry pe : prohibitedExpiries_) {
            XMLUtils::appendNode(datesNode, pe.toXML(doc));
        }
        XMLUtils::appendNode(node, prohibitedExpiriesNode);
    }
 
    XMLUtils::addChild(doc, node, "OptionExpiryMonthLag", static_cast<int>(optionExpiryMonthLag_));
    
 
    if (!strOptionBdc_.empty())
        XMLUtils::addChild(doc, node, "OptionBusinessDayConvention", strOptionBdc_);
 
    if (!futureContinuationMappings_.empty()) {
        map<string, string> tmp;
        for (const auto& kv : futureContinuationMappings_) {
            tmp[to_string(kv.first)] = to_string(kv.second);
        }
        XMLUtils::addChildren(doc, node, "FutureContinuationMappings",
            "ContinuationMapping", "From", "To", tmp);
    }
 
    if (!optionContinuationMappings_.empty()) {
        map<string, string> tmp;
        for (const auto& kv : optionContinuationMappings_) {
            tmp[to_string(kv.first)] = to_string(kv.second);
        }
        XMLUtils::addChildren(doc, node, "OptionContinuationMappings",
            "ContinuationMapping", "From", "To", tmp);
    }
 
    if (!averagingData_.empty()) {
        XMLUtils::appendNode(node, averagingData_.toXML(doc));
    }
 
    if (hoursPerDay_ != Null<Natural>())
        XMLUtils::addChild(doc, node, "HoursPerDay", static_cast<int>(hoursPerDay_));
 
    if (offPeakPowerIndexData_) {
        XMLUtils::appendNode(node, offPeakPowerIndexData_->toXML(doc));
    }
 
    if (!indexName_.empty())
        XMLUtils::addChild(doc, node, "IndexName", indexName_);
 
    if (!savingsTime_.empty())
        XMLUtils::addChild(doc, node, "SavingsTime", savingsTime_);
 
    if (contractFrequency_ == Monthly && !validContractMonths_.empty() && validContractMonths_.size() < 12) {
        XMLNode* validContractMonthNode = doc.allocNode("ValidContractMonths");
        for (auto  month : validContractMonths_) {
            XMLUtils::addChild(doc, validContractMonthNode, "Month", to_string(month));
        }
        XMLUtils::appendNode(node, validContractMonthNode);
    }
 
    if (balanceOfTheMonth_) {
        XMLUtils::addChild(doc, node, "BalanceOfTheMonth", balanceOfTheMonth_);
    }
 
    if (balanceOfTheMonthPricingCalendar_ != Calendar()) {
        XMLUtils::addChild(doc, node, "BalanceOfTheMonthPricingCalendar", to_string(balanceOfTheMonthPricingCalendar_));
    }
 
    if (!optionUnderlyingFutureConvention_.empty()) {
        XMLUtils::addChild(doc, node, "OptionUnderlyingFutureConvention", optionUnderlyingFutureConvention_);
        XMLUtils::addChild(doc, node, "OptionContractFrequency", strOptionContractFrequency_);
    }
 
    return node;
}

Here is the call graph for this function:

◆ build()

void build ( )

overridevirtual

Implementation.

Implements Convention.

Definition at line 2203 of file conventions.cpp.

                                      {
 
    contractFrequency_ = parseAndValidateFrequency(strContractFrequency_);
    if (strOptionContractFrequency_.empty()) {
        optionContractFrequency_ = contractFrequency_;
    } else {
        optionContractFrequency_ = parseAndValidateFrequency(strOptionContractFrequency_);
    }
 
    if (contractFrequency_ != Daily || optionContractFrequency_ != Daily) {
        if (anchorType_ == AnchorType::DayOfMonth) {
            dayOfMonth_ = lexical_cast<Natural>(strDayOfMonth_);
        } else if (anchorType_ == AnchorType::CalendarDaysBefore) {
            calendarDaysBefore_ = lexical_cast<Natural>(strCalendarDaysBefore_);
        } else if (anchorType_ == AnchorType::LastWeekday) {
            weekday_ = parseWeekday(strWeekday_);
        } else if (anchorType_ == AnchorType::BusinessDaysAfter) {
            businessDaysAfter_ =  lexical_cast<Integer>(strBusinessDaysAfter_);
        } else if (anchorType_ == AnchorType::WeeklyDayOfTheWeek) {
            weekday_ = parseWeekday(strWeekday_);
        } else {
            nth_ = lexical_cast<Natural>(strNth_);
            weekday_ = parseWeekday(strWeekday_);
        }
    }
 
    calendar_ = parseCalendar(strCalendar_);
    expiryCalendar_ = strExpiryCalendar_.empty() ? calendar_ : parseCalendar(strExpiryCalendar_);
 
    // Optional entries
    oneContractMonth_ = strOneContractMonth_.empty() ? Month::Jan : parseMonth(strOneContractMonth_);
    offsetDays_ = strOffsetDays_.empty() ? 0 : lexical_cast<Integer>(strOffsetDays_);
    bdc_ = strBdc_.empty() ? Preceding : parseBusinessDayConvention(strBdc_);
 
    if (optionAnchorType_ == OptionAnchorType::BusinessDaysBefore) {
        if (strOptionExpiryOffset_.empty())
            optionExpiryOffset_ = 0;
        else
            optionExpiryOffset_ = lexical_cast<Natural>(strOptionExpiryOffset_);
    } else if (optionAnchorType_ == OptionAnchorType::NthWeekday) {
        optionNth_ = lexical_cast<Natural>(strOptionNth_);
        optionWeekday_ = parseWeekday(strOptionWeekday_);
    } else if (optionAnchorType_ == OptionAnchorType::DayOfMonth) {
        optionAnchorType_ = OptionAnchorType::DayOfMonth;
        optionExpiryDay_ = lexical_cast<Natural>(strOptionExpiryDay_);
    } else if (optionAnchorType_ == OptionAnchorType::LastWeekday) {
        optionWeekday_ = parseWeekday(strOptionWeekday_);
    } else if (optionAnchorType_ == OptionAnchorType::WeeklyDayOfTheWeek) {
        optionWeekday_ = parseWeekday(strOptionWeekday_);
    } else {
        optionAnchorType_ = OptionAnchorType::BusinessDaysBefore;
        optionExpiryOffset_ = 0;
    }
 
    optionBdc_ = strOptionBdc_.empty() ? Preceding : parseBusinessDayConvention(strOptionBdc_);
 
    // Check the continuation mappings
    checkContinuationMappings(futureContinuationMappings_, "future");
    checkContinuationMappings(optionContinuationMappings_, "option");
 
    // Check that neither of the indexes in OffPeakPowerIndexData self reference
    if (offPeakPowerIndexData_) {
        const string& opIdx = offPeakPowerIndexData_->offPeakIndex();
        QL_REQUIRE(id_ != opIdx, "The off-peak index (" << opIdx << ") cannot equal the index for which" <<
            " we are providing conventions (" << id_ << ").");
        const string& pIdx = offPeakPowerIndexData_->peakIndex();
        QL_REQUIRE(id_ != pIdx, "The peak index (" << pIdx << ") cannot equal the index for which" <<
            " we are providing conventions (" << id_ << ").");
    }
 
    if (balanceOfTheMonthPricingCalendarStr_.empty()) {
        balanceOfTheMonthPricingCalendar_ = Calendar();
    } else {
        balanceOfTheMonthPricingCalendar_ = parseCalendar(balanceOfTheMonthPricingCalendarStr_);
    }
 
    QL_REQUIRE(!balanceOfTheMonth_ || isAveraging(), "Balance of the month make only sense for averaging futures");
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseAndValidateFrequency()

Frequency parseAndValidateFrequency ( const std::string & strFrequency )

private

Populate and check frequency.

Definition at line 2283 of file conventions.cpp.

                                                                                             {
    auto freq = parseFrequency(strFrequency);
    QL_REQUIRE(freq == Annual || freq == Quarterly || freq == Monthly || freq == Weekly || freq == Daily,
               "Contract frequency should be annual, quarterly, monthly, weekly or daily but got " << freq);
    return freq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateBdc()

bool validateBdc ( const ProhibitedExpiry & pe ) const

private

Validate the business day conventions in the ProhibitedExpiry.

Definition at line 2290 of file conventions.cpp.

                                                                            {
    vector<BusinessDayConvention> bdcs{ pe.futureBdc(), pe.optionBdc() };
    for (auto bdc : bdcs) {
        if (!(bdc == Preceding || bdc == Following || bdc == ModifiedPreceding || bdc == ModifiedFollowing)) {
            WLOG("Prohibited expiry bdc must be one of {Preceding, Following, ModifiedPreceding," <<
                " ModifiedFollowing} but got " << bdc << " for date " << io::iso_date(pe.expiry()) << ".");
            return false;
        }
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ anchorType_

AnchorType anchorType_

private

Definition at line 1618 of file conventions.hpp.

◆ dayOfMonth_

QuantLib::Natural dayOfMonth_

private

Definition at line 1619 of file conventions.hpp.

◆ nth_

QuantLib::Natural nth_

private

Definition at line 1620 of file conventions.hpp.

◆ weekday_

QuantLib::Weekday weekday_

private

Definition at line 1621 of file conventions.hpp.

◆ calendarDaysBefore_

QuantLib::Natural calendarDaysBefore_

private

Definition at line 1622 of file conventions.hpp.

◆ businessDaysAfter_

QuantLib::Integer businessDaysAfter_

private

Definition at line 1623 of file conventions.hpp.

◆ contractFrequency_

QuantLib::Frequency contractFrequency_

private

Definition at line 1624 of file conventions.hpp.

◆ calendar_

QuantLib::Calendar calendar_

private

Definition at line 1625 of file conventions.hpp.

◆ expiryCalendar_

QuantLib::Calendar expiryCalendar_

private

Definition at line 1626 of file conventions.hpp.

◆ oneContractMonth_

QuantLib::Month oneContractMonth_

private

Definition at line 1627 of file conventions.hpp.

◆ offsetDays_

QuantLib::Integer offsetDays_

private

Definition at line 1628 of file conventions.hpp.

◆ bdc_

QuantLib::BusinessDayConvention bdc_

private

Definition at line 1629 of file conventions.hpp.

◆ strDayOfMonth_

std::string strDayOfMonth_

private

Definition at line 1632 of file conventions.hpp.

◆ strNth_

std::string strNth_

private

Definition at line 1633 of file conventions.hpp.

◆ strWeekday_

std::string strWeekday_

private

Definition at line 1634 of file conventions.hpp.

◆ strCalendarDaysBefore_

std::string strCalendarDaysBefore_

private

Definition at line 1635 of file conventions.hpp.

◆ strBusinessDaysAfter_

std::string strBusinessDaysAfter_

private

Definition at line 1636 of file conventions.hpp.

◆ strContractFrequency_

std::string strContractFrequency_

private

Definition at line 1637 of file conventions.hpp.

◆ strCalendar_

std::string strCalendar_

private

Definition at line 1638 of file conventions.hpp.

◆ strExpiryCalendar_

std::string strExpiryCalendar_

private

Definition at line 1639 of file conventions.hpp.

◆ expiryMonthLag_

QuantLib::Size expiryMonthLag_

private

Definition at line 1640 of file conventions.hpp.

◆ strOneContractMonth_

std::string strOneContractMonth_

private

Definition at line 1641 of file conventions.hpp.

◆ strOffsetDays_

std::string strOffsetDays_

private

Definition at line 1642 of file conventions.hpp.

◆ strBdc_

std::string strBdc_

private

Definition at line 1643 of file conventions.hpp.

◆ adjustBeforeOffset_

bool adjustBeforeOffset_

private

Definition at line 1644 of file conventions.hpp.

◆ isAveraging_

bool isAveraging_

private

Definition at line 1645 of file conventions.hpp.

◆ prohibitedExpiries_

std::set<ProhibitedExpiry> prohibitedExpiries_

private

Definition at line 1646 of file conventions.hpp.

◆ optionExpiryMonthLag_

QuantLib::Size optionExpiryMonthLag_

private

Definition at line 1647 of file conventions.hpp.

◆ optionBdc_

QuantLib::BusinessDayConvention optionBdc_

private

Definition at line 1648 of file conventions.hpp.

◆ strOptionBdc_

std::string strOptionBdc_

private

Definition at line 1649 of file conventions.hpp.

◆ futureContinuationMappings_

std::map<QuantLib::Natural, QuantLib::Natural> futureContinuationMappings_

private

Definition at line 1650 of file conventions.hpp.

◆ optionContinuationMappings_

std::map<QuantLib::Natural, QuantLib::Natural> optionContinuationMappings_

private

Definition at line 1651 of file conventions.hpp.

◆ averagingData_

AveragingData averagingData_

private

Definition at line 1652 of file conventions.hpp.

◆ hoursPerDay_

QuantLib::Natural hoursPerDay_

private

Definition at line 1653 of file conventions.hpp.

◆ offPeakPowerIndexData_

boost::optional<OffPeakPowerIndexData> offPeakPowerIndexData_

private

Definition at line 1654 of file conventions.hpp.

◆ indexName_

std::string indexName_

private

Definition at line 1655 of file conventions.hpp.

◆ strOptionContractFrequency_

std::string strOptionContractFrequency_

private

Definition at line 1657 of file conventions.hpp.

◆ optionAnchorType_

OptionAnchorType optionAnchorType_

private

Definition at line 1659 of file conventions.hpp.

◆ strOptionExpiryOffset_

std::string strOptionExpiryOffset_

private

Definition at line 1660 of file conventions.hpp.

◆ strOptionExpiryDay_

std::string strOptionExpiryDay_

private

Definition at line 1661 of file conventions.hpp.

◆ strOptionNth_

std::string strOptionNth_

private

Definition at line 1662 of file conventions.hpp.

◆ strOptionWeekday_

std::string strOptionWeekday_

private

Definition at line 1663 of file conventions.hpp.

◆ optionContractFrequency_

QuantLib::Frequency optionContractFrequency_

private

Definition at line 1666 of file conventions.hpp.

◆ optionExpiryOffset_

QuantLib::Natural optionExpiryOffset_

private

Definition at line 1667 of file conventions.hpp.

◆ optionNth_

QuantLib::Natural optionNth_

private

Definition at line 1668 of file conventions.hpp.

◆ optionWeekday_

QuantLib::Weekday optionWeekday_

private

Definition at line 1669 of file conventions.hpp.

◆ optionExpiryDay_

QuantLib::Natural optionExpiryDay_

private

Definition at line 1670 of file conventions.hpp.

◆ validContractMonths_

std::set<QuantLib::Month> validContractMonths_

private

Definition at line 1672 of file conventions.hpp.

◆ savingsTime_

std::string savingsTime_

private

Definition at line 1673 of file conventions.hpp.

◆ balanceOfTheMonth_

bool balanceOfTheMonth_

private

Definition at line 1677 of file conventions.hpp.

◆ balanceOfTheMonthPricingCalendarStr_

std::string balanceOfTheMonthPricingCalendarStr_

private

Definition at line 1678 of file conventions.hpp.

◆ balanceOfTheMonthPricingCalendar_

Calendar balanceOfTheMonthPricingCalendar_

private

Definition at line 1679 of file conventions.hpp.

◆ optionUnderlyingFutureConvention_

std::string optionUnderlyingFutureConvention_

private

Option Underlying Future convention.

Definition at line 1681 of file conventions.hpp.

Classes

Public Types

Public Member Functions

Inspectors

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ AnchorType

◆ OptionAnchorType

Constructor & Destructor Documentation

◆ CommodityFutureConvention() [1/5]

◆ CommodityFutureConvention() [2/5]

◆ CommodityFutureConvention() [3/5]

◆ CommodityFutureConvention() [4/5]

◆ CommodityFutureConvention() [5/5]

Member Function Documentation

◆ anchorType()

◆ dayOfMonth()

◆ nth()

◆ weekday()

◆ calendarDaysBefore()

◆ businessDaysAfter()

◆ contractFrequency()

◆ calendar()

◆ expiryCalendar()

◆ expiryMonthLag()

◆ oneContractMonth()

◆ offsetDays()

◆ businessDayConvention()

◆ adjustBeforeOffset()

◆ isAveraging()

◆ optionExpiryOffset()

◆ prohibitedExpiries()

◆ optionExpiryMonthLag()

◆ optionExpiryDay()

◆ optionBusinessDayConvention()

◆ futureContinuationMappings()

◆ optionContinuationMappings()

◆ averagingData()

◆ hoursPerDay()

◆ offPeakPowerIndexData()

◆ indexName()

◆ optionContractFrequency()

◆ optionAnchorType()

◆ optionNth()

◆ optionWeekday()

◆ savingsTime()

◆ validContractMonths()

◆ balanceOfTheMonth()

◆ balanceOfTheMonthPricingCalendar()

◆ optionUnderlyingFutureConvention()

◆ fromXML()

◆ toXML()

◆ build()

◆ parseAndValidateFrequency()

◆ validateBdc()

Member Data Documentation

◆ anchorType_

◆ dayOfMonth_

◆ nth_

◆ weekday_

◆ calendarDaysBefore_

◆ businessDaysAfter_

◆ contractFrequency_

◆ calendar_

◆ expiryCalendar_

◆ oneContractMonth_

◆ offsetDays_

◆ bdc_

◆ strDayOfMonth_

◆ strNth_

◆ strWeekday_

◆ strCalendarDaysBefore_

◆ strBusinessDaysAfter_

◆ strContractFrequency_

◆ strCalendar_

◆ strExpiryCalendar_

◆ expiryMonthLag_

◆ strOneContractMonth_

◆ strOffsetDays_