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
        {
            struct ONIXS_EUREX_EMDI_API QuoteSideIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    OneSidedQuoteNotAllowed = 0,

                    OneSidedQuoteAllowed = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API QuoteSideModelType
            {
                enum Enum
                {
                    Undefined = -1,

                    SSQNotSupported = 0,

                    SSQSupported = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API FeedType
            {
                enum Enum
                {
                    Undefined = -1,

                    HighIncremental = 0,

                    HighSnapshot = 1,

                    Low = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API CrossMatchInstruction
            {
                enum Enum
                {
                    Undefined = -1,

                    CancelAggressive = 0,

                    CancelPassive,

                    CancelAggressiveAndPassive,
                };
            };
 
            class ONIXS_EUREX_EMDI_API TickRuleScope : GroupInstance
            {
            public:
                InstrumentType::Enum tickRuleProductComplex() const
                {
                    return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::TickRuleProductComplex);
                }

                TrdType::Enum trdType() const
                {
                    return getIntEnumFieldValue<TrdType>(*this, Tags::TrdType);
                }
 
            private:
                friend class TypedGroup<TickRuleScope>;
 
                TickRuleScope (const GroupInstance& groupInstance)
                        : GroupInstance (groupInstance)
                {
                }
            };

            class TickRuleScopes : public TypedGroup<TickRuleScope>
            {
            private:
                explicit
                TickRuleScopes (const Group& group)
                        : TypedGroup<TickRuleScope> (group)
                {
                }
 
                friend class TickRule;
            };
 

            class ONIXS_EUREX_EMDI_API TickRule : GroupInstance
            {
                public:
                    UInt32 tickRuleId () const
                    {
                        return getUInt32 (Tags::TickRuleID);
                    }

                    Decimal startTickPriceRange() const
                    {
                        return getDecimal (Tags::StartTickPriceRange);
                    }

                    Decimal endTickPriceRange() const
                    {
                        return getDecimal (Tags::EndTickPriceRange);
                    }

                    Decimal tickIncrement() const
                    {
                        return getDecimal (Tags::TickIncrement);
                    }

                    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;
            };

            struct ONIXS_EUREX_EMDI_API MatchAlgorithm
            {
                enum Enum
                {
                    Undefined = -1,

                    PriceTime = 0,

                    ProRata = 1,

                    TimeProRata = 2,
                };
            };
 

            struct ONIXS_EUREX_EMDI_API MatchType
            {
                enum Enum
                {
                    Undefined = -1,

                    AutoMatch = 0,

                    CallAuction = 1,
                };
            };
 

            struct ONIXS_EUREX_EMDI_API USApproval
            {
                enum Enum
                {
                    Undefined = -1,

                    NoApproval = 0,

                    CFTCApproved = 1,

                    SECApproved = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API MarketSegmentType
            {
                enum Enum
                {
                    Undefined = -1,

                    Pool = 0,
                };
            };
 

            struct ONIXS_EUREX_EMDI_API MarketSegmentSubType
            {
                enum Enum
                {
                    Undefined = -1,

                    InterProductSpread = 0,

                    BTRFBucket = 1,

                    EBBBucket = 2,

                    CommodityGroup = 3,
                };
            };

            struct ONIXS_EUREX_EMDI_API DecaySplit
            {
                enum Enum
                {
                    Undefined = -1,

                    Quarter = 0,

                    Season = 1,

                    Year = 2,
                };
            };

            struct ONIXS_EUREX_EMDI_API AuctionType
            {
                enum Enum
                {
                    Undefined = -1,

                    AnyAuction = 0,
                };
            };

            struct ONIXS_EUREX_EMDI_API ClosedBookIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    No = 0,

                    Yes = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API MarketImbalanceIndicator
            {
                enum Enum
                {
                    Undefined = -1,

                    No = 0,

                    Yes = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API DisableOnBookTrading
            {
                enum Enum
                {
                    Undefined = -1,

                    No = 0,

                    Yes = 1,
                };
            };

            struct ONIXS_EUREX_EMDI_API MarketSegmentRelationship
            {
                enum Enum
                {
                    Undefined = -1,

                    CashLegForVolatilityStrategies = 0,

                    TargetProductForDecayingProduct = 1,

                    BTRFBucket = 2,

                    EBBBucket = 3,

                    CommodityGroup = 4,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API AllowOneProductStrip
            {
                enum Enum
                {
                    Undefined = -1,

                    OneProductStripNotAllowed = 0,

                    OneProductStripNot = 1,
                };
            };

            class ONIXS_EUREX_EMDI_API MatchRule : GroupInstance
            {
                public:
                    InstrumentType::Enum matchRuleProductComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::MatchRuleProductComplex);
                    }

                    MatchAlgorithm::Enum matchAlgorithm() const
                    {
                        return getIntEnumFieldValue<MatchAlgorithm> (*this, Tags::MatchAlgorithm);
                    }

                    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;
            };

            class ONIXS_EUREX_EMDI_API QuoteSizeRule : GroupInstance
            {
                public:

                    bool minBidSize (Decimal& size) const
                    {
                        return get (Tags::MinBidSize).toNumber (size);
                    }

                    bool minOfferSize (Decimal& size) const
                    {
                        return get (Tags::MinOfferSize).toNumber (size);
                    }

                    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;
            };

            class ONIXS_EUREX_EMDI_API FlexRule : GroupInstance
            {
                public:

                    InstrumentType::Enum flexProductEligibilityComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType> (*this, Tags::FlexProductEligibilityComplex);
                    }

                    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;
            };
 

            class ONIXS_EUREX_EMDI_API AuctionTypeRule : GroupInstance
            {
                public:
                    AuctionType::Enum auctionType() const
                    {
                        return getIntEnumFieldValue<AuctionType> (*this, Tags::AuctionType);
                    }

                    ClosedBookIndicator::Enum closedBookIndicator() const
                    {
                        return getIntEnumFieldValue<ClosedBookIndicator> (*this, Tags::ClosedBookIndicator);
                    }

                    MarketImbalanceIndicator::Enum marketImbalanceIndicator() const
                    {
                        return getIntEnumFieldValue<MarketImbalanceIndicator> (*this, Tags::MarketImbalanceIndicator);
                    }

                    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;
            };

            class ONIXS_EUREX_EMDI_API Feed : GroupInstance
            {
                public:

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

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

                    bool marketDepth (UInt32& depth) const
                    {
                        return get (Tags::MarketDepth).toNumber (depth);
                    }

                    bool marketDepthTimeInterval (UInt32& interval) const
                    {
                        return get (Tags::MarketDepthTimeInterval).toNumber (interval);
                    }

                    bool mdRecoveryTimeInterval (UInt32& interval) const
                    {
                        return get (Tags::MDRecoveryTimeInterval).toNumber (interval);
                    }

                    StringRef mdPrimaryFeedLineID() const
                    {
                        StringRef val;
                        return get (Tags::PrimaryServiceLocationID).toStringRef (val) ? val : StringRef();
                    }

                    UInt32 mdPrimaryFeedLineSubID() const
                    {
                        return getUInt32 (Tags::PrimaryServiceLocationSubID);
                    }

                    bool mdSecondaryFeedLineID (StringRef& id) const
                    {
                        return get (Tags::SecondaryServiceLocationID).toStringRef (id);
                    }

                    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;
            };

            class ONIXS_EUREX_EMDI_API PriceRangeRule : GroupInstance
            {
                public:

                    UInt32 priceRangeRuleID() const
                    {
                        return getUInt32 (Tags::PriceRangeRuleID);
                    }

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

                    Decimal startPriceRange() const
                    {
                        return getDecimal (Tags::StartPriceRange);
                    }

                    Decimal endPriceRange() const
                    {
                        return getDecimal (Tags::EndPriceRange);
                    }

                    bool priceRangeValue (Decimal& value) const
                    {
                        return get (Tags::PriceRangeValue).toNumber (value);
                    }

                    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;
            };

            class ONIXS_EUREX_EMDI_API HHIInterval : GroupInstance
            {
            public:

                UInt32 hHIIndicator() const
                {
                    return getUInt32(Tags::HHIIndicator);
                }

                Decimal hHIIntervalEnd() const
                {
                    return getDecimal(Tags::HHIIntervalEnd);
                }
 
 
            private:
                friend class TypedGroup<HHIInterval>;
 
                HHIInterval(const GroupInstance& groupInstance)
                    : GroupInstance(groupInstance)
                {
                }
            };

            class HHIIntervals : public TypedGroup<HHIInterval>
            {
            private:
                explicit
                    HHIIntervals(const Group& group)
                    : TypedGroup<HHIInterval>(group)
                {
                }
 
                friend class ProductSnapshot;
            };

            class ONIXS_EUREX_EMDI_API InstrumentScope : GroupInstance
            {
                public:

                    InstrumentScopeOperator::Enum instrumentScopeOperator() const
                    {
                        return getIntEnumFieldValue<InstrumentScopeOperator> (*this, Tags::InstrumentScopeOperator);
                    }

                    SecurityType::Enum securityType() const
                    {
                        return getIntEnumFieldValue<SecurityType> (*this, Tags::InstrumentScopeSecurityType);
                    }

                    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;
            };
 

            class ONIXS_EUREX_EMDI_API RelatedMarketSegment : GroupInstance
            {
                public:

                    UInt32 relatedMarketSegmentID() const
                    {
                        return getUInt32 (Tags::RelatedMarketSegmentID);
                    }

                    MarketSegmentRelationship::Enum marketSegmentRelationship() const
                    {
                        return getIntEnumFieldValue<MarketSegmentRelationship>(*this, Tags::MarketSegmentRelationship);
                    }

                    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;
            };
 

            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;
            };
 

            class ONIXS_EUREX_EMDI_API ProductSnapshot : public Message
            {
                public:

                    StringRef marketId() const
                    {
                        return getStringRef (Tags::MarketID);
                    }

                    MarketSegmentId marketSegmentId() const
                    {
                        return getUInt32 (Tags::MarketSegmentID);
                    }

                    UInt32 effectiveBusinessDate() const
                    {
                        return getUInt32 (Tags::EffectiveBusinessDate);
                    }

                    UInt32 nextEffectiveBusinessDate() const
                    {
                        return getUInt32 (Tags::NextEffectiveBusinessDate);
                    }

                    StringRef marketSegment() const
                    {
                        return getStringRef (Tags::MarketSegment);
                    }

                    bool currency (StringRef& value) const
                    {
                        return get (Tags::Currency).toStringRef (value);
                    }

                    MarketSegmentStatus::Enum marketSegmentStatus() const
                    {
                        return getIntEnumFieldValue<MarketSegmentStatus> (*this, Tags::MarketSegmentStatus);
                    }

                    PartitionId partitionId() const
                    {
                        return getUInt32 (Tags::PartitionID);
                    }

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

                    bool negotiationDuration(UInt32& value) const
                    {
                        return get(Tags::NegotiationDuration).toNumber(value);
                    }

                    CrossMatchInstruction::Enum crossMatchInstructionDefault() const
                    {
                        return getIntEnumFieldValue<CrossMatchInstruction>(*this, Tags::CrossMatchInstructionDefault);
                    }

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

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

                    bool parentMktSegmID (StringRef& id) const
                    {
                        return get (Tags::ParentMktSegmID).toStringRef (id);
                    }

                    bool maxDiffExpMonths(UInt32& value) const
                    {
                        return get(Tags::MaxDiffExpMonths).toNumber(value);
                    }

                    USApproval::Enum usApproval() const
                    {
                        return getIntEnumFieldValue<USApproval>(*this, Tags::USApproval);
                    }

                    MarketSegmentType::Enum marketSegmentType() const
                    {
                        return getIntEnumFieldValue<MarketSegmentType> (*this, Tags::MarketSegmentType);
                    }

                    MarketSegmentSubType::Enum marketSegmentSubType() const
                    {
                        return getIntEnumFieldValue<MarketSegmentSubType> (*this, Tags::MarketSegmentSubType);
                    }

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

                    bool maxOffsetRFQExpireTime(UInt32& value) const
                    {
                        return get(Tags::MaxOffsetRFQExpireTime).toNumber(value);
                    }

                    bool offsetSTPEffectiveTime(UInt32& value) const
                    {
                        return get(Tags::OffsetSTPEffectiveTime).toNumber(value);
                    }

                    bool tslMarketGroupID(UInt32& value) const
                    {
                        return get(Tags::TslMarketGroupID).toNumber(value);
                    }

                    bool tslMarketGroup(StringRef& value) const
                    {
                        return get(Tags::TslMarketGroup).toStringRef(value);
                    }

                    bool independentSystemOperator(StringRef& value) const
                    {
                        return get(Tags::IndependentSystemOperator).toStringRef(value);
                    }

                    bool locationID(StringRef& value) const
                    {
                        return get(Tags::LocationID).toStringRef(value);
                    }

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

                    bool commodityProductClass(StringRef& value) const
                    {
                        return get(Tags::CommodityProductClass).toStringRef(value);
                    }

                    bool commodityUnit(UInt32& value) const
                    {
                        return get(Tags::CommodityUnit).toNumber(value);
                    }

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

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

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

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

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

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

                    bool underlyingSecurityExchange (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityExchange).toStringRef (value);
                    }

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

                    bool underlyingSecurityId (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityID).toStringRef (value);
                    }

                    bool underlyingSecurityIdSource (StringRef& value) const
                    {
                        return get (Tags::UnderlyingSecurityIDSource).toStringRef (value);
                    }

                    bool underlyingPrevClosePx (Decimal& price) const
                    {
                        return get (Tags::UnderlyingPrevClosePx).toNumber (price);
                    }

                    InstrumentScopes instrumentScopes() const
                    {
                        return InstrumentScopes ( getOptionalGroup (Tags::NoInstrumentScopes) );
                    }

                    RelatedMarketSegments relatedMarketSegments() const
                    {
                        return RelatedMarketSegments ( getOptionalGroup (Tags::NoRelatedMarketSegments) );
                    }

                    TickRules tickRules() const
                    {
                        checkSequencePresence("tickRules");
 
                        return TickRules (getGroup(Tags::NoTickRules) );
                    }

                    PriceRangeRules priceRangeRules() const
                    {
                        return PriceRangeRules (getOptionalGroup(Tags::NoPriceRangeRules) );
                    }

                    QuoteSideIndicator::Enum quoteSideIndicator() const
                    {
                        return getIntEnumFieldValue<QuoteSideIndicator> (*this, Tags::QuoteSideIndicator);
                    }

                    QuoteSideModelType::Enum quoteSideModelType() const
                    {
                        return getIntEnumFieldValue<QuoteSideModelType>(*this, Tags::QuoteSideModelType);
                    }

                    bool fastMarketPercentage (Decimal& value) const
                    {
                        return get (Tags::FastMarketPercentage).toNumber (value);
                    }

                    bool checkMarketOrder() const
                    {
                        UInt32 value;
                        return get(Tags::CheckMarketOrder).toNumber(value) ? (value == 1) : false;
                    }

                    HHIIntervals hHIIntervals() const
                    {
                        return HHIIntervals(getOptionalGroup(Tags::NoHHIIntervals));
                    }

                    QuoteSizeRules quoteSizeRules() const
                    {
                        return QuoteSizeRules (getOptionalGroup(Tags::NoQuoteSizeRules) );
                    }

                    FlexRules flexRules() const
                    {
                        return FlexRules (getOptionalGroup(Tags::NoFlexProductEligibilities) );
                    }

                    bool roundLot(Decimal& value) const
                    {
                        return get(Tags::RoundLot).toNumber(value);
                    }

                    AuctionTypeRules auctionTypeRules() const
                    {
                        return AuctionTypeRules ( getOptionalGroup (Tags::NoAuctionTypeRules) );
                    }

                    MatchRules matchRules() const
                    {
                        checkSequencePresence("matchRules");
                        return MatchRules (getGroup(Tags::NoMatchRules) );
                    }

                    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");
                        }
                    }
            };
        }
    }
}