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,

                    ///
                    SubscriptionRight,

                    ///
                    InvestmentFunds,

                    ///
                    DigitalAssets
                };
            };

            /// 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 DisplayDayOfWeek
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,
     
                    Monday = 0,
                    Tuesday = 1,
                    Wednesday = 2,
                    Thursday = 3,
                    Friday = 4,
                    Saturday = 5,
                    Sunday = 6
                };
            };

            ///
            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 WarrantType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Call = 0,
                    ///
                    Put,
                    ///
                    Range,
                    ///
                    Certificate ,
                    ///
                    Other
                };
            };


            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,
                    Energy = 6
                };
            };

            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,

                    ///
                    Specialist
                };
            };

            /// 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,

                    ///
                    NcsCviaT2S = 4
                };
            };

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

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

                    ///
                    Intraday = 0,

                    ///
                    Longterm,

                    ///
                    Activated,
                };
            };

            /// 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,
                    ///
                    MultiCCPEligible,
                    ///
                    PoolFactor,
                    ///
                    IndexationCoefficient,
                    ///
                    TradingOnTermsOfIssue,
                    ///
                    IssuerBusinessUnit,
                    ///
                    AllowKnockOut,
                    ///
                    HasPLP,
                    ///
                    PLPDeferralTime,
                    ///
                    WarrantStrike,
                    ///
                    ReportingMarketTES,
                    ///
                    LiquidityProviderUserGroup,
                    ///
                    SpecialistUserGroup,
                    ///
                    LiquidityClass
                };
            };

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

                    ///
                    LastEligible = 0,

                    ///
                    FirstEligible = 1,

                    ///
                    CapitalAdjustment = 2,

                    ///
                    DividendPayment = 3
                };
            };

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

                    ///
                    Default = 0,
                    ///
                    SingleAuction = 1,
                    ///
                    SpecialAuction = 2
                };
            };

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

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

                    ///
                    ContractMonthYear = 0,

                    ///
                    ExpirationDate,

                    ///
                    ContractDate,
                };
            };


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

                    ///
                    Dayly = 0,

                    ///
                    Weekly,

                    ///
                    Monthly,

                    ///
                    Quarterly,

                    ///
                    SemiAnnually,

                    ///
                    Yearly,
                };
            };

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

                    ///
                    EndOfMonth = 0,
                };
            };

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

                    ///
                    Day = 0,

                    ///
                    Week, 

                    ///
                    Month,

                    ///
                    Flex,

                    ///
                    EndOfMonth

                };
            };

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

                    ///
                    None = 0,

                    ///
                    Date,
                    
                    ///
                    Month,

                    ///
                    Permanent,

                    ///
                    Quarter,

                    ///
                    Season,

                    ///
                    WeekOfYear,

                    ///
                    Year,

                    ///
                    WeekOfMonth,

                    ///
                    WeekendOfYear,

                    ///
                    RelativeDay,

                    ///
                    EndOfMonth
                };
            };

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

                    ///
                    Summer = 0,

                    ///
                    Winter,
                };
            };

            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
                    EventType::Enum eventType() const
                    {
                        return getNonZeroIntEnumFieldValue<EventType>(*this, Tags::EventType);
                    }

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

                private:
                    friend class TypedGroup<Event>;

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

            class Events : public TypedGroup<Event>
            {
                private:
                    explicit
                    Events (const Group& group)
                        : TypedGroup<Event> (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);
                    }

                    /// Display Name
                    bool displayName(StringRef& desc) const
                    {
                        return get(Tags::DisplayName).toStringRef(desc);
                    }

                    /// Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely within a product.
                    ContractIdentificationEligibility::Enum contractIdentificationEligibility() const
                    {
                        return getIntEnumFieldValue<ContractIdentificationEligibility>(*this, Tags::ContractIdentificationEligibility);
                    }

                    /// Defines, if this contract based on its contract generation cycle, is considered primary.
                    bool isPrimary() const
                    {
                        UInt32 value;
                        return get(Tags::IsPrimary).toNumber(value) ? (value == 1) : false;
                    }

                    /// Actual contract start date
                    bool contractDate (UInt32& value)
                    {
                        return get (Tags::ContractDate).toNumber (value);
                    }

                    /// A symbol to describe the type of ContractDate
                    bool contractDateType(StringRef& value)
                    {
                        return get(Tags::ContractDateType).toStringRef(value);
                    }

                    /// Contract start month
                    bool contractMonthYear (UInt32& value)
                    {
                        return get (Tags::ContractMonthYear).toNumber (value);
                    }

                    /// Defines the instrument cycle type
                    ContractCycleType::Enum contractCycleType() const
                    {
                        return getIntEnumFieldValue<ContractCycleType>(*this, Tags::ContractCycleType);
                    }

                    /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
                    ContractCycleSubType::Enum contractCycleSubType() const
                    {
                        return getIntEnumFieldValue<ContractCycleSubType>(*this, Tags::ContractCycleSubType);
                    }

                    /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
                    ContractFrequency::Enum contractFrequency() const
                    {
                        return getIntEnumFieldValue<ContractFrequency>(*this, Tags::ContractFrequency);
                    }

                    /// Defines the instrument display instruction
                    ContractDisplayInstruction::Enum contractDisplayInstruction() const
                    {
                        return getIntEnumFieldValue<ContractDisplayInstruction>(*this, Tags::ContractDisplayInstruction);
                    }

                    /// Display Day
                    bool displayDay(UInt32& value)
                    {
                        return get(Tags::DisplayDay).toNumber(value);
                    }

                    /// Display Relative Day
                    bool displayRelativeDay(UInt32& value)
                    {
                        return get(Tags::DisplayRelativeDay).toNumber(value);
                    }

                    /// Display Week
                    bool displayWeek(UInt32& value)
                    {
                        return get(Tags::DisplayWeek).toNumber(value);
                    }

                    /// The day of week of the weekly contract.
                    DisplayDayOfWeek::Enum displayDayOfWeek() const
                    {
                        return getIntEnumFieldValue<DisplayDayOfWeek>(*this, Tags::DisplayDayOfWeek);
                    }

                    /// Display Month
                    bool displayMonth(UInt32& value)
                    {
                        return get(Tags::DisplayMonth).toNumber(value);
                    }

                    /// The Display Quarter denotes the three-month period inside a year.
                    bool displayQuarter(UInt32& value)
                    {
                        return get(Tags::DisplayQuarter).toNumber(value);
                    }

                    /// Defines the instrument display instruction
                    DisplaySeason::Enum displaySeason() const
                    {
                        return getIntEnumFieldValue<DisplaySeason>(*this, Tags::DisplaySeason);
                    }

                    /// Display Year
                    bool displayYear(UInt32& value)
                    {
                        return get(Tags::DisplayYear).toNumber(value);
                    }

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

                    /// Previous day’s option delta provided for option instruments only.
                    bool priceDelta(Decimal& value) const
                    {
                        return get(Tags::PriceDelta).toNumber(value);
                    }

                    /// Indicates whether this message is the last in a sequence of messages that together convey a joint list of InstrmtLegGrp.
                    LastFragment::Enum lastFragment() const
                    {
                        return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
                    }

                    /// Common integer multiple of the option legs for Option Volatility Strategies.
                    bool legRatioMultiplier(UInt32& value) const
                    {
                        return get(Tags::LegRatioMultiplier).toNumber(value);
                    }

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

                    /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
                    bool underlyingMarketSegmentID(UInt32& val) const
                    {
                        return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
                    }

                    /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
                    bool underlyingSecurityID(Int64& val) const
                    {
                        return get(Tags::UnderlyingSecurityID).toNumber(val);
                    }


                    /// 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.
                    bool currency (StringRef& value) const
                    {
                        return get (Tags::Currency).toStringRef (value);
                    }

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

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

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

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

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

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

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

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

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

                    /// Reference to Volatility Corridor Table for Opening Auction
                    bool volatilityCorridorOpeningAuction(UInt32& value) const
                    {
                        return get(Tags::VolatilityCorridorOpeningAuction).toNumber(value);
                    }

                    /// Reference to Volatility Corridor Table for Intraday Auction
                    bool volatilityCorridorIntradayAuction(UInt32& value) const
                    {
                        return get(Tags::VolatilityCorridorIntradayAuction).toNumber(value);
                    }

                    /// Reference to Volatility Corridor Table for Closing Auction
                    bool volatilityCorridorClosingAuction(UInt32& value) const
                    {
                        return get(Tags::VolatilityCorridorClosingAuction).toNumber(value);
                    }

                    /// Reference to Volatility Corridor Table in Continuous
                    bool volatilityCorridorContinuous(UInt32& value) const
                    {
                        return get(Tags::VolatilityCorridorContinuous).toNumber(value);
                    }

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

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

                    /// 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)
                    {
                    }
            };
        }
    }
}