InstrumentSnapshot.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/Defines.h>
#include <OnixS/Eurex/MarketData/Message.h>
#include <OnixS/Eurex/MarketData/Group.h>
#include <OnixS/Eurex/MarketData/Tags.h>
#include <OnixS/Eurex/MarketData/InstrumentLeg.h>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {

            /// Alternate identifier entry.
            class ONIXS_EUREX_EMDI_API SecurityAlt : GroupInstance
            {
                public:

                    /// Alternate instrument identifier.
                    StringRef securityAltID() const
                    {
                        StringRef val;
                        return get (Tags::SecurityAltID).toStringRef (val) ? val : StringRef();
                    }

                    /// Security alternate id source.
                    StringRef securityAltIDSource() const
                    {
                        StringRef val;
                        return get (Tags::SecurityAltIDSource).toStringRef (val) ? val : StringRef();
                    }

                private:
                    friend class TypedGroup<SecurityAlt>;

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

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

                    friend class InstrumentSnapshot;
            };

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

                    ///
                    Option = 0,

                    ///
                    Future = 1,

                    ///
                    MultiLegInstrument = 2,

                    ///
                    VarianceFutures = 3,

                    ///
                    TotalReturnFutures = 4,

                    ///
                    CommonStock = 5,

                    ///
                    Bond = 6,

                    ///
                    TradeAtReferencePrice = 7,

                    ///
                    ExchangeTradedFund = 8,

                    ///
                    ExchangeTradedCommodity = 9,

                    ///
                    ExchangeTradedNote = 10,

                    ///
                    Warrant,

                    ///
                    Other,
                };
            };

            /// Exposes list of Instrument scope operators.
            struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Include = 0,
                };
            };


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

                    ///
                    Put = 0,

                    ///
                    Call = 1
                };
            };


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

                    ///
                    European = 0,

                    ///
                    American = 1
                };
            };

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

                    ///
                    PredefinedMultilegSecurity = 0,

                    ///
                    UserDefinedMultilegSecurity = 1
                };
            };

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

                    ///
                    PremiumStyle = 0,

                    ///
                    FuturesStyleMarkToMarket = 1
                };
            };

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

                    ///
                    Cash = 0,

                    ///
                    Physical = 1
                };
            };

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

                    ///
                    Shares = 0,
                    Derivatives = 1,
                    PaymentVsPayment = 2,
                    Notional = 3,
                    Cascade = 4,
                    Other = 5
                };
            };

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

                    ///
                    Proprietary = 0,
                };
            };

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

                    ///
                    ClearingOrganization = 0,
                    ///
                    MarketMaker = 1,
                };
            };

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

                    ///
                    DesignatedSponsor = 0,
                };
            };

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

                    ///
                    Auslandskassenverein = 0,

                    ///
                    Girosammelverwahrung = 1,

                    ///
                    Streifbandverwahrung = 2,

                    ///
                    Wertpapierrechnung = 3,
                };
            };

            /// Accrued interest Calculation Methods
            struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Basis30360 = 0,

                    ///
                    M30360,

                    ///
                    Act360,

                    ///
                    Act365Fixed,

                    ///
                    ActActAFB,

                    ///
                    ActActIcma,

                    ///
                    ActActIsda,

                    ///
                    Act365L,
                };
            };

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

                    ///
                    Zero = 0,

                    ///
                    FixedRate,

                    ///
                    FloatingRate,

                    ///
                    Structured,
                };
            };
            
            /// Flat Indicators
            struct ONIXS_EUREX_EMDI_API FlatIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    NoFlat = 0,

                    ///
                    Flat,

                    ///
                    XFlat,
                };
            };
            
            /// Instrument Party.
            class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
            {
                public:

                    /// Identifies a party associated with an instrument.
                    StringRef id() const
                    {
                        StringRef val;
                        return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
                    }

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

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

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

                private:
                    friend class TypedGroup<InstrumentParty>;

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

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

                    ///
                    MinimumReserveOrderQuantity = 0,
                    ///
                    MinimumDisplayQuantity = 1,
                    ///
                    IssuerName = 2,
                    ///
                    IssuerNumber = 3,
                    ///
                    MarketType = 4,
                    ///
                    MarketTypeSupplement = 5,
                    ///
                    ReportingMarket = 6,
                    ///
                    CumExIndicator = 7,
                    ///
                    ProductAssignmentGroup = 8,
                    ///
                    ProductAssignmentGroupDescription = 9,
                    ///
                    PreTradeLISValue = 10,
                    ///
                    VDOMinimumExecutionVolume = 11,
                    ///
                    IlliquidAsDefinedByExchange = 12,
                    ///
                    MarketMakingObligation = 13,
                    ///
                    LiquidAsDefinedByRegulator = 14,
                    ///
                    EligibleForStressedMarketConditions = 15,
                    ///
                    EligibleForSystematicInternaliser = 16,
                    ///
                    MultiCCPEligible = 17,
                    ///
                    PoolFactor,
                    ///
                    IndexationCoefficient,
                    ///
                    TradedBeforeIssueDate,
                    ///
                    IssuerBusinessUnit,
                    ///
                    AllowKnockOut,
                    ///
                    HasPLP,
                    ///
                    PLPDeferralTime,
                    ///
                    WarrantStrike,
                    ///
                    ReportingMarketTES
                };
            };

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

                    ///
                    Disabled = 0,
                    ///
                    Enabled = 1,
                    ///
                    CentralCounterparty = 2,
                };
            };

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

                    ///
                    Percent = 0,
                    ///
                    Shares = 1,
                    ///
                    Points = 2,
                };
            };

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

                    friend class InstrumentSnapshot;
            };

            /// Instrument Attribute.
            class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
            {
                public:

                    ///
                    InstrumentAttributeType::Enum type() const
                    {
                        return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
                    }

                    ///
                    StringRef value() const
                    {
                        StringRef val;
                        return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
                    }

                private:
                    friend class TypedGroup<InstrumentAttribute>;

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

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

                    friend class InstrumentSnapshot;
            };


            /// Event.
            class ONIXS_EUREX_EMDI_API Event : GroupInstance
            {
                public:
                    /// Event Type
                    bool eventType (UInt32& type) const
                    {
                        return get (Tags::EventType).toNumber (type);
                    }

                    /// Event Date
                    UInt32 eventDate() const
                    {
                        return getUInt32 (Tags::EventDate);
                    }

                private:
                    friend class TypedGroup<Event>;

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

            /// TesTickRule.
            class ONIXS_EUREX_EMDI_API TesTickRule : GroupInstance
            {
                /// Ref Tick Table ID
                bool refTickTableID (UInt32& type) const
                {
                    return get (Tags::RefTickTableID).toNumber (type);
                }

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

            private:
                friend class TypedGroup<TesTickRule>;

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

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

                    friend class InstrumentSnapshot;
            };

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

                    friend class InstrumentSnapshot;
            };

            ///
            class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
            {
                private:
                    explicit
                    InstrumentSnapshotLegs (const Group& group)
                        : TypedGroup<InstrumentLeg> (group)
                    {
                    }

                    friend class InstrumentSnapshot;
            };


            /// TradingSessionRules
            class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
            {
                public:

                    /// Trading Session ID
                    UInt32 tradingSessionID() const
                    {
                        return 0u;
                    }

                    /// Defines the trading session sub ID.
                    TradingSessionSubID::Enum tradingSessionSubID() const
                    {
                        return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
                    }

                private:
                    friend class TypedGroup<TradingSessionRule>;

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

            ///
            class TradingSessionRules : public TypedGroup<TradingSessionRule>
            {
                private:
                    explicit
                    TradingSessionRules (const Group& group)
                        : TypedGroup<TradingSessionRule> (group)
                    {
                    }

                    friend class InstrumentSnapshot;
            };

            /// Instrument snapshot.
            class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
            {
                public:
                    /// Instrument identifier.
                    SecurityId securityId() const
                    {
                        return getInt64 (Tags::SecurityID);
                    }

                    /// Entries.
                    SecurityAlts securityAlts() const
                    {
                        return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
                    }

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

                    /// Security Status.
                    SecurityStatus::Enum securityStatus() const
                    {
                        return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
                    }

                    /// Security description
                    bool securityDesc(StringRef& desc) const
                    {
                        return get (Tags::SecurityDesc).toStringRef (desc);
                    }

                    /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
                    bool securityExchange (StringRef& exchange) const
                    {
                        return get (Tags::SecurityExchange).toStringRef (exchange);
                    }

                    /// Type of Market Data update action
                    InstrumentType::Enum productComplex() const
                    {
                        return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
                    }

                    /// Indicates the type of security using ISO 10962 standard.
                    bool cfiCode(StringRef desc) const
                    {
                        return get (Tags::CFICode).toStringRef (desc);
                    }

                    /// Strike Price
                    bool strikePrice (Decimal& price) const
                    {
                        return get (Tags::StrikePrice).toNumber (price);
                    }

                    /// Strike Price Precision
                    bool strikePricePrecision (UInt32& precision) const
                    {
                        return get (Tags::StrikePricePrecision).toNumber (precision);
                    }

                    /// Contract Multiplier
                    bool contractMultiplier (Decimal& multiplier) const
                    {
                        return get (Tags::ContractMultiplier).toNumber (multiplier);
                    }

                    /// Put Or Call
                    PutOrCall::Enum putOrCall() const
                    {
                        return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
                    }

                    /// Version of an option. Version can change as a result of corporate actions or events.
                    bool optAttribute (UInt32& attribute) const
                    {
                        return get (Tags::OptAttribute).toNumber (attribute);
                    }

                    /// Exercise Style
                    ExerciseStyle::Enum exerciseStyle() const
                    {
                        return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
                    }

                    /// Original strike price prior to corporate action, e.g. 5.20.
                    bool origStrikePrice (Decimal& price) const
                    {
                        return get (Tags::OrigStrikePrice).toNumber (price);
                    }

                    /// Contract generation.
                    bool contractGenerationNumber (UInt32& number) const
                    {
                        return get (Tags::ContractGenerationNumber).toNumber (number);
                    }

                    /// Lepo Flag
                    bool lowExercisePriceOptionIndicator() const
                    {
                        UInt32 value;
                        return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
                    }

                    /// Traditional or futures margin style.
                    ValuationMethod::Enum valuationMethod() const
                    {
                        return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
                    }

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

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

                    /// Previous day�s settlement price. Converted in trading notation in case of variance futures.
                    bool priorSettlPrice (Decimal& price) const
                    {
                        return get (Tags::PriorSettlPrice).toNumber (price);
                    }

                    /// Legs
                    InstrumentSnapshotLegs legs() const
                    {
                        return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
                    }

                    /// UnitOfMeasure
                    bool unitOfMeasure(StringRef& val) const
                    {
                        return get(Tags::UnitOfMeasure).toStringRef(val);
                    }

                    /// AssetType
                    bool assetType(UInt32& val) const
                    {
                        return get(Tags::AssetType).toNumber(val);
                    }

                    /// AssetSubType
                    bool assetSubType(UInt32& val) const
                    {
                        return get(Tags::AssetSubType).toNumber(val);
                    }

                    /// Transact Time
                    bool transactTime (UInt64& time) const
                    {
                        return get (Tags::TransactTime).toNumber (time);
                    }

                    /// Reference to tick size table identifier from product level message.
                    bool refTickTableID (UInt32& time) const
                    {
                        return get (Tags::RefTickTableID).toNumber (time);
                    }

                    /// Currency as published in ISO 4217.
                    StringRef currency() const
                    {
                        return getStringRef (Tags::Currency);
                    }

                    /// Settlement currency.
                    bool settlCurrency(StringRef& desc) const
                    {
                        return get (Tags::SettlCurrency).toStringRef (desc);
                    }

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

                    /// Issuer of instrument.
                    StringRef issuer() const
                    {
                        return getStringRef(Tags::Issuer);
                    }

                    /// Issue date of instrument.
                    bool issueDate(UInt32& date) const
                    {
                        return get(Tags::IssueDate).toNumber(date);
                    }

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

                    /// The minimum tradable unit of a bond.
                    bool minTradeVol(Decimal& value) const
                    {
                        return get(Tags::MinTradeVol).toNumber(value);
                    }

                    /// Instrument parties.
                    InstrumentParties instrumentParties() const
                    {
                        return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
                    }

                    /// Underlying symbol.
                    StringRef underlyingSymbol() const
                    {
                        return getStringRef(Tags::UnderlyingSymbol);
                    }

                    /// Instrument identifier of the leg security.
                    bool couponRate(Decimal& value) const
                    {
                        return get(Tags::CouponRate).toNumber(value);
                    }

                    /// Previous coupon payment date.
                    bool previousCouponPaymentDate(UInt32& value) const
                    {
                        return get(Tags::PreviousCouponPaymentDate).toNumber(value);
                    }

                    /// Upcoming Coupon payment date.
                    bool couponPaymentDate(UInt32& value) const
                    {
                        return get(Tags::CouponPaymentDate).toNumber(value);
                    }

                    /// Defines the Accrued interest Calculation Method.
                    AccruedInterestCalculationMethod::Enum couponDayCount() const
                    {
                        return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
                    }

                    /// Coupon Type
                    CouponType::Enum couponType() const
                    {
                        return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
                    }

                    /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
                    StringRef countryOfIssue() const
                    {
                        return getStringRef(Tags::CountryOfIssue);
                    }

                    /// The Flat Indicator of a bond.
                    FlatIndicator::Enum flatIndicator() const
                    {
                        return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
                    }

                    /// Instrument attributes
                    InstrumentAttributes instrumentAttributes() const
                    {
                        return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
                    }

                    /// Events.
                    Events events() const
                    {
                        return Events ( getGroup (Tags::NoEvents) );
                    }

                    /// Events.
                    TesTickRules tesTickRules() const
                    {
                        return TesTickRules ( getGroup (Tags::NoTickRules) );
                    }
                    
                    /// Instrument Price Precision
                    bool instrumentPricePrecision (UInt32& value) const
                    {
                        return get (Tags::InstrumentPricePrecision).toNumber (value);
                    }
                    
                    /// Defines the minimum price movement in ticks (tick size).
                    bool minPriceIncrement (Decimal& increment) const
                    {
                        return get (Tags::MinPriceIncrement).toNumber (increment);
                    }

                    /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
                    bool minPriceIncrementClearing (Decimal& price) const
                    {
                        return get (Tags::MinPriceIncrementClearing).toNumber (price);
                    }

                    /// Defines the minimum price movement in the respective currency (tick value).
                    Decimal minPriceIncrementAmount() const
                    {
                        return getDecimal (Tags::MinPriceIncrementAmount);
                    }

                    /// Actual expiration day of the instrument (YYYYMMDD).
                    bool maturityDate(Timestamp& date) const
                    {
                        UInt32 tmp;
                        if (get(Tags::MaturityDate).toNumber(tmp))
                        {
                            date = Timestamp::parse(tmp, TimestampFormat::YYYYMMDD);
                            return true;
                        }
                        return false;
                    }

                    /// Expiration month (YYYYMM).
                    bool maturityMonthYear(UInt32& monthYear) const
                    {
                        return get(Tags::MaturityMonthYear).toNumber(monthYear);
                    }

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

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

                    /// Implied market indicator
                    ImpliedMarketIndicator::Enum impliedMarketIndicator() const
                    {
                        return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
                    }

                    /// Multileg model
                    MultilegModel::Enum multilegModel() const
                    {
                        return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
                    }

                    /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
                    PriceType::Enum priceType() const
                    {
                        return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
                    }

                    /// Only for cash.
                    PostTradeAnonymityType::Enum postTradeAnonymity() const
                    {
                        return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
                    }

                    /// Settlment Business Days
                    bool settlBusinessDays (UInt32& value) const
                    {
                        return get (Tags::SettlBusinessDays).toNumber (value);
                    }

                    /// Bid side minimum quote quantity.
                    bool quoteSizeRuleMinBidSize(Decimal& value) const
                    {
                        return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
                    }

                    /// Bid side minimum quote quantity.
                    bool quoteSizeMinOfferSize(Decimal& value) const
                    {
                        return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
                    }

                    /// Bid side minimum quote quantity.
                    UInt32 priceRangeRuleID() const
                    {
                        return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
                    }

                    ///
                    bool symbol(StringRef value) const
                    {
                        return get(Tags::Symbol).toStringRef(value);
                    }

                    ///
                    TradingSessionRules tradingSessionRules()
                    {
                        return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
                    }

                private:
                    friend class InstrumentSnapshotWrapper;
                    friend class InstrumentIncremental;

                    InstrumentSnapshot (const void* impl)
                        : Message (impl)
                    {
                    }
            };
        }
    }
}