ProductSnapshot.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/

#pragma once

#include <OnixS/Eurex/MarketData/ABI.h>
#include <OnixS/Eurex/MarketData/Exception.h>
#include <OnixS/Eurex/MarketData/Defines.h>
#include <OnixS/Eurex/MarketData/InstrumentSnapshot.h>
#include <OnixS/Eurex/MarketData/Tags.h>
#include <OnixS/Eurex/MarketData/Group.h>


namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Exposes list of available Quote side indicators.
            struct ONIXS_EUREX_EMDI_API QuoteSideIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Not allowed
                    OneSidedQuoteNotAllowed = 0,

                    /// Allowed
                    OneSidedQuoteAllowed = 1,
                };
            };

            /// Exposes list of available quote side model types.
            struct ONIXS_EUREX_EMDI_API QuoteSideModelType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Single-sided quotes not supported
                    SSQNotSupported = 0,

                    /// Single-sided quotes supported
                    SSQSupported = 1,
                };
            };

            /// Exposes list of available feed types.
            struct ONIXS_EUREX_EMDI_API FeedType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Defines if product is traded on on NTA.
                    HighIncremental = 0,

                    /// Defines if product is still traded on "Eurex classic"
                    HighSnapshot = 1,

                    /// Defines if product is still traded on "Eurex classic"
                    Low = 2,
                };
            };

            class ONIXS_EUREX_EMDI_API TickRuleScope : GroupInstance
            {
            public:
                /// Defines the instrument type for the tick rule.
                InstrumentType::Enum tickRuleProductComplex() const
                {
                    return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::TickRuleProductComplex);
                }

                /// Trade Type
                TrdType::Enum trdType() const
                {
                    return getIntEnumFieldValue<TrdType>(*this, Tags::TrdType);
                }

            private:
                friend class TypedGroup<TickRuleScope>;

                TickRuleScope (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                {
                }
            };

            /// Tick rule scope definitions.
            class TickRuleScopes : public TypedGroup<TickRuleScope>
            {
            private:
                explicit
                TickRuleScopes (const Group& group)
                        : TypedGroup<TickRuleScope> (group)
                {
                }

                friend class TickRule;
            };


            /// Tick rule.
            class ONIXS_EUREX_EMDI_API TickRule : GroupInstance
            {
                public:
                    /// Table identifier, only for cash.
                    UInt32 tickRuleId () const
                    {
                        return getUInt32 (Tags::TickRuleID);
                    }

                    /// Starting price range for specified tick increment (inclusive).
                    Decimal startTickPriceRange() const
                    {
                        return getDecimal (Tags::StartTickPriceRange);
                    }

                    /// Ending price range for the specified tick increment (noninclusive).
                    Decimal endTickPriceRange() const
                    {
                        return getDecimal (Tags::EndTickPriceRange);
                    }

                    /// Tick increment for stated price range. Specifies the valid price
                    /// increments at which instrument of the product can be quoted and
                    /// traded.
                    Decimal tickIncrement() const
                    {
                        return getDecimal (Tags::TickIncrement);
                    }

                    /// Tick rule scope definitions.
                    TickRuleScopes tickRuleScopes() const
                    {
                        return TickRuleScopes ( getOptionalGroup (Tags::NoTickRuleScopes));
                    }

                private:
                    friend class TypedGroup<TickRule>;

                    TickRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class TickRules : public TypedGroup<TickRule>
            {
            private:
                explicit
                TickRules (const Group& group)
                        : TypedGroup<TickRule> (group)
                {
                }

                friend class ProductSnapshot;
            };

            /// Exposes list of available match algorithms.
            struct ONIXS_EUREX_EMDI_API MatchAlgorithm
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    PriceTime = 0,

                    ///
                    ProRata = 1,

                    ///
                    TimeProRata = 2,
                };
            };


            /// Exposes list of available match types.
            struct ONIXS_EUREX_EMDI_API MatchType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    AutoMatch = 0,

                    ///
                    CallAuction = 2,
                };
            };


            /// Exposes list of available market segment types.
            struct ONIXS_EUREX_EMDI_API USApproval
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    NoApproval = 0,

                    ///
                    CFTCApproved = 0,

                    ///
                    SECApproved = 0,
                };
            };

            /// Exposes list of available market segment types.
            struct ONIXS_EUREX_EMDI_API MarketSegmentType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Pool = 0,
                };
            };


            /// Exposes list of available market segment subtypes.
            struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    InterProductSpread = 0,

                    ///
                    BTRFBucket = 1,

                    ///
                    EBBBucket = 2,

                    ///
                    CommodityGroup = 3,
                };
            };

            /// Exposes list of available Decay splits.
            struct ONIXS_EUREX_EMDI_API DecaySplit
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Quarter = 1,

                    ///
                    Season = 2,

                    ///
                    Year = 3,
                };
            };

            /// Exposes list of available auction types.
            struct ONIXS_EUREX_EMDI_API AuctionType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    AnyAuction = 0,
                };
            };

            /// Exposes list of available closed book indicators.
            struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    No = 0,

                    ///
                    Yes = 1,
                };
            };

            /// Exposes list of available market imbalance indicators.
            struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    No = 0,

                    ///
                    Yes = 1,
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API DisableOnBookTrading
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    No = 0,

                    ///
                    Yes = 1,
                };
            };

            /// Exposes list of available market segment relationship types.
            struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    CashLegForVolatilityStrategies = 0,

                    ///
                    TargetProductForDecayingProduct = 1,

                    ///
                    BTRFBucket = 2,

                    ///
                    EBBBucket = 3,

                    ///
                    CommodityGroup = 4,
                };
            };

            struct ONIXS_EUREX_EMDI_API AllowOneProductStrip
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    OneProductStripNotAllowed = 0,

                    ///
                    OneProductStripNot = 1,
                };
            };

            /// Match rule.
            class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
            {
                public:
                    /// Defines the instrument type for the match rule.
                    InstrumentType::Enum matchRuleProductComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
                    }

                    /// Defines the matching algorithm.
                    MatchAlgorithm::Enum matchAlgorithm() const
                    {
                        return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
                    }

                    /// Defines the matching type.
                    /// @note Absence means no distinction between continuous and auctions
                    MatchType::Enum matchType() const
                    {
                        return getIntEnumFieldValue<MatchType> (*this, Tags::MatchType);
                    }

                private:
                    friend class TypedGroup<MatchRule>;

                    MatchRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class MatchRules : public TypedGroup<MatchRule>
            {
                private:
                    explicit
                    MatchRules (const Group& group)
                        : TypedGroup<MatchRule> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };

            /// Quote size rule.
            class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
            {
                public:

                    /// Minimum bid quantity (identical to minimum offer quantity).
                    bool minBidSize (Decimal& size) const
                    {
                        return get (Tags::MinBidSize).toNumber (size);
                    }

                    /// Minimum offer quantity (identical to minimum bid quantity).
                    bool minOfferSize (Decimal& size) const
                    {
                        return get (Tags::MinOfferSize).toNumber (size);
                    }

                    /// Indicates if product is in the state Fast Market.
                    bool fastMarketIndicator() const
                    {
                        UInt32 value;
                        return get (Tags::FastMarketIndicator).toNumber (value) ? (value == 1) : false;
                    }

                private:
                    friend class TypedGroup<QuoteSizeRule>;

                    QuoteSizeRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class QuoteSizeRules : public TypedGroup<QuoteSizeRule>
            {
                private:
                    explicit
                    QuoteSizeRules (const Group& group)
                        : TypedGroup<QuoteSizeRule> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };

            /// Flex rule.
            class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
            {
                public:

                    /// Defines the strategy types available for user defined strategies.
                    InstrumentType::Enum flexProductEligibilityComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
                    }

                    /// Defines if user defined strategies are allowed.
                    bool flexProductEligibilityIndicator() const
                    {
                        return (getUInt32 (Tags::FlexProductEligibilityIndicator) == 1);
                    }

                private:
                    friend class TypedGroup<FlexRule>;

                    FlexRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class FlexRules : public TypedGroup<FlexRule>
            {
                private:
                    explicit
                    FlexRules (const Group& group)
                        : TypedGroup<FlexRule> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };


            /// Auction type rule.
            class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
            {
                public:
                    /// Defines the type of auction.
                    AuctionType::Enum auctionType() const
                    {
                        return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
                    }

                    /// Indicates whether the order book is closed during auction trading. "N" reserved for future releases.
                    ClosedBookIndicator::Enum closedBookIndicator() const
                    {
                        return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
                    }

                    /// Controls if during auction call/volatility interruption/extended volatility interruption/market
                    /// order interruption phase a surplus (side and volume) at the indicative price
                    /// (if crossed order book) or the best bid/best ask limit and quantity (if uncrossed order book)
                    /// is displayed to the market.
                    MarketImbalanceIndicator::Enum marketImbalanceIndicator() const
                    {
                        return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
                    }

                    /// Defines, if On Book trading is disabled
                    DisableOnBookTrading::Enum disableOnBookTrading() const
                    {
                        return getIntEnumFieldValue<DisableOnBookTrading>(*this, Tags::DisableOnBookTrading);
                    }

                private:
                    friend class TypedGroup<AuctionTypeRule>;

                    AuctionTypeRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class AuctionTypeRules : public TypedGroup<AuctionTypeRule>
            {
                private:
                    explicit
                    AuctionTypeRules (const Group& group)
                        : TypedGroup<AuctionTypeRule> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };

            /// Feed
            class ONIXS_EUREX_EMDI_API Feed : GroupInstance
            {
                public:

                    /// Feed type.
                    FeedType::Enum mdFeedType() const
                    {
                        return getIntEnumFieldValue<FeedType> (*this, Tags::MDFeedType);
                    }

                    /// Book type.
                    BookType::Enum mdBookType() const
                    {
                        return getIntEnumFieldValue<BookType> (*this, Tags::MDBookType);
                    }

                    /// Maximum number of price levels for the product.
                    bool marketDepth (UInt32& depth) const
                    {
                        return get (Tags::MarketDepth).toNumber (depth);
                    }

                    /// Netting interval for low bandwidth feeds (0=no netting).
                    bool marketDepthTimeInterval (UInt32& interval) const
                    {
                        return get (Tags::MarketDepthTimeInterval).toNumber (interval);
                    }

                    /// Recovery interval (duration of one cycle).
                    bool mdRecoveryTimeInterval (UInt32& interval) const
                    {
                        return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
                    }

                    /// IP Address for Service A.
                    StringRef mdPrimaryFeedLineID() const
                    {
                        StringRef val;
                        return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
                    }

                    /// Port number for IP address Service A.
                    UInt32 mdPrimaryFeedLineSubID() const
                    {
                        return getUInt32 (Tags::PrimaryServiceLocationSubID);
                    }

                    /// IP Address for Service B.
                    bool mdSecondaryFeedLineID (StringRef& id) const
                    {
                        return get (Tags::SecondaryServiceLocationID).toStringRef (id);
                    }

                    /// Port number for IP address Service B.
                    bool mdSecondaryFeedLineSubID (UInt32& subId) const
                    {
                        return get (Tags::SecondaryServiceLocationSubID).toNumber (subId);
                    }

                private:
                    friend class TypedGroup<Feed>;

                    Feed (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class Feeds : public TypedGroup<Feed>
            {
                private:
                    explicit
                    Feeds (const Group& group)
                        : TypedGroup<Feed> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };

            /// Price range rule.
            class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
            {
                public:

                    /// Table identifier, not unique within repeating group.
                    UInt32 priceRangeRuleID() const
                    {
                        return getUInt32 (Tags::PriceRangeRuleID);
                    }

                    ///
                    InstrumentType::Enum priceRangeProductComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::PriceRangeProductComplex);
                    }

                    /// Start of price range (inclusive).
                    Decimal startPriceRange() const
                    {
                        return getDecimal (Tags::StartPriceRange);
                    }

                    /// End of price range (non-inclusive).
                    Decimal endPriceRange() const
                    {
                        return getDecimal (Tags::EndPriceRange);
                    }

                    /// Maximum allowable quote spread (absolute value). Conditionally required if PriceRangePercentage is absent.
                    bool priceRangeValue (Decimal& value) const
                    {
                        return get (Tags::PriceRangeValue).toNumber (value);
                    }

                    /// Maximum allowable quote spread (percentage value). Conditionally required if PriceRangeValue is absent.
                    bool priceRangePercentage (Decimal& percentage) const
                    {
                        return get (Tags::PriceRangePercentage).toNumber (percentage);
                    }

                private:
                    friend class TypedGroup<PriceRangeRule>;

                    PriceRangeRule (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class PriceRangeRules : public TypedGroup<PriceRangeRule>
            {
                private:
                    explicit
                    PriceRangeRules (const Group& group)
                        : TypedGroup<PriceRangeRule> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };

            /// Herfindahl-Hirschman Index (HHI) interval.
            class ONIXS_EUREX_EMDI_API HHIInterval : GroupInstance
            {
            public:

                /// The HHIInterval value.
                UInt32 hHIIndicator() const
                {
                    return getUInt32(Tags::HHIIndicator);
                }

                /// The HHIInterval upper boundary.
                Decimal hHIIntervalEnd() const
                {
                    return getDecimal(Tags::HHIIntervalEnd);
                }


            private:
                friend class TypedGroup<HHIInterval>;

                HHIInterval(const GroupInstance& groupInstance)
                    : GroupInstance(groupInstance)
                {
                }
            };

            /// Herfindahl-Hirschman Index (HHI) intervals.
            class HHIIntervals : public TypedGroup<HHIInterval>
            {
            private:
                explicit
                    HHIIntervals(const Group& group)
                    : TypedGroup<HHIInterval>(group)
                {
                }

                friend class ProductSnapshot;
            };

            /// Instrument Scope.
            class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
            {
                public:

                    /// Instrument scope operator.
                    InstrumentScopeOperator::Enum instrumentScopeOperator() const
                    {
                        return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
                    }

                    /// Type of security.
                    SecurityType::Enum securityType() const
                    {
                        return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
                    }

                    /// Standard strategy type for complex instruments.
                    bool instrumentScopeSecuritySubType (UInt32& value) const
                    {
                        return get (Tags::InstrumentScopeSecuritySubType).toNumber (value);
                    }

                private:
                    friend class TypedGroup<InstrumentScope>;

                    InstrumentScope (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class InstrumentScopes : public TypedGroup<InstrumentScope>
            {
                private:
                    explicit
                    InstrumentScopes (const Group& group)
                        : TypedGroup<InstrumentScope> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };


            /// Related Market Segments.
            class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
            {
                public:

                    /// Market segment identifier.
                    UInt32 relatedMarketSegmentID() const
                    {
                        return getUInt32 (Tags::RelatedMarketSegmentID);
                    }

                    /// Defines the type of the relationship..
                    MarketSegmentRelationship::Enum marketSegmentRelationship() const
                    {
                        return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
                    }

                    /// Defines the type of the relationship..
                    AllowOneProductStrip::Enum allowOneProductStrip() const
                    {
                        return getIntEnumFieldValue<AllowOneProductStrip>(*this, Tags::AllowOneProductStrip);
                    }

                private:
                    friend class TypedGroup<RelatedMarketSegment>;

                    RelatedMarketSegment (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                    {
                    }
            };

            class RelatedMarketSegments : public TypedGroup<RelatedMarketSegment>
            {
                private:
                    explicit
                    RelatedMarketSegments (const Group& group)
                        : TypedGroup<RelatedMarketSegment> (group)
                    {
                    }

                    friend class ProductSnapshot;
            };


            /// Quantity Scaling Factors
            class ONIXS_EUREX_EMDI_API QuantityScalingFactor : GroupInstance
            {
            public:
                ///
                UInt32 quantityScalingFactor() const
                {
                    return getUInt32 (Tags::QuantityScalingFactor);
                }

            private:
                friend class TypedGroup<QuantityScalingFactor>;

                QuantityScalingFactor (const GroupInstance& groupInstance)
                    : GroupInstance (groupInstance)
                {
                }
            };

            class QuantityScalingFactors : public TypedGroup<QuantityScalingFactor>
            {
            private:
                explicit
                QuantityScalingFactors (const Group& group)
                    : TypedGroup<QuantityScalingFactor> (group)
                {
                }

                friend class ProductSnapshot;
            };


            /// Product snapshot.
            class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
            {
                public:

                    /// Market Identifier Code as specified in ISO 10383.
                    StringRef marketId() const
                    {
                        return getStringRef (Tags::MarketID);
                    }

                    /// Product identifier.
                    MarketSegmentId marketSegmentId() const
                    {
                        return getUInt32 (Tags::MarketSegmentID);
                    }

                    /// Current business date
                    UInt32 effectiveBusinessDate() const
                    {
                        return getUInt32 (Tags::EffectiveBusinessDate);
                    }

                    /// Next business date
                    UInt32 nextEffectiveBusinessDate() const
                    {
                        return getUInt32 (Tags::NextEffectiveBusinessDate);
                    }

                    /// Product name.
                    StringRef marketSegment() const
                    {
                        return getStringRef (Tags::MarketSegment);
                    }

                    /// Currency as published in ISO 4217.
                    bool currency (StringRef& value) const
                    {
                        return get (Tags::Currency).toStringRef (value);
                    }

                    /// Defines the TES security status.
                    MarketSegmentStatus::Enum marketSegmentStatus() const
                    {
                        return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
                    }

                    /// Partition of the product.
                    PartitionId partitionId() const
                    {
                        return getUInt32 (Tags::PartitionID);
                    }

                    ///
                    UInt32 capacityGroupId() const
                    {
                        return getUInt32 (Tags::CapacityGroupId);
                    }

                    /// Contains the default and maximum duration of negotiation event in seconds.
                    bool negotiationDuration(UInt32& value) const
                    {
                        return get(Tags::NegotiationDuration).toNumber(value);
                    }

                    /// Product Description.
                    bool marketSegmentDesc (StringRef& desc) const
                    {
                        return get (Tags::MarketSegmentDesc).toStringRef (desc);
                    }

                    /// Product ISIN.
                    bool marketSegmentSymbol (StringRef& symbol) const
                    {
                        return get (Tags::MarketSegmentSymbol).toStringRef (symbol);
                    }

                    /// Standard Eurex product types.
                    bool parentMktSegmID (StringRef& id) const
                    {
                        return get (Tags::ParentMktSegmID).toStringRef (id);
                    }

                    /// Market Segmen type.
                    USApproval::Enum usApproval() const
                    {
                        return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
                    }

                    /// Market Segmen type.
                    MarketSegmentType::Enum marketSegmentType() const
                    {
                        return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
                    }

                    /// Market Segment subtype.
                    MarketSegmentSubType::Enum marketSegmentSubType() const
                    {
                        return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
                    }

                    ///
                    DecaySplit::Enum decaySplit() const
                    {
                        return getIntEnumFieldValue<DecaySplit>(*this, Tags::DecaySplit);
                    }

                    /// Defines the max expiry time in seconds describing when the RFQ session will be
                    /// automatically terminated.
                    bool maxOffsetRFQExpireTime(UInt32& value) const
                    {
                        return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
                    }

                    /// Defines the waiting period of the final STP deal inside Eurex EnLight in seconds.
                    bool offsetSTPEffectiveTime(UInt32& value) const
                    {
                        return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
                    }

                    /// TSL product group ID
                    bool tslMarketGroupID(UInt32& value) const
                    {
                        return get(Tags::TslMarketGroupID).toNumber(value);
                    }

                    /// TSL product group symbol
                    bool tslMarketGroup(StringRef& value) const
                    {
                        return get(Tags::TslMarketGroup).toStringRef(value);
                    }

                    /// Name of the Independent System Operator (ISO) such as PJM, ERCOT, ISONE, NYISO, CAISO, etc.
                    bool independentSystemOperator(StringRef& value) const
                    {
                        return get(Tags::IndependentSystemOperator).toStringRef(value);
                    }

                    /// Location/ nodes within the ISO which this product covers such as Western Hub, Jersey Central Power, etc .
                    bool locationID(StringRef& value) const
                    {
                        return get(Tags::LocationID).toStringRef(value);
                    }

                    ///
                    bool productType (StringRef& value) const
                    {
                        return get (Tags::ProductType).toStringRef (value);
                    }

                    /// Information about the hours covered by the product such as Peak, Off - Peak, 2x16, 7x8
                    bool commodityProductClass(StringRef& value) const
                    {
                        return get(Tags::CommodityProductClass).toStringRef(value);
                    }

                    /// Information about the load such as 5 MW, 25 MW, 50 MW
                    bool commodityUnit(UInt32& value) const
                    {
                        return get(Tags::CommodityUnit).toNumber(value);
                    }

                    ///
                    bool locationType(StringRef& value)
                    {
                        return get (Tags::LocationType).toStringRef (value);
                    }

                    ///
                    bool maxTradeVol(Decimal& value)
                    {
                        return get (Tags::MaxTradeVol).toNumber(value);
                    }

                    ///
                    bool maxTradeVal(UInt64& value)
                    {
                        return get (Tags::MaxTradeVal).toNumber(value);
                    }

                    ///
                    bool maxCalendarSpreadVol(Decimal& value)
                    {
                        return get (Tags::MaxCalendarSpreadVol).toNumber(value);
                    }

                    ///
                    bool maxTESVol(Decimal& value)
                    {
                        return get (Tags::MaxTESVol).toNumber(value);
                    }

                    ///
                    QuantityScalingFactors quantityScalingFactors() const
                    {
                        return QuantityScalingFactors (getGroup(Tags::NoQuantityScalingFactors));
                    }

                    /// Market Identifier Code of the underlying as specified in ISO 10383.
                    bool underlyingSecurityExchange (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
                    }

                    /// Underlying security symbol
                    bool underlyingSymbol (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSymbol).toStringRef (value);
                    }

                    /// ISIN code of the underlying.
                    bool underlyingSecurityId (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityID).toStringRef (value);
                    }

                    /// Underlying Security ID Source.
                    bool underlyingSecurityIdSource (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
                    }

                    /// Closing price of the underlying on the previous day.
                    bool underlyingPrevClosePx (Decimal& price) const
                    {
                        return get (Tags::UnderlyingPrevClosePx).toNumber (price);
                    }

                    /// Instrument Scopes.
                    InstrumentScopes instrumentScopes() const
                    {
                        return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
                    }

                    /// Related Market Segments.
                    RelatedMarketSegments relatedMarketSegments() const
                    {
                        return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
                    }

                    /// Tick rules.
                    /// The group is absent for buckets, when marketSegmentSubType() is equal to
                    /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
                    TickRules tickRules() const
                    {
                        checkSequencePresence("tickRules");

                        return TickRules (getGroup(Tags::NoTickRules) );
                    }

                    /// Price range rules.
                    /// The group is absent for buckets, when marketSegmentSubType() is equal to
                    /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
                    PriceRangeRules priceRangeRules() const
                    {
                        return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
                    }

                    /// Defines if one sided quotes are allowed
                    QuoteSideIndicator::Enum quoteSideIndicator() const
                    {
                        return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
                    }

                    /// Defines if one sided quotes are allowed
                    QuoteSideModelType::Enum quoteSideModelType() const
                    {
                        return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
                    }

                    /// Percentage by which range resulting from PriceRangeValue and PriceRangePercentage
                    /// has to be extended to obtain the valid price range during Fast Market
                    bool fastMarketPercentage (Decimal& value) const
                    {
                        return get (Tags::FastMarketPercentage).toNumber (value);
                    }

                    /// Specifies if Market Orders will be checked against the available bid/ask price on the opposing side in specific scenarios.
                    bool checkMarketOrder() const
                    {
                        UInt32 value;
                        return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
                    }

                    /// Herfindahl-Hirschman Index (HHI) intervals.
                    HHIIntervals hHIIntervals() const
                    {
                        return HHIIntervals(getOptionalGroup(Tags::NoHHIIntervals));
                    }

                    /// Quote size rules.
                    QuoteSizeRules quoteSizeRules() const
                    {
                        return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
                    }

                    /// Flex rules.
                    FlexRules flexRules() const
                    {
                        return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
                    }

                    /// Minimum Tradable Unit in derivatives markets.
                    bool roundLot(Decimal& value) const
                    {
                        return get(Tags::RoundLot).toNumber(value);
                    }

                    /// Match rules.
                    AuctionTypeRules auctionTypeRules() const
                    {
                        return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
                    }

                    /// Match rules.
                    /// The group is absent for buckets, when marketSegmentSubType() is equal to
                    /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
                    MatchRules matchRules() const
                    {
                        checkSequencePresence("matchRules");
                        return MatchRules (getGroup(Tags::NoMatchRules) );
                    }

                    /// Feeds
                    /// The group is absent for buckets, when marketSegmentSubType() is equal to
                    /// MarketSegmentSubType::BTRFBucket or MarketSegmentSubType::EBBBucket
                    Feeds feeds() const
                    {
                        checkSequencePresence("feeds");
                        return Feeds (getGroup(Tags::NoMDFeedTypes) );
                    }

                private:
                    friend class ProductSnapshotWrapper;

                    ProductSnapshot (const void* impl)
                        : Message (impl)
                    {
                    }

                    void checkSequencePresence(const char* seqName) const
                    {
                        if(marketSegmentSubType() == MarketSegmentSubType::BTRFBucket || marketSegmentSubType() == MarketSegmentSubType::EBBBucket)
                        {
                            const std::string enhancedName =
                                std::string("Rdi ProductSnapshot::") + seqName;

                            throw OperationException(
                                enhancedName.c_str(), "The sequence is absent for BTRFBucket and EBBBucket subtypes");
                        }
                    }
            };
        }
    }
}