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
        {

            class ONIXS_EUREX_EMDI_API SecurityAlt : GroupInstance
            {
                public:

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

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

            struct ONIXS_EUREX_EMDI_API SecurityType
            {
                enum Enum
                {
                    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
                };
            };

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

                    Include = 0,
                };
            };

            struct ONIXS_EUREX_EMDI_API DisplayDayOfWeek
            {
                enum Enum
                {
                    Undefined = -1,
 
                    Monday = 0,
                    Tuesday = 1,
                    Wednesday = 2,
                    Thursday = 3,
                    Friday = 4,
                    Saturday = 5,
                    Sunday = 6
                };
            };

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

                    Put = 0,

                    Call = 1
                };
            };
 

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

                    European = 0,

                    American = 1
                };
            };
 
            struct ONIXS_EUREX_EMDI_API MultilegModel
            {
                enum Enum
                {
                    Undefined = -1,

                    PredefinedMultilegSecurity = 0,

                    UserDefinedMultilegSecurity = 1
                };
            };

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

                    PremiumStyle = 0,

                    FuturesStyleMarkToMarket = 1
                };
            };

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

                    Call = 0,
                    Put,
                    Range,
                    Certificate ,
                    Other
                };
            };
 
 
            struct ONIXS_EUREX_EMDI_API SettlMethod
            {
                enum Enum
                {
                    Undefined = -1,

                    Cash = 0,

                    Physical = 1
                };
            };
 
            struct ONIXS_EUREX_EMDI_API SettlSubMethod
            {
                enum Enum
                {
                    Undefined = -1,

                    Shares = 0,
                    Derivatives = 1,
                    PaymentVsPayment = 2,
                    Notional = 3,
                    Cascade = 4,
                    Other = 5,
                    Energy = 6
                };
            };
 
            struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
            {
                enum Enum
                {
                    Undefined = -1,

                    Proprietary = 0,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
            {
                enum Enum
                {
                    Undefined = -1,

                    ClearingOrganization = 0,
                    MarketMaker = 1,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
            {
                enum Enum
                {
                    Undefined = -1,

                    DesignatedSponsor = 0,

                    Specialist
                };
            };

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

                    Auslandskassenverein = 0,

                    Girosammelverwahrung = 1,

                    Streifbandverwahrung = 2,

                    Wertpapierrechnung = 3,

                    NcsCviaT2S = 4
                };
            };

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

                    Basis30360 = 0,

                    M30360,

                    Act360,

                    Act365Fixed,

                    ActActAFB,

                    ActActIcma,

                    ActActIsda,

                    Act365L,
                };
            };

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

                    Zero = 0,

                    FixedRate,

                    FloatingRate,

                    Structured,
                };
            };

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

                    Intraday = 0,

                    Longterm,

                    Activated,
                };
            };
 

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

                    NoFlat = 0,

                    Flat,

                    XFlat,
                };
            };

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

                    PreListedOnly = 0,

                    UserRequested,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API MaturityFrequencyUnit
            {
                enum Enum
                {
                    Undefined = -1,

                    NoValue  = 0,

                    Day = 1, // D

                    Week = 2, // Wk

                    Month = 3, // Mo

                    Flexible = 4, // F

                    EndOfMonth = 5, // EOM
                };
 
                static std::string toString (Enum value);
            };

            class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
            {
                public:

                    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
                {
                    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
                {
                    Undefined = -1,

                    LastEligible = 0,

                    FirstEligible = 1,

                    CapitalAdjustment = 2,

                    DividendPayment = 3,

                    FinalSettlementReferenceDate = 4
                };
            };
 
            struct ONIXS_EUREX_EMDI_API InstrumentAuctionType
            {
                enum Enum
                {
                    Undefined = -1,

                    Default = 0,
                    SingleAuction = 1,
                    SpecialAuction = 2
                };
            };
 
            struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
            {
                enum Enum
                {
                    Undefined = -1,

                    Disabled = 0,
                    Enabled = 1,
                    CentralCounterparty = 2,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API PriceNotation
            {
                enum Enum
                {
                    Undefined = -1,

                    AverageNetChange = 0,

                    Average = 1,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API PriceType
            {
                enum Enum
                {
                    Undefined = -1,

                    Percent = 0,
                    Shares = 1,
                    Points = 2,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API ContractIdentificationEligibility
            {
                enum Enum
                {
                    Undefined = -1,

                    ContractMonthYear = 0,

                    ExpirationDate,

                    ContractDate,
                };
            };

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

                    MaturityMonth = 1,

                    MaturityMonthPlusOne,

                    IMMMonth,

                    FirstDeliveryMonth,

                    FinalSettlementDateMonth,
                };
            };
 
 
            struct ONIXS_EUREX_EMDI_API ContractCycleType
            {
                enum Enum
                {
                    Undefined = -1,

                    Dayly = 0,

                    Weekly,

                    Monthly,

                    Quarterly,

                    SemiAnnually,

                    Yearly,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API ContractCycleSubType
            {
                enum Enum
                {
                    Undefined = -1,

                    EndOfMonth = 0,
                };
            };
 
            struct ONIXS_EUREX_EMDI_API ContractFrequency
            {
                enum Enum
                {
                    Undefined = -1,

                    Day = 0,

                    Week,

                    Month,

                    Flex,

                    EndOfMonth
 
                };
            };
 
            struct ONIXS_EUREX_EMDI_API ContractDisplayInstruction
            {
                enum Enum
                {
                    Undefined = -1,

                    None = 0,

                    Date,

                    Month,

                    Permanent,

                    Quarter,

                    Season,

                    WeekOfYear,

                    Year,

                    WeekOfMonth,

                    WeekendOfYear,

                    RelativeDay,

                    EndOfMonth
                };
            };
 
            struct ONIXS_EUREX_EMDI_API DisplaySeason
            {
                enum Enum
                {
                    Undefined = -1,

                    Summer = 0,

                    Winter,
                };
            };
 
            class InstrumentParties : public TypedGroup<InstrumentParty>
            {
                private:
                    explicit
                    InstrumentParties (const Group& group)
                        : TypedGroup<InstrumentParty> (group)
                    {
                    }
 
                    friend class InstrumentSnapshot;
            };

            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;
            };
 
 
            class ONIXS_EUREX_EMDI_API SecurityClassification : GroupInstance
            {
            public:
                SecurityClassificationReasonType::Enum securityClassificationReason() const
                {
                    return getIntEnumFieldValue<SecurityClassificationReasonType> (*this, Tags::SecurityClassificationReason);
                }

                SecurityClassificationValueType::Enum securityClassificationValue() const
                {
                    return getIntEnumFieldValue<SecurityClassificationValueType> (*this, Tags::SecurityClassificationValue);
                }
 
            private:
                friend class TypedGroup<SecurityClassification>;
 
                SecurityClassification (const GroupInstance& groupInstance)
                    : GroupInstance (groupInstance)
                {
                }
            };

            class SecurityClassifications : public TypedGroup<SecurityClassification>
            {
            private:
                explicit
                SecurityClassifications (const Group& group)
                    : TypedGroup<SecurityClassification> (group)
                {
                }
 
                friend class InstrumentSnapshot;
            };

            class ONIXS_EUREX_EMDI_API Event : GroupInstance
            {
                public:
                    EventType::Enum eventType() const
                    {
                        return getIntEnumFieldValue<EventType>(*this, Tags::EventType);
                    }

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

            class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
            {
                public:

                    UInt32 tradingSessionID() const
                    {
                        return 0u;
                    }

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

            class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
            {
                public:
                    SecurityId securityId() const
                    {
                        return getInt64 (Tags::SecurityID);
                    }

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

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

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

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

                    bool securityExchange (StringRef& exchange) const
                    {
                        return get (Tags::SecurityExchange).toStringRef (exchange);
                    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    bool displayRelativeDay(Int32& value) const
                    {
                        return get(Tags::DisplayRelativeDay).toNumber(value);
                    }

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

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

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

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

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

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

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

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

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

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

                    bool optAttribute (UInt32& attribute) const
                    {
                        return get (Tags::OptAttribute).toNumber (attribute);
                    }

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

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

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

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

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

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

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

                    bool riskSensitivityFactor(Decimal& value) const
                    {
                        return get(Tags::RiskSensitivityFactor).toNumber(value);
                    }
 
                protected:
                    LastFragment::Enum lastFragment() const
                    {
                        return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
                    }

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

                    PriceNotation::Enum priceNotation() const
                    {
                        return getNonZeroIntEnumFieldValue<PriceNotation> (*this, Tags::PriceNotation);
                    }

                    InstrumentSnapshotLegs legs() const
                    {
                        return InstrumentSnapshotLegs (getGroup (Tags::NoLegs));
                    }
 
                public:
                    bool underlyingMarketSegmentID(UInt32& val) const
                    {
                        return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
                    }

                    bool underlyingSecurityID(Int64& val) const
                    {
                        return get(Tags::UnderlyingSecurityID).toNumber(val);
                    }

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

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

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

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

                    bool displayNameAlias(StringRef& val) const
                    {
                        return get(Tags::DisplayNameAlias).toStringRef(val);
                    }

                    bool periodAlias(StringRef& val) const
                    {
                        return get(Tags::PeriodAlias).toStringRef(val);
                    }

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

                    bool refTickTableID (UInt32& time) const
                    {
                        return get (Tags::RefTickTableID).toNumber (time);
                    }

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

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

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

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

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

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

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

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

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

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

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

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

                    StringRef midpointExecVenueId() const
                    {
                        StringRef val;
                        return get (Tags::MidpointExecVenueID).toStringRef (val) ? val : StringRef();
                    }

                    InstrumentParties instrumentParties() const
                    {
                        return InstrumentParties (getOptionalGroup (Tags::NoInstrumentParties));
                    }

                    StringRef underlyingSymbol() const
                    {
                        return getStringRef(Tags::UnderlyingSymbol);
                    }

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

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

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

                    AccruedInterestCalculationMethod::Enum couponDayCount() const
                    {
                        return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
                    }

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

                    StringRef countryOfIssue() const
                    {
                        return getStringRef(Tags::CountryOfIssue);
                    }

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

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

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

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

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

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

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

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

                    bool fixedAbsVolaInterruptionLimit(Decimal& increment) const
                    {
                        return get(Tags::FixedAbsVolaInterruptionLimit).toNumber(increment);
                    }

                    bool floatAbsVolaInterruptionLimit(Decimal& increment) const
                    {
                        return get(Tags::FloatAbsVolaInterruptionLimit).toNumber(increment);
                    }

                    bool fixedPctVolaInterruptionLimit(Decimal& increment) const
                    {
                        return get(Tags::FixedPctVolaInterruptionLimit).toNumber(increment);
                    }

                    bool floatPctVolaInterruptionLimit(Decimal& increment) const
                    {
                        return get(Tags::FloatPctVolaInterruptionLimit).toNumber(increment);
                    }
 

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

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

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

                    bool minPriceIncrement (Decimal& increment) const
                    {
                        return get (Tags::MinPriceIncrement).toNumber (increment);
                    }

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

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

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

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

                    bool securitySubType(UInt32& type) const
                    {
                        return get(Tags::SecuritySubType).toNumber(type);
                    }

                    bool relatedSecurityId(Int64& value) const
                    {
                        return get(Tags::RelatedSecurityID).toNumber(value);
                    }

                    StringRef relatedSecurityIDSource() const
                    {
                        return StringRef("M");
                    }

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

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

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

                    PriceType::Enum priceType() const
                    {
                        return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
                    }

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

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

                    bool quoteSizeRuleMinBidSize(Decimal& value) const
                    {
                        return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
                    }

                    bool quoteSizeMinOfferSize(Decimal& value) const
                    {
                        return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
                    }

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

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

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

                    SecurityClassifications securityClassifications() const
                    {
                        return SecurityClassifications(getOptionalGroup(Tags::NoSecurityClassifications));
                    }
 
                private:
                    friend class InstrumentSnapshotWrapper;
                    friend class InstrumentIncremental;
 
                    InstrumentSnapshot (const FIX::Core::Messaging::Message* impl)
                        : Message (impl)
                    {
                    }
            };
        }
    }
}