Messages.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 <cassert>
#include <stdexcept>

#include <OnixS/CME/MDH/Composites.h>
#include <OnixS/CME/MDH/BinaryMessage.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN

/// MDInstrumentDefinitionFixedIncome.
struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFixedIncome57 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 57
    };

    /// Number of repeating EventType entries.
    /// Entry of EventsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        EventsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Code to represent the type of event.
        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventType>(offset);
        }

        /// Date and Time of instrument Activation or Expiration event
        /// sent as number of nanoseconds since Unix epoch.
        Timestamp eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<Timestamp>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.EventsEntry";
        }
    };

    /// Repeating group containing EventsEntry entries.
    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    /// Number of repeating FeedType repeating group entries.
    /// Entry of FeedTypesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        FeedTypesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Describes a class of service for a given data feed. GBX-
        /// Real Book, GBI-Implied Book.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// book depth.
        Int8 marketDepth() const
        {
            const BlockLength offset = 3;

            return ordinary<Int8>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.FeedTypesEntry";
        }
    };

    /// Repeating group containing FeedTypesEntry entries.
    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    /// Number of repeating InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        InstAttribEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument eligibility attributes.
        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        /// Bitmap field of 32 Boolean type instrument eligibility
        /// flags.
        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;

            return ordinary<InstAttribValue>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.InstAttribEntry";
        }
    };

    /// Repeating group containing InstAttribEntry entries.
    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    /// Number of entries.
    /// Entry of LotTypeRulesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        LotTypeRulesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// This tag is required to interpret the value in tag
        /// 1231-MinLotSize.
        Int8 lotType() const
        {
            const BlockLength offset = 0;

            return ordinary<Int8>(offset);
        }

        /// Minimum quantity accepted for order entry. If tag
        /// 1093-LotType=4, this value is the minimum quantity for
        /// order entry expressed in the applicable units, specified
        /// in tag 996-UnitOfMeasure, (e.g., megawatts). If tag
        /// 1093-LotType= 5, this value represents order qty increment.
        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;

            const BlockLength offset = 1;

            return decimal(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.LotTypeRulesEntry";
        }
    };

    /// Repeating group containing LotTypeRulesEntry entries.
    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    /// Initializes blank instance.
    InstrumentDefinitionFixedIncome57() {}

    /// Initializes instance over given memory block.
    InstrumentDefinitionFixedIncome57(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 10)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 1;

        return ordinary(value, offset, Null());
    }

    /// Last Security update action on Incremental feed, 'D' or
    /// 'M' is used when a mid-week deletion or modification (i.e.
    /// extension) occurs.
    SecurityUpdateAction::Enum securityUpdateAction() const
    {
        const BlockLength offset = 5;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Timestamp of when the instrument was last added, modified
    /// or deleted.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;

        return ordinary<Timestamp>(offset);
    }

    /// Identifies the current market state of the instrument.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 14;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// MD channel ID as defined in the XML Configuration file.
    Int16 applId() const
    {
        const BlockLength offset = 15;

        return ordinary<Int16>(offset);
    }

    /// Identifies the market segment for all CME Globex
    /// instruments.
    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;

        return ordinary<UInt8>(offset);
    }

    /// Indicates the product complex.
    UInt8 underlyingProduct() const
    {
        const BlockLength offset = 18;

        return ordinary<UInt8>(offset);
    }

    /// Exchange used to identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Security Group Code.
    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// The underlying asset code also known as Product Code.
    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Instrument Name or Symbol.
    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Unique instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 55;

        return ordinary<Int32>(offset);
    }

    /// Identifies class or source of Tag 48-SecurityID value.
    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    /// Security Type.
    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// ISO standard instrument categorization code.
    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Identifies the currency used for price.
    StrRef currency() const
    {
        const BlockLength offset = 71;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Identifies currency used for settlement, if different from
    /// trade price currency.
    StrRef settlCurrency() const
    {
        const BlockLength offset = 74;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Matching Algorithm.
    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 77;

        return ordinary<CHAR>(offset);
    }

    /// The minimum trading volume for a security.
    UInt32 minTradeVol() const
    {
        const BlockLength offset = 78;

        return ordinary<UInt32>(offset);
    }

    /// The maximum trading volume for a security.
    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 82;

        return ordinary<UInt32>(offset);
    }

    /// Minimum constant tick for the instrument, sent only if
    /// instrument is non-VTT (Variable Tick table) eligible.
    bool minPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 86;

        return decimal(value, offset, Null());
    }

    /// Contains the multiplier to convert the CME Globex display
    /// price to the conventional price.
    Decimal displayFactor() const
    {
        const BlockLength offset = 94;

        return decimal<Decimal9>(offset);
    }

    /// Price Denominator of Main Fraction.
    bool mainFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 102;

        return ordinary(value, offset, Null());
    }

    /// Price Denominator of Sub Fraction.
    bool subFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 103;

        return ordinary(value, offset, Null());
    }

    /// Number of Decimals in Displayed Price.
    bool priceDisplayFormat(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 104;

        return ordinary(value, offset, Null());
    }

    /// Unit of measure for the products' original contract size.
    /// This will be populated for all products listed on CME
    /// Globex.
    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 105;
        const BlockLength length = 30;

        return fixedStr<length>(offset);
    }

    /// This field contains the contract size for each instrument.
    /// Use in combination with tag 996-UnitofMeasure.
    bool unitOfMeasureQty(Decimal& value) const
    {
        typedef NullDecimal9 Null;

        const BlockLength offset = 135;

        return decimal(value, offset, Null());
    }

    /// Trading Reference Price.
    bool tradingReferencePrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 143;

        return decimal(value, offset, Null());
    }

    /// Indicates session date corresponding to the reference
    /// price in tag 1150-TradingReferencePrice.
    bool tradingReferenceDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 151;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Allowable high limit price for the trading day.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 153;

        return decimal(value, offset, Null());
    }

    /// Allowable low limit price for the trading day.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 161;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 169;

        return decimal(value, offset, Null());
    }

    /// Monetary value equivalent to the minimum price
    /// fluctuation.
    bool minPriceIncrementAmount(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 177;

        return decimal(value, offset, Null());
    }

    /// Issue Date.
    bool issueDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 185;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Dated Date.
    bool datedDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 187;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Maturity Date.
    bool maturityDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 189;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// The rate of interest that, when multiplied by the
    /// principal, par value, or face value of a bond, provides
    /// the currency amount of the periodic interest payment.
    bool couponRate(Decimal& value) const
    {
        typedef NullDecimal9 Null;

        const BlockLength offset = 191;

        return decimal(value, offset, Null());
    }

    /// Par value.
    bool parValue(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 199;

        return decimal(value, offset, Null());
    }

    /// Time unit associated with the frequency of the bond's
    /// coupon payment.
    StrRef couponFrequencyUnit() const
    {
        const BlockLength offset = 207;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Time unit multiplier for the frequency of the bond's
    /// coupon payment.
    bool couponFrequencyPeriod(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 210;

        return ordinary(value, offset, Null());
    }

    /// The day count convention used in interest calculations for
    /// a bond or an interest bearing security.
    StrRef couponDayCount() const
    {
        const BlockLength offset = 212;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Country of Origin, ISO alpha-2 country code.
    StrRef countryOfIssue() const
    {
        const BlockLength offset = 232;
        const BlockLength length = 2;

        return fixedStr<length>(offset);
    }

    /// Name of security issuer or the Legal Entity Identifier
    /// (LEI - the International ISO standard 17442).
    StrRef issuer() const
    {
        const BlockLength offset = 234;
        const BlockLength length = 25;

        return fixedStr<length>(offset);
    }

    /// Long name of the instrument.
    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 259;
        const BlockLength length = 35;

        return fixedStr<length>(offset);
    }

    /// Expanded instrument description. Will contain either ISIN
    /// or CUSIP.
    StrRef securityAltId() const
    {
        const BlockLength offset = 294;
        const BlockLength length = 12;

        return fixedStr<length>(offset);
    }

    /// Identifies class or source of the SecurityAltID (455)
    /// value.
    bool securityAltIdSource(SecurityAltIDSource::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 306;

        return enumeration<SecurityAltIDSource>(value, offset, Null());
    }

    /// Price quotation method.
    StrRef priceQuoteMethod() const
    {
        const BlockLength offset = 307;
        const BlockLength length = 5;

        return fixedStr<length>(offset);
    }

    /// Clearing organization.
    StrRef partyRoleClearingOrg() const
    {
        const BlockLength offset = 312;
        const BlockLength length = 5;

        return fixedStr<length>(offset);
    }

    /// User-defined Instrument flag.
    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 317;

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// Risk Set identifies the list of instruments sharing credit
    /// limits set up.
    StrRef riskSet() const
    {
        const BlockLength offset = 318;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Market Set defines the bilateral relationship and Self
    /// Match Prevention configuration for eligible markets.
    StrRef marketSet() const
    {
        const BlockLength offset = 324;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// External unique instrument ID.
    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 330;

        return ordinary(value, offset, Null());
    }

    /// Returns instance of Events repeating group.
    Events events() const
    {
        return groups().head<Events>();
    }

    /// Returns instance of FeedTypes repeating group.
    FeedTypes feedTypes() const
    {
        return groups().tail<Events>().head<FeedTypes>();
    }

    /// Returns instance of InstAttrib repeating group.
    InstAttrib instAttrib() const
    {
        return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
    }

    /// Returns instance of LotTypeRules repeating group.
    LotTypeRules lotTypeRules() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 338;

        return 207;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionFixedIncome57";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

/// ChannelReset.
struct ONIXS_CMEMDH_LTWT ChannelReset4 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 4
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data update action.
        UpdateTypeNew updateAction() const
        {
            return UpdateTypeNew();
        }

        /// Market Data entry type.
        EntryTypeChannelReset entryType() const
        {
            return EntryTypeChannelReset();
        }

        /// Indicates the channel ID as defined in the XML
        /// configuration file.
        Int16 applId() const
        {
            const BlockLength offset = 0;

            return ordinary<Int16>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 2;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "ChannelReset4.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    ChannelReset4() {}

    /// Initializes instance over given memory block.
    ChannelReset4(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "ChannelReset4";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// AdminHeartbeat.
struct ONIXS_CMEMDH_LTWT AdminHeartbeat12 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 12
    };

    /// Initializes blank instance.
    AdminHeartbeat12() {}

    /// Initializes instance over given memory block.
    AdminHeartbeat12(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 0;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminHeartbeat12";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("0");
    }
};

/// AdminLogin.
struct ONIXS_CMEMDH_LTWT AdminLogin15 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 15
    };

    /// Initializes blank instance.
    AdminLogin15() {}

    /// Initializes instance over given memory block.
    AdminLogin15(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Heartbeat interval (seconds).
    Int8 heartBtInt() const
    {
        const BlockLength offset = 0;

        return ordinary<Int8>(offset);
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminLogin15";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("A");
    }
};

/// AdminLogout.
struct ONIXS_CMEMDH_LTWT AdminLogout16 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 16
    };

    /// Initializes blank instance.
    AdminLogout16() {}

    /// Initializes instance over given memory block.
    AdminLogout16(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Free format text string. May include logout confirmation
    /// or reason for logout.
    StrRef text() const
    {
        const BlockLength offset = 0;
        const BlockLength length = 180;

        return fixedStr<length>(offset);
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminLogout16";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("5");
    }
};

/// AdminLogin.
struct ONIXS_CMEMDH_LTWT AdminLogin408 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 408
    };

    /// Initializes blank instance.
    AdminLogin408() {}

    /// Initializes instance over given memory block.
    AdminLogin408(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalTcpRecoveryVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Heartbeat interval (seconds).
    Int8 heartBtInt() const
    {
        const BlockLength offset = 0;

        return ordinary<Int8>(offset);
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminLogin408";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("A");
    }
};

/// AdminLogout.
struct ONIXS_CMEMDH_LTWT AdminLogout409 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 409
    };

    /// Initializes blank instance.
    AdminLogout409() {}

    /// Initializes instance over given memory block.
    AdminLogout409(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalTcpRecoveryVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Free format text string. May include logout confirmation
    /// or reason for logout.
    StrRef text() const
    {
        const BlockLength offset = 0;
        const BlockLength length = 180;

        return fixedStr<length>(offset);
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminLogout409";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("5");
    }
};

/// AdminHeartbeat.
struct ONIXS_CMEMDH_LTWT AdminHeartbeat410 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 410
    };

    /// Initializes blank instance.
    AdminHeartbeat410() {}

    /// Initializes instance over given memory block.
    AdminHeartbeat410(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalTcpRecoveryVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 0;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "AdminHeartbeat410";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("0");
    }
};

/// MDInstrumentDefinitionFuture.
struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFuture54 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 54
    };

    /// Number of repeating EventType entries.
    /// Entry of EventsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        EventsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Code to represent the type of event.
        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventType>(offset);
        }

        /// Date and Time of instument Activation or Expiration event
        /// sent as number of nanoseconds since Unix epoch.
        Timestamp eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<Timestamp>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.EventsEntry";
        }
    };

    /// Repeating group containing EventsEntry entries.
    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    /// Number of repeating FeedType entries.
    /// Entry of FeedTypesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        FeedTypesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Describes a class of service for a given data feed. GBX-
        /// Real Book, GBI-Implied Book.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// Book depth.
        Int8 marketDepth() const
        {
            const BlockLength offset = 3;

            return ordinary<Int8>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.FeedTypesEntry";
        }
    };

    /// Repeating group containing FeedTypesEntry entries.
    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    /// Number of repeating InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        InstAttribEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument eligibility attributes.
        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        /// Bitmap field of 32 Boolean type instrument eligibility
        /// flags.
        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;

            return ordinary<InstAttribValue>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.InstAttribEntry";
        }
    };

    /// Repeating group containing InstAttribEntry entries.
    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    /// Number of entries.
    /// Entry of LotTypeRulesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        LotTypeRulesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// This tag is required to interpret the value in tag
        /// 1231-MinLotSize.
        Int8 lotType() const
        {
            const BlockLength offset = 0;

            return ordinary<Int8>(offset);
        }

        /// Minimum quantity accepted for order entry. If tag
        /// 1093-LotType=4, this value is the minimum quantity for
        /// order entry expressed in the applicable units, specified
        /// in tag 996-UnitOfMeasure, e.g. megawatts.
        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;

            const BlockLength offset = 1;

            return decimal(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.LotTypeRulesEntry";
        }
    };

    /// Repeating group containing LotTypeRulesEntry entries.
    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    /// Initializes blank instance.
    InstrumentDefinitionFuture54() {}

    /// Initializes instance over given memory block.
    InstrumentDefinitionFuture54(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 1;

        return ordinary(value, offset, Null());
    }

    /// Last Security update action on Incremental feed, 'D' or
    /// 'M' is used when a mid-week deletion or modification (i.e.
    /// extension) occurs.
    SecurityUpdateAction::Enum securityUpdateAction() const
    {
        const BlockLength offset = 5;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Timestamp of when the instrument was last added, modified
    /// or deleted.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;

        return ordinary<Timestamp>(offset);
    }

    /// Identifies the current state of the instrument. In
    /// Security Definition message this tag is available in the
    /// Instrument Replay feed only.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 14;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// The channel ID as defined in the XML Configuration file.
    Int16 applId() const
    {
        const BlockLength offset = 15;

        return ordinary<Int16>(offset);
    }

    /// Identifies the market segment, populated for all CME
    /// Globex instruments.
    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;

        return ordinary<UInt8>(offset);
    }

    /// Product complex.
    UInt8 underlyingProduct() const
    {
        const BlockLength offset = 18;

        return ordinary<UInt8>(offset);
    }

    /// Exchange used to identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Security Group Code.
    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// The underlying asset code also known as Product Code.
    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Instrument Name or Symbol.
    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Unique instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 55;

        return ordinary<Int32>(offset);
    }

    /// Identifies class or source of tag 48-SecurityID value.
    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    /// Security Type.
    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// ISO standard instrument categorization code.
    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// This field provides the actual calendar date for contract
    /// maturity.
    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;

        const BlockLength offset = 71;

        return ordinary(value, offset, Null());
    }

    /// Identifies currency used for price.
    StrRef currency() const
    {
        const BlockLength offset = 76;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Identifies currency used for settlement, if different from
    /// trading currency.
    StrRef settlCurrency() const
    {
        const BlockLength offset = 79;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Matching algorithm.
    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 82;

        return ordinary<CHAR>(offset);
    }

    /// The minimum trading volume for a security.
    UInt32 minTradeVol() const
    {
        const BlockLength offset = 83;

        return ordinary<UInt32>(offset);
    }

    /// The maximum trading volume for a security.
    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 87;

        return ordinary<UInt32>(offset);
    }

    /// Minimum constant tick for the instrument, sent only if
    /// instrument is non-VTT (Variable Tick table) eligible.
    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 91;

        return decimal<PRICE9>(offset);
    }

    /// Contains the multiplier to convert the CME Globex display
    /// price to the conventional price.
    Decimal displayFactor() const
    {
        const BlockLength offset = 99;

        return decimal<Decimal9>(offset);
    }

    /// Price Denominator of Main Fraction.
    bool mainFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 107;

        return ordinary(value, offset, Null());
    }

    /// Price Denominator of Sub Fraction.
    bool subFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 108;

        return ordinary(value, offset, Null());
    }

    /// Number of decimals in fractional display price.
    bool priceDisplayFormat(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 109;

        return ordinary(value, offset, Null());
    }

    /// Unit of measure for the products' original contract size.
    /// This will be populated for all products listed on CME
    /// Globex.
    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 110;
        const BlockLength length = 30;

        return fixedStr<length>(offset);
    }

    /// This field contains the contract size for each instrument.
    /// Used in combination with tag 996-UnitofMeasure.
    bool unitOfMeasureQty(Decimal& value) const
    {
        typedef NullDecimal9 Null;

        const BlockLength offset = 140;

        return decimal(value, offset, Null());
    }

    /// Reference price for prelisted instruments or the last
    /// calculated Settlement whether it be Theoretical,
    /// Preliminary or a Final Settle of the session.
    bool tradingReferencePrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 148;

        return decimal(value, offset, Null());
    }

    /// Bitmap field of eight Boolean type indicators representing
    /// settlement price type.
    SettlPriceType settlPriceType() const
    {
        const BlockLength offset = 156;

        return ordinary<SettlPriceType>(offset);
    }

    /// The total open interest for the market at the close of the
    /// prior trading session.
    bool openInterestQty(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 157;

        return ordinary(value, offset, Null());
    }

    /// The total cleared volume of instrument traded during the
    /// prior trading session.
    bool clearedVolume(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 161;

        return ordinary(value, offset, Null());
    }

    /// Allowable high limit price for the trading day.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 165;

        return decimal(value, offset, Null());
    }

    /// Allowable low limit price for the trading day.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 173;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 181;

        return decimal(value, offset, Null());
    }

    /// Indicates the quantity that a contract will decay daily by
    /// once the decay start date is reached.
    bool decayQuantity(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 189;

        return ordinary(value, offset, Null());
    }

    /// Indicates the date at which a decaying contract will begin
    /// to decay.
    bool decayStartDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 193;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Fixed contract value assigned to each product.
    bool originalContractSize(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 195;

        return ordinary(value, offset, Null());
    }

    /// Number of deliverable units per instrument, e.g., peak
    /// days in maturity month or number of calendar days in
    /// maturity month.
    bool contractMultiplier(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 199;

        return ordinary(value, offset, Null());
    }

    /// Indicates the type of multiplier being applied to the
    /// product. Optionally used in combination with tag
    /// 231-ContractMultiplier.
    bool contractMultiplierUnit(Int8& value) const
    {
        typedef NullInt8 Null;

        const BlockLength offset = 203;

        return ordinary(value, offset, Null());
    }

    /// The schedule according to which the electricity is
    /// delivered in a physical contract, or priced in a financial
    /// contract. Specifies whether the contract is defined
    /// according to the Easter Peak, Eastern Off-Peak, Western
    /// Peak or Western Off-Peak.
    bool flowScheduleType(Int8& value) const
    {
        typedef NullInt8 Null;

        const BlockLength offset = 204;

        return ordinary(value, offset, Null());
    }

    /// Monetary value equivalent to the minimum price fluctuation.
    bool minPriceIncrementAmount(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 205;

        return decimal(value, offset, Null());
    }

    /// User-defined instruments flag.
    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 213;

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// Indicates session date corresponding to the settlement
    /// price in tag 1150-TradingReferencePrice.
    bool tradingReferenceDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 214;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// External unique instrument ID.
    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 216;
        const SchemaVersion since = 10;

        return ordinary(value, offset, Null(), since);
    }

    /// Returns instance of Events repeating group.
    Events events() const
    {
        return groups().head<Events>();
    }

    /// Returns instance of FeedTypes repeating group.
    FeedTypes feedTypes() const
    {
        return groups().tail<Events>().head<FeedTypes>();
    }

    /// Returns instance of InstAttrib repeating group.
    InstAttrib instAttrib() const
    {
        return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
    }

    /// Returns instance of LotTypeRules repeating group.
    LotTypeRules lotTypeRules() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 224;

        return 216;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionFuture54";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

/// MDInstrumentDefinitionSpread.
struct ONIXS_CMEMDH_LTWT InstrumentDefinitionSpread56 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 56
    };

    /// Number of repeating EventType entries.
    /// Entry of EventsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        EventsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Code to represent the type of event.
        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventType>(offset);
        }

        /// Date and time of instument Activation or Expiration event
        /// sent as number of nanoseconds since Unix epoch.
        Timestamp eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<Timestamp>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.EventsEntry";
        }
    };

    /// Repeating group containing EventsEntry entries.
    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    /// Number of FeedType entries.
    /// Entry of FeedTypesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        FeedTypesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Describes a class of service for a given data feed. GBX-
        /// Real Book, GBI-Implied Book.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// Identifies the depth of book.
        Int8 marketDepth() const
        {
            const BlockLength offset = 3;

            return ordinary<Int8>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.FeedTypesEntry";
        }
    };

    /// Repeating group containing FeedTypesEntry entries.
    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    /// Number of InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        InstAttribEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument Eligibility Attributes.
        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        /// Bitmap field of 32 Boolean type Instrument eligibility
        /// flags.
        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;

            return ordinary<InstAttribValue>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.InstAttribEntry";
        }
    };

    /// Repeating group containing InstAttribEntry entries.
    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    /// Number of entries.
    /// Entry of LotTypeRulesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        LotTypeRulesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// This tag is required to interpret the value in tag
        /// 1231-MinLotSize.
        Int8 lotType() const
        {
            const BlockLength offset = 0;

            return ordinary<Int8>(offset);
        }

        /// Minimum quantity accepted for order entry. If tag
        /// 1093-LotType=4, this value is the minimum quantity for
        /// order entry expressed in the applicable units, specified
        /// in tag 996-UnitOfMeasure, e.g. megawatts.
        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;

            const BlockLength offset = 1;

            return decimal(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.LotTypeRulesEntry";
        }
    };

    /// Repeating group containing LotTypeRulesEntry entries.
    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    /// Number of Leg entries.
    /// Entry of LegsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LegsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        LegsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        LegsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Leg Security ID.
        Int32 legSecurityId() const
        {
            const BlockLength offset = 0;

            return ordinary<Int32>(offset);
        }

        /// Identifies source of tag 602-LegSecurityID value.
        SecurityIDSource legSecurityIdSource() const
        {
            return SecurityIDSource();
        }

        /// Leg side.
        LegSide::Enum legSide() const
        {
            const BlockLength offset = 4;

            return enumeration<LegSide>(offset);
        }

        /// Leg ratio of quantity for this individual leg relative to
        /// the entire multi-leg instrument.
        Int8 legRatioQty() const
        {
            const BlockLength offset = 5;

            return ordinary<Int8>(offset);
        }

        /// Price for the future leg of a UDS Covered instrument.
        bool legPrice(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 6;

            return decimal(value, offset, Null());
        }

        /// Delta used to calculate the quantity of futures used to
        /// cover the option or option strategy.
        bool legOptionDelta(Decimal& value) const
        {
            typedef NullDecimalQty Null;

            const BlockLength offset = 14;

            return decimal(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 18;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.LegsEntry";
        }
    };

    /// Repeating group containing LegsEntry entries.
    typedef BinaryGroup<LegsEntry, GroupSize, MessageSize> Legs;

    /// Initializes blank instance.
    InstrumentDefinitionSpread56() {}

    /// Initializes instance over given memory block.
    InstrumentDefinitionSpread56(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 1;

        return ordinary(value, offset, Null());
    }

    /// Last Security update action on Incremental feed, 'D' or
    /// 'M' is used when a mid-week deletion or modification (i.e.
    /// extension) occurs.
    SecurityUpdateAction::Enum securityUpdateAction() const
    {
        const BlockLength offset = 5;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Timestamp of when the instrument was last added, modified
    /// or deleted.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;

        return ordinary<Timestamp>(offset);
    }

    /// Identifies the current state of the instrument. The data
    /// is available in the Instrument Replay feed only.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 14;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// The channel ID as defined in the XML Configuration file.
    Int16 applId() const
    {
        const BlockLength offset = 15;

        return ordinary<Int16>(offset);
    }

    /// Identifies the market segment, populated for all CME
    /// Globex instruments.
    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;

        return ordinary<UInt8>(offset);
    }

    /// Product complex.
    bool underlyingProduct(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 18;

        return ordinary(value, offset, Null());
    }

    /// Exchange used to identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Security Group Code.
    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// The underlying asset code also known as Product Code.
    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Instrument Name or Symbol. Previously used as  Group Code.
    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Unique instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 55;

        return ordinary<Int32>(offset);
    }

    /// Identifies class or source of the security ID (Tag 48)
    /// value.
    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    /// Security Type.
    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// ISO standard instrument categorization code.
    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// This field provides the actual calendar date for contract
    /// maturity.
    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;

        const BlockLength offset = 71;

        return ordinary(value, offset, Null());
    }

    /// Identifies currency used for price.
    StrRef currency() const
    {
        const BlockLength offset = 76;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Strategy type.
    StrRef securitySubType() const
    {
        const BlockLength offset = 79;
        const BlockLength length = 5;

        return fixedStr<length>(offset);
    }

    /// User-defined instruments flag.
    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 84;

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// Matching algorithm.
    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 85;

        return ordinary<CHAR>(offset);
    }

    /// The minimum trading volume for a security.
    UInt32 minTradeVol() const
    {
        const BlockLength offset = 86;

        return ordinary<UInt32>(offset);
    }

    /// The maximum trading volume for a security.
    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 90;

        return ordinary<UInt32>(offset);
    }

    /// Minimum constant tick for the instrument, sent only if
    /// instrument is non-VTT (Variable Tick table) eligible.
    bool minPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 94;

        return decimal(value, offset, Null());
    }

    /// Contains the multiplier to convert the CME Globex display
    /// price to the conventional price.
    Decimal displayFactor() const
    {
        const BlockLength offset = 102;

        return decimal<Decimal9>(offset);
    }

    /// Number of decimals in fractional display price.
    bool priceDisplayFormat(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 110;

        return ordinary(value, offset, Null());
    }

    /// Used for price calculation in spread and leg pricing.
    bool priceRatio(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 111;

        return decimal(value, offset, Null());
    }

    /// Tick Rule.
    bool tickRule(Int8& value) const
    {
        typedef NullInt8 Null;

        const BlockLength offset = 119;

        return ordinary(value, offset, Null());
    }

    /// Unit of measure for the products' original contract size.
    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 120;
        const BlockLength length = 30;

        return fixedStr<length>(offset);
    }

    /// Reference price - the most recently available Settlement
    /// whether it be Theoretical, Preliminary or a Final Settle
    /// of the session.
    bool tradingReferencePrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 150;

        return decimal(value, offset, Null());
    }

    /// Bitmap field of eight Boolean type indicators representing
    /// settlement price type.
    SettlPriceType settlPriceType() const
    {
        const BlockLength offset = 158;

        return ordinary<SettlPriceType>(offset);
    }

    /// The total open interest for the market at the close of the
    /// prior trading session.
    bool openInterestQty(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 159;

        return ordinary(value, offset, Null());
    }

    /// The total cleared volume of instrument traded during the
    /// prior trading session.
    bool clearedVolume(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 163;

        return ordinary(value, offset, Null());
    }

    /// Allowable high limit price for the trading day.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 167;

        return decimal(value, offset, Null());
    }

    /// Allowable low limit price for the trading day.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 175;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 183;

        return decimal(value, offset, Null());
    }

    /// Price Denominator of Main Fraction.
    bool mainFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 191;

        return ordinary(value, offset, Null());
    }

    /// Price Denominator of Sub Fraction.
    bool subFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 192;

        return ordinary(value, offset, Null());
    }

    /// Indicates session date corresponding to the settlement
    /// price in tag 1150-TradingReferencePrice.
    bool tradingReferenceDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 193;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Price quotation method.
    StrRef priceQuoteMethod() const
    {
        const BlockLength offset = 195;
        const BlockLength length = 5;
        const SchemaVersion since = 10;

        return fixedStr<length>(offset, since);
    }

    /// Risk Set identifies the list of instruments sharing credit
    /// limits set up.
    StrRef riskSet() const
    {
        const BlockLength offset = 200;
        const BlockLength length = 6;
        const SchemaVersion since = 10;

        return fixedStr<length>(offset, since);
    }

    /// Market Set defines the bilateral relationship and Self
    /// Match Prevention configuration for eligible markets.
    StrRef marketSet() const
    {
        const BlockLength offset = 206;
        const BlockLength length = 6;
        const SchemaVersion since = 10;

        return fixedStr<length>(offset, since);
    }

    /// External unique instrument ID.
    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 212;
        const SchemaVersion since = 10;

        return ordinary(value, offset, Null(), since);
    }

    /// Long name of the instrument.
    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 220;
        const BlockLength length = 35;
        const SchemaVersion since = 10;

        return fixedStr<length>(offset, since);
    }

    /// Returns instance of Events repeating group.
    Events events() const
    {
        return groups().head<Events>();
    }

    /// Returns instance of FeedTypes repeating group.
    FeedTypes feedTypes() const
    {
        return groups().tail<Events>().head<FeedTypes>();
    }

    /// Returns instance of InstAttrib repeating group.
    InstAttrib instAttrib() const
    {
        return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
    }

    /// Returns instance of LotTypeRules repeating group.
    LotTypeRules lotTypeRules() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
    }

    /// Returns instance of Legs repeating group.
    Legs legs() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().head<Legs>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 255;

        return 195;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionSpread56";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

/// SecurityStatus.
struct ONIXS_CMEMDH_LTWT SecurityStatus30 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 30
    };

    /// Initializes blank instance.
    SecurityStatus30() {}

    /// Initializes instance over given memory block.
    SecurityStatus30(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Security Group.
    StrRef securityGroup() const
    {
        const BlockLength offset = 8;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Product Code within Security Group specified.
    StrRef asset() const
    {
        const BlockLength offset = 14;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// If this tag is present, 35=f message is sent for the
    /// instrument.
    bool securityId(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 20;

        return ordinary(value, offset, Null());
    }

    /// Trade Session Date.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 24;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 26;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Identifies the trading status applicable to the instrument
    /// or Security Group.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 27;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// Identifies the reason for the status change.
    HaltReason::Enum haltReason() const
    {
        const BlockLength offset = 28;

        return enumeration<HaltReason>(offset);
    }

    /// Identifies an additional event or a rule related to the
    /// status.
    SecurityTradingEvent::Enum securityTradingEvent() const
    {
        const BlockLength offset = 29;

        return enumeration<SecurityTradingEvent>(offset);
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 30;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "SecurityStatus30";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("f");
    }
};

/// MDIncrementalRefreshBook.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshBook46 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 46
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Market Data entry size.
        bool entrySize(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 12;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 16;

            return ordinary<UInt32>(offset);
        }

        /// In Book entry - aggregate number of orders at given price
        /// level.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 20;

            return ordinary(value, offset, Null());
        }

        /// Aggregate book level.
        UInt8 priceLevel() const
        {
            const BlockLength offset = 24;

            return ordinary<UInt8>(offset);
        }

        ///  Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 25;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeBook::Enum entryType() const
        {
            const BlockLength offset = 26;

            return enumeration<EntryTypeBook>(offset);
        }

        /// Tradeable qty.
        bool tradeableSize(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 27;
            const SchemaVersion since = 10;

            return ordinary(value, offset, Null(), since);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion version)
        {
            if (version >= 10)
                return 31;

            return 27;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshBook46.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Number of OrderID entries.
    /// Entry of OrderIDEntry repeating group.
    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize8Byte::BlockLength> Base;

        /// Initializes blank instance.
        OrderIDEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique Order ID.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Order priority for execution on the order book.
        bool orderPriority(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Visible qty of order.
        bool displayQty(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 16;

            return ordinary(value, offset, Null());
        }

        /// Reference to corresponding Price and Security ID, sequence
        /// of MD entry in the message.
        bool referenceId(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 20;

            return ordinary(value, offset, Null());
        }

        /// Order book update action to be applied to the order
        /// referenced by OrderID.
        OrderUpdateAction::Enum orderUpdateAction() const
        {
            const BlockLength offset = 21;

            return enumeration<OrderUpdateAction>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 22;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshBook46.OrderIDEntry";
        }
    };

    /// Repeating group containing OrderIDEntry entries.
    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    /// Initializes blank instance.
    IncrementalRefreshBook46() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshBook46(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Returns instance of OrderIDEntries repeating group.
    OrderIDEntries orderIdEntries() const
    {
        return groups().tail<Entries>().head<OrderIDEntries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshBook46";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshDailyStatistics.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshDailyStatistics49 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 49
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Market Data entry size.
        bool entrySize(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 12;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 16;

            return ordinary<UInt32>(offset);
        }

        /// Indicates trade session date corresponding to a statistic
        /// entry.
        bool tradingReferenceDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 20;

            FieldValue fieldValue;

            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        /// Bitmap field of eight Boolean type indicators representing
        /// settlement price type.
        SettlPriceType settlPriceType() const
        {
            const BlockLength offset = 22;

            return ordinary<SettlPriceType>(offset);
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 23;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeDailyStatistics::Enum entryType() const
        {
            const BlockLength offset = 24;

            return enumeration<EntryTypeDailyStatistics>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 25;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshDailyStatistics49.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    IncrementalRefreshDailyStatistics49() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshDailyStatistics49(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshDailyStatistics49";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshLimitsBanding.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshLimitsBanding50 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 50
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Upper price threshold for the instrument.
        bool highLimitPrice(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Lower price threshold for the instrument.
        bool lowLimitPrice(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 8;

            return decimal(value, offset, Null());
        }

        /// Differential static value for price banding.
        bool maxPriceVariation(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 16;

            return decimal(value, offset, Null());
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 24;

            return ordinary<Int32>(offset);
        }

        /// MD Entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 28;

            return ordinary<UInt32>(offset);
        }

        /// Market Data entry update action. In order to delete
        /// banding value, high or low limit, the deleted price field
        /// is populated with a NULL.
        UpdateActionNew updateAction() const
        {
            return UpdateActionNew();
        }

        /// Market Data entry type.
        EntryTypeLimits entryType() const
        {
            return EntryTypeLimits();
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 32;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshLimitsBanding50.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    IncrementalRefreshLimitsBanding50() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshLimitsBanding50(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshLimitsBanding50";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshSessionStatistics.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatistics51 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 51
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        Decimal entryPx() const
        {
            const BlockLength offset = 0;

            return decimal<PRICE9>(offset);
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

        /// MD Entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 12;

            return ordinary<UInt32>(offset);
        }

        /// Flag describing IOP and Open Price entries.
        bool openCloseSettlFlag(OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 16;

            return enumeration<OpenCloseSettlFlag>(value, offset, Null());
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 17;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeStatistics::Enum entryType() const
        {
            const BlockLength offset = 18;

            return enumeration<EntryTypeStatistics>(offset);
        }

        /// Indicative Opening Quantity.
        bool entrySize(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 19;

            return ordinary(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 23;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshSessionStatistics51.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    IncrementalRefreshSessionStatistics51() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshSessionStatistics51(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshSessionStatistics51";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshVolume.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshVolume37 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 37
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Cumulative traded volume.
        Int32 entrySize() const
        {
            const BlockLength offset = 0;

            return ordinary<Int32>(offset);
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 4;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 8;

            return ordinary<UInt32>(offset);
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 12;

            return enumeration<UpdateAction>(offset);
        }

        /// Electronic Volume entry provides cumulative session trade
        /// volume updated with the event.
        EntryTypeVol entryType() const
        {
            return EntryTypeVol();
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 13;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshVolume37.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    IncrementalRefreshVolume37() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshVolume37(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshVolume37";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// SnapshotFullRefresh.
struct ONIXS_CMEMDH_LTWT SnapshotFullRefresh52 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 52
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Market Data entry quantity.
        bool entrySize(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Aggregate number of orders at the given price level.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 12;

            return ordinary(value, offset, Null());
        }

        /// Aggregate book position.
        bool priceLevel(Int8& value) const
        {
            typedef NullInt8 Null;

            const BlockLength offset = 16;

            return ordinary(value, offset, Null());
        }

        /// Indicates the date of trade session corresponding to a
        /// statistic entry.
        bool tradingReferenceDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 17;

            FieldValue fieldValue;

            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        /// Flag describing  Open Price entry.
        bool openCloseSettlFlag(OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 19;

            return enumeration<OpenCloseSettlFlag>(value, offset, Null());
        }

        /// Bitmap field of eight Boolean type indicators representing
        /// settlement price type.
        SettlPriceType settlPriceType() const
        {
            const BlockLength offset = 20;

            return ordinary<SettlPriceType>(offset);
        }

        /// Market Data entry type.
        EntryType::Enum entryType() const
        {
            const BlockLength offset = 21;

            return enumeration<EntryType>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 22;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "SnapshotFullRefresh52.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    SnapshotFullRefresh52() {}

    /// Initializes instance over given memory block.
    SnapshotFullRefresh52(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Sequence number of the last Incremental feed packet
    /// processed. This value is used to synchronize the snapshot
    /// loop with the real-time feed.
    UInt32 lastMsgSeqNumProcessed() const
    {
        const BlockLength offset = 0;

        return ordinary<UInt32>(offset);
    }

    /// Total number of messages replayed in the loop.
    UInt32 totNumReports() const
    {
        const BlockLength offset = 4;

        return ordinary<UInt32>(offset);
    }

    /// Security ID.
    Int32 securityId() const
    {
        const BlockLength offset = 8;

        return ordinary<Int32>(offset);
    }

    /// Sequence number of the last Market Data entry processed
    /// for the instrument.
    UInt32 rptSeq() const
    {
        const BlockLength offset = 12;

        return ordinary<UInt32>(offset);
    }

    /// Timestamp of the last event security participated in, sent
    /// as number of nanoseconds since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 16;

        return ordinary<Timestamp>(offset);
    }

    /// UTC Date and time of last Security Definition add, update
    /// or delete on a given Market Data channel.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 24;

        return ordinary<Timestamp>(offset);
    }

    /// Trade session date sent as number of days since Unix epoch.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 32;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Identifies the current trading state of the instrument.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 34;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// Upper price threshold for the instrument.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 35;

        return decimal(value, offset, Null());
    }

    /// Lower price threshold for the instrument.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 43;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 51;

        return decimal(value, offset, Null());
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 59;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "SnapshotFullRefresh52";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("W");
    }
};

/// QuoteRequest.
struct ONIXS_CMEMDH_LTWT QuoteRequest39 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 39
    };

    /// Indicates the number of repeating symbols specified.
    /// Entry of RelatedSymEntry repeating group.
    struct ONIXS_CMEMDH_LTWT RelatedSymEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        RelatedSymEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        RelatedSymEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument Name or Symbol.
        StrRef symbol() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 20;

            return fixedStr<length>(offset);
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 20;

            return ordinary<Int32>(offset);
        }

        /// Quantity requested.
        bool orderQty(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 24;

            return ordinary(value, offset, Null());
        }

        /// Type of quote requested.
        Int8 quoteType() const
        {
            const BlockLength offset = 28;

            return ordinary<Int8>(offset);
        }

        /// Side requested.
        bool side(Int8& value) const
        {
            typedef NullInt8 Null;

            const BlockLength offset = 29;

            return ordinary(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 30;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "QuoteRequest39.RelatedSymEntry";
        }
    };

    /// Repeating group containing RelatedSymEntry entries.
    typedef BinaryGroup<RelatedSymEntry, GroupSize, MessageSize> RelatedSym;

    /// Initializes blank instance.
    QuoteRequest39() {}

    /// Initializes instance over given memory block.
    QuoteRequest39(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Quote Request ID defined by the exchange.
    StrRef quoteReqId() const
    {
        const BlockLength offset = 8;
        const BlockLength length = 23;

        return fixedStr<length>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 31;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of RelatedSym repeating group.
    RelatedSym relatedSym() const
    {
        return groups().head<RelatedSym>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 32;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "QuoteRequest39";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("R");
    }
};

/// MDInstrumentDefinitionOption.
struct ONIXS_CMEMDH_LTWT InstrumentDefinitionOption55 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 55
    };

    /// Number of EventType entries.
    /// Entry of EventsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        EventsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Code to represent the type of event.
        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventType>(offset);
        }

        /// Date and Time of instument Activation or Expiration event
        /// sent as number of nanoseconds since Unix epoch.
        Timestamp eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<Timestamp>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.EventsEntry";
        }
    };

    /// Repeating group containing EventsEntry entries.
    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    /// Number of FeedType entries.
    /// Entry of FeedTypesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        FeedTypesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Describes a class of service for a given data feed. GBX-
        /// Real Book, GBI-Implied Book.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// Book depth.
        Int8 marketDepth() const
        {
            const BlockLength offset = 3;

            return ordinary<Int8>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.FeedTypesEntry";
        }
    };

    /// Repeating group containing FeedTypesEntry entries.
    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    /// Number of InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        InstAttribEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument Eligibility Attributes.
        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        /// Bitmap field of 32 Boolean type Instrument eligibility
        /// flags.
        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;

            return ordinary<InstAttribValue>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.InstAttribEntry";
        }
    };

    /// Repeating group containing InstAttribEntry entries.
    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    /// Number of entries.
    /// Entry of LotTypeRulesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        LotTypeRulesEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// This tag is required to interpret the value in tag
        /// 1231-MinLotSize.
        Int8 lotType() const
        {
            const BlockLength offset = 0;

            return ordinary<Int8>(offset);
        }

        /// Minimum quantity accepted for order entry. If tag
        /// 1093-LotType=4, this value is the minimum quantity for
        /// order entry expressed in the applicable units, specified
        /// in tag 996-UnitOfMeasure, e.g. megawatts.
        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;

            const BlockLength offset = 1;

            return decimal(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.LotTypeRulesEntry";
        }
    };

    /// Repeating group containing LotTypeRulesEntry entries.
    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    /// Number of underlying instruments.
    /// Entry of UnderlyingsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT UnderlyingsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        UnderlyingsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        UnderlyingsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique Instrument ID as qualified by the exchange per tag
        /// 305-UnderlyingSecurityIDSource.
        Int32 underlyingSecurityId() const
        {
            const BlockLength offset = 0;

            return ordinary<Int32>(offset);
        }

        /// This value is always '8' for CME.
        SecurityIDSource underlyingSecurityIdSource() const
        {
            return SecurityIDSource();
        }

        /// Underlying Instrument Symbol (Contract Name).
        StrRef underlyingSymbol() const
        {
            const BlockLength offset = 4;
            const BlockLength length = 20;

            return fixedStr<length>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 24;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.UnderlyingsEntry";
        }
    };

    /// Repeating group containing UnderlyingsEntry entries.
    typedef BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> Underlyings;

    /// Number of related instruments group.
    /// Entry of RelatedInstrumentsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT RelatedInstrumentsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        RelatedInstrumentsEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        RelatedInstrumentsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Related Security ID.
        Int32 relatedSecurityId() const
        {
            const BlockLength offset = 0;

            return ordinary<Int32>(offset);
        }

        /// Related Security ID source.
        SecurityIDSource relatedSecurityIdSource() const
        {
            return SecurityIDSource();
        }

        /// Related instrument Symbol.
        StrRef relatedSymbol() const
        {
            const BlockLength offset = 4;
            const BlockLength length = 20;

            return fixedStr<length>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 24;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.RelatedInstrumentsEntry";
        }
    };

    /// Repeating group containing RelatedInstrumentsEntry entries.
    typedef BinaryGroup<RelatedInstrumentsEntry, GroupSize, MessageSize> RelatedInstruments;

    /// Initializes blank instance.
    InstrumentDefinitionOption55() {}

    /// Initializes instance over given memory block.
    InstrumentDefinitionOption55(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 1;

        return ordinary(value, offset, Null());
    }

    /// Last Security update action on Incremental feed, 'D' or
    /// 'M' is used when a mid-week deletion or modification (i.e.
    /// extension) occurs.
    SecurityUpdateAction::Enum securityUpdateAction() const
    {
        const BlockLength offset = 5;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Timestamp of when the instrument was last added, modified
    /// or deleted.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;

        return ordinary<Timestamp>(offset);
    }

    /// Identifies the current state of the instrument. The data
    /// is available in the Instrument Replay feed only.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 14;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// The channel ID as defined in the XML Configuration file.
    Int16 applId() const
    {
        const BlockLength offset = 15;

        return ordinary<Int16>(offset);
    }

    /// Identifies the market segment, populated for all CME
    /// Globex instruments.
    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;

        return ordinary<UInt8>(offset);
    }

    /// Indicates the product complex.
    UInt8 underlyingProduct() const
    {
        const BlockLength offset = 18;

        return ordinary<UInt8>(offset);
    }

    /// Exchange used to identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Security Group Code.
    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// The underlying asset code also known as Product Code.
    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Instrument Name or Symbol. Previously used as Instrument
    /// Group Code.
    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Unique Instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 55;

        return ordinary<Int32>(offset);
    }

    /// Identifies class or source of tag 48-SecurityID value.
    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    /// Security Type.
    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// ISO standard instrument categorization code.
    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Indicates whether an option instrument is a put or call.
    PutOrCall::Enum putOrCall() const
    {
        const BlockLength offset = 71;

        return enumeration<PutOrCall>(offset);
    }

    /// This field provides the actual calendar date for contract
    /// maturity.
    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;

        const BlockLength offset = 72;

        return ordinary(value, offset, Null());
    }

    /// Identifies currency used for price.
    StrRef currency() const
    {
        const BlockLength offset = 77;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Strike Price for an option instrument.
    bool strikePrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 80;

        return decimal(value, offset, Null());
    }

    /// Currency in which the StrikePrice is denominated.
    StrRef strikeCurrency() const
    {
        const BlockLength offset = 88;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Identifies currency used for settlement, if different from
    /// trade price currency.
    StrRef settlCurrency() const
    {
        const BlockLength offset = 91;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Defines cabinet price for outright options products.
    bool minCabPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 94;

        return decimal(value, offset, Null());
    }

    /// Matching algorithm.
    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 102;

        return ordinary<CHAR>(offset);
    }

    /// The minimum trading volume for a security.
    UInt32 minTradeVol() const
    {
        const BlockLength offset = 103;

        return ordinary<UInt32>(offset);
    }

    /// The maximum trading volume for a security.
    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 107;

        return ordinary<UInt32>(offset);
    }

    /// Minimum constant tick for the instrument.
    bool minPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 111;

        return decimal(value, offset, Null());
    }

    /// Monetary value equivalent to the minimum price fluctuation.
    bool minPriceIncrementAmount(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 119;

        return decimal(value, offset, Null());
    }

    /// Contains the multiplier to convert the CME Globex display
    /// price to the conventional price.
    Decimal displayFactor() const
    {
        const BlockLength offset = 127;

        return decimal<Decimal9>(offset);
    }

    /// VTT code referencing variable tick table.
    bool tickRule(Int8& value) const
    {
        typedef NullInt8 Null;

        const BlockLength offset = 135;

        return ordinary(value, offset, Null());
    }

    /// Price Denominator of Main Fraction.
    bool mainFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 136;

        return ordinary(value, offset, Null());
    }

    /// Price Denominator of Sub Fraction.
    bool subFraction(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 137;

        return ordinary(value, offset, Null());
    }

    /// Number of decimals in fractional display price.
    bool priceDisplayFormat(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 138;

        return ordinary(value, offset, Null());
    }

    /// Unit of measure for the products' original contract size.
    /// This will be populated for all products listed on CME
    /// Globex.
    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 139;
        const BlockLength length = 30;

        return fixedStr<length>(offset);
    }

    /// This field contains the contract size for each instrument.
    /// Used in combination with tag 996-UnitofMeasure.
    bool unitOfMeasureQty(Decimal& value) const
    {
        typedef NullDecimal9 Null;

        const BlockLength offset = 169;

        return decimal(value, offset, Null());
    }

    /// Reference price - the most recently available Settlement
    /// whether it be Theoretical, Preliminary or a Final Settle
    /// of the session.
    bool tradingReferencePrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 177;

        return decimal(value, offset, Null());
    }

    /// Bitmap field of eight Boolean type indicators representing
    /// settlement price type.
    SettlPriceType settlPriceType() const
    {
        const BlockLength offset = 185;

        return ordinary<SettlPriceType>(offset);
    }

    /// The total cleared volume of instrument traded during the
    /// prior trading session.
    bool clearedVolume(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 186;

        return ordinary(value, offset, Null());
    }

    /// The total open interest for the market at the close of the
    /// prior trading session.
    bool openInterestQty(Int32& value) const
    {
        typedef NullInt32 Null;

        const BlockLength offset = 190;

        return ordinary(value, offset, Null());
    }

    /// Allowable low limit price for the trading day.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 194;

        return decimal(value, offset, Null());
    }

    /// Allowable high limit price for the trading day.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 202;

        return decimal(value, offset, Null());
    }

    /// User-defined instruments flag.
    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 210;

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// Indicates session date corresponding to the settlement
    /// price in tag 1150-TradingReferencePrice.
    bool tradingReferenceDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 211;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// External unique instrument ID.
    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 213;
        const SchemaVersion since = 10;

        return ordinary(value, offset, Null(), since);
    }

    /// Returns instance of Events repeating group.
    Events events() const
    {
        return groups().head<Events>();
    }

    /// Returns instance of FeedTypes repeating group.
    FeedTypes feedTypes() const
    {
        return groups().tail<Events>().head<FeedTypes>();
    }

    /// Returns instance of InstAttrib repeating group.
    InstAttrib instAttrib() const
    {
        return groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
    }

    /// Returns instance of LotTypeRules repeating group.
    LotTypeRules lotTypeRules() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
    }

    /// Returns instance of Underlyings repeating group.
    Underlyings underlyings() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().head<Underlyings>();
    }

    /// Returns instance of RelatedInstruments repeating group.
    RelatedInstruments relatedInstruments() const
    {
        return groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().tail<Underlyings>().head<RelatedInstruments>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 221;

        return 213;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionOption55";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

/// MDIncrementalRefreshTradeSummary.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummary48 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 48
    };

    /// Number of Trade Summary entries.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Trade price.
        Decimal entryPx() const
        {
            const BlockLength offset = 0;

            return decimal<PRICE9>(offset);
        }

        /// Consolidated trade quantity.
        Int32 entrySize() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

        /// Security ID as defined by CME.
        Int32 securityId() const
        {
            const BlockLength offset = 12;

            return ordinary<Int32>(offset);
        }

        /// Sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 16;

            return ordinary<UInt32>(offset);
        }

        /// The total number of real orders per instrument that
        /// participated in a match step within a match event.
        Int32 numberOfOrders() const
        {
            const BlockLength offset = 20;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is the aggressor or if there is no
        /// aggressor.
        bool aggressorSide(AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 24;

            return enumeration<AggressorSide>(value, offset, Null());
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 25;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        /// Market Data Trade entry ID.
        bool tradeEntryId(UInt32& value) const
        {
            typedef NullUInt32 Null;

            const BlockLength offset = 26;

            return ordinary(value, offset, Null());
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 30;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummary48.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Number of OrderID entries.
    /// Entry of OrderIDEntry repeating group.
    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize8Byte::BlockLength> Base;

        /// Initializes blank instance.
        OrderIDEntry() {}

        /// Initializes instance of given
        /// version over given memory block.
        OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique order identifier as assigned by the exchange.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Quantity bought or sold on this last fill.
        Int32 lastQty() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 12;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummary48.OrderIDEntry";
        }
    };

    /// Repeating group containing OrderIDEntry entries.
    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    /// Initializes blank instance.
    IncrementalRefreshTradeSummary48() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshTradeSummary48(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Returns instance of OrderIDEntries repeating group.
    OrderIDEntries orderIdEntries() const
    {
        return groups().tail<Entries>().head<OrderIDEntries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshTradeSummary48";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshOrderBook.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshOrderBook47 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 47
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Order ID.
        bool orderId(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 0;

            return ordinary(value, offset, Null());
        }

        /// Order priority for execution on the order book.
        bool orderPriority(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Order price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 16;

            return decimal(value, offset, Null());
        }

        /// Visible order qty.
        bool displayQty(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 24;

            return ordinary(value, offset, Null());
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 28;

            return ordinary<Int32>(offset);
        }

        /// Order book update action to be applied to the order
        /// referenced by OrderID.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 32;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeBook::Enum entryType() const
        {
            const BlockLength offset = 33;

            return enumeration<EntryTypeBook>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 34;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshOrderBook47.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    IncrementalRefreshOrderBook47() {}

    /// Initializes instance over given memory block.
    IncrementalRefreshOrderBook47(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshOrderBook47";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// SnapshotFullRefreshOrderBook.
struct ONIXS_CMEMDH_LTWT SnapshotFullRefreshOrderBook53 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum
    {
        TemplateId = 53
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type.
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        /// Initializes blank instance.
        Entry() {}

        /// Initializes instance of given
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique Order ID.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Order priority for execution on the order book.
        bool orderPriority(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Order Price.
        Decimal entryPx() const
        {
            const BlockLength offset = 16;

            return decimal<PRICE9>(offset);
        }

        /// Visible order qty.
        Int32 displayQty() const
        {
            const BlockLength offset = 24;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry type.
        EntryTypeBook::Enum entryType() const
        {
            const BlockLength offset = 28;

            return enumeration<EntryTypeBook>(offset);
        }

        /// Returns size of entry body in bytes
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 29;
        }

        /// Entity class name.
        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "SnapshotFullRefreshOrderBook53.Entry";
        }
    };

    /// Repeating group containing Entry entries.
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance.
    SnapshotFullRefreshOrderBook53() {}

    /// Initializes instance over given memory block.
    SnapshotFullRefreshOrderBook53(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Sequence number of the last Incremental feed packet
    /// processed. This value is used to synchronize the snapshot
    /// loop with the real-time feed.
    UInt32 lastMsgSeqNumProcessed() const
    {
        const BlockLength offset = 0;

        return ordinary<UInt32>(offset);
    }

    /// Total number of instruments in the replayed loop.
    UInt32 totNumReports() const
    {
        const BlockLength offset = 4;

        return ordinary<UInt32>(offset);
    }

    /// Security ID.
    Int32 securityId() const
    {
        const BlockLength offset = 8;

        return ordinary<Int32>(offset);
    }

    /// Total number of packets that constitutes a single
    /// instrument order book.
    UInt32 chunks() const
    {
        const BlockLength offset = 12;

        return ordinary<UInt32>(offset);
    }

    /// Chunk sequence.
    UInt32 currentChunk() const
    {
        const BlockLength offset = 16;

        return ordinary<UInt32>(offset);
    }

    /// Timestamp of the last event security participated in, sent
    /// as number of nanoseconds since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 20;

        return ordinary<Timestamp>(offset);
    }

    /// Returns instance of Entries repeating group.
    Entries entries() const
    {
        return groups().head<Entries>();
    }

    /// Size of message body in bytes.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 28;
    }

    /// Returns class name.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "SnapshotFullRefreshOrderBook53";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED
    static StrRef fixType()
    {
        return toStrRef("W");
    }
};

/// MDInstrumentDefinitionFX.
struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFX63 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 63 
    };

    /// Number of EventType entries.
    /// Entry of EventsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        EventsEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        EventsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Code to represent the type of event.
        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventType>(offset);
        }

        /// Date and Time of instument Activation or Expiration event
        /// sent as number of nanoseconds since Unix epoch.
        Timestamp eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<Timestamp>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.EventsEntry";
        }
    };

    /// Repeating group containing EventsEntry entries. 
    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    /// Number of FeedType entries.
    /// Entry of FeedTypesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        FeedTypesEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        FeedTypesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Describes a class of service for a given data feed.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// Book depth.
        Int8 marketDepth() const
        {
            const BlockLength offset = 3;

            return ordinary<Int8>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.FeedTypesEntry";
        }
    };

    /// Repeating group containing FeedTypesEntry entries. 
    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    /// Number of InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        InstAttribEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        InstAttribEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Instrument eligibility attributes.
        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        /// Bitmap field of 32 Boolean type instrument eligibility
        /// flags.
        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;

            return ordinary<InstAttribValue>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.InstAttribEntry";
        }
    };

    /// Repeating group containing InstAttribEntry entries. 
    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    /// Number of LotTypeRules entries.
    /// Entry of LotTypeRulesEntry repeating group.
    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        LotTypeRulesEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        LotTypeRulesEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// This tag is required to interpret the value in tag
        /// 1231-MinLotSize.
        Int8 lotType() const
        {
            const BlockLength offset = 0;

            return ordinary<Int8>(offset);
        }

        /// For FX instruments in the repeating group with Tag
        /// 1093-LotType=2, Tag 1231-MinLotSize provides a Regular
        /// Amount - a default order size on the Workstation screen.
        /// With tag 1093-LotType= 5, Tag 1231-MinLotSize value
        /// represents standard min order qty increment.  With  tag
        /// 1093-LotType=6 tag 1231-MinLotSize contains
        /// SizePriorityQty for instruments trading with Match
        /// Algorithm = P (Size Priority).
        UInt64 minLotSize() const
        {
            const BlockLength offset = 1;

            return ordinary<UInt64>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.LotTypeRulesEntry";
        }
    };

    /// Repeating group containing LotTypeRulesEntry entries. 
    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    /// Number of scheduled Trading Dates.
    /// Entry of TradingSessionsEntry repeating group.
    struct ONIXS_CMEMDH_LTWT TradingSessionsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        TradingSessionsEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        TradingSessionsEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Trade Date.
        bool tradeDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 0;

            FieldValue fieldValue;

            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        /// Settle (Value) Date corresponding to Trade Date.
        bool settlDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 2;

            FieldValue fieldValue;

            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        /// For Spot instruments will not contain the value. For NDFs,
        /// the valuation (fixing) date of the NDF.  For Fixed Date
        /// NDFs Value Date and Maturity Date remain constant for all
        /// Trade Dates.
        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 4;

            FieldValue fieldValue;

            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        /// ISIN value as provided by ANNA, Association of National
        /// Numbering Agencies. This field is populated for MTF-
        /// Regulated NDFs and is unique for each Settle Date.
        StrRef securityAltId() const
        {
            const BlockLength offset = 6;
            const BlockLength length = 12;
            const SchemaVersion since = 10;

            return fixedStr<length>(offset, since);
        }

        /// Identifies class or source of the SecurityAltID (455)
        /// value.
        SecurityAltIDSourceISIN securityAltIdSource() const
        {
            return SecurityAltIDSourceISIN();
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion version)
        {
            if (version >= 10)
                return 18;

            return 6;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.TradingSessionsEntry";
        }
    };

    /// Repeating group containing TradingSessionsEntry entries. 
    typedef BinaryGroup<TradingSessionsEntry, GroupSize, MessageSize> TradingSessions;

    /// Initializes blank instance. 
    InstrumentDefinitionFX63() {}

    /// Initializes instance over given memory block. 
    InstrumentDefinitionFX63(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 1;

        return ordinary(value, offset, Null());
    }

    /// Last Security update action on Incremental feed, 'D' or
    /// 'M' is used when a mid-week deletion or modification (i.e.
    /// extension) occurs.
    SecurityUpdateAction::Enum securityUpdateAction() const
    {
        const BlockLength offset = 5;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Timestamp of when the instrument was last added, modified
    /// or deleted.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;

        return ordinary<Timestamp>(offset);
    }

    /// Identifies the current state of the instrument. In
    /// Security Definition message this tag is available in the
    /// Instrument Replay feed only.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 14;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// The channel ID as defined in the XML Configuration file.
    Int16 applId() const
    {
        const BlockLength offset = 15;

        return ordinary<Int16>(offset);
    }

    /// Identifies the market segment, populated for all CME
    /// Globex instruments.
    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;

        return ordinary<UInt8>(offset);
    }

    /// Product complex.
    UInt8 underlyingProduct() const
    {
        const BlockLength offset = 18;

        return ordinary<UInt8>(offset);
    }

    /// Exchange used to identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Security Group Code.
    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// The underlying asset code also known as Product Code.
    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Instrument Name or Symbol.
    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Unique instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 55;

        return ordinary<Int32>(offset);
    }

    /// Identifies class or source of tag 48-SecurityID value.
    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    /// Security Type.
    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// ISO standard instrument categorization code.
    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;

        return fixedStr<length>(offset);
    }

    /// Base currency.
    StrRef currency() const
    {
        const BlockLength offset = 71;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Currency used for settlement, which may be different from
    /// Local currency specified in Tag 1524 PriceQuoteCurrency.
    StrRef settlCurrency() const
    {
        const BlockLength offset = 74;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Local (counter) currency.
    StrRef priceQuoteCurrency() const
    {
        const BlockLength offset = 77;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Matching algorithm.
    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 80;

        return ordinary<CHAR>(offset);
    }

    /// The minimum trading volume for a security.
    UInt32 minTradeVol() const
    {
        const BlockLength offset = 81;

        return ordinary<UInt32>(offset);
    }

    /// The maximum trading volume for a security.
    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 85;

        return ordinary<UInt32>(offset);
    }

    /// Minimum price tick.
    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 89;

        return decimal<PRICE9>(offset);
    }

    /// Contains the multiplier to convert the CME Globex display
    /// price to the conventional price.
    Decimal displayFactor() const
    {
        const BlockLength offset = 97;

        return decimal<Decimal9>(offset);
    }

    /// Specifies price decimal precision for EBS instrument.
    UInt8 pricePrecision() const
    {
        const BlockLength offset = 105;

        return ordinary<UInt8>(offset);
    }

    /// Unit of measure for the products' original contract size.
    /// This will be populated for all products listed on CME
    /// Globex.
    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 106;
        const BlockLength length = 30;

        return fixedStr<length>(offset);
    }

    /// This field contains the contract size for each instrument.
    /// Used in combination with tag 996-UnitofMeasure.
    bool unitOfMeasureQty(Decimal& value) const
    {
        typedef NullDecimal9 Null;

        const BlockLength offset = 136;

        return decimal(value, offset, Null());
    }

    /// Allowable high limit price for the trading day.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 144;

        return decimal(value, offset, Null());
    }

    /// Allowable low limit price for the trading day.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 152;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 160;

        return decimal(value, offset, Null());
    }

    /// User-defined instruments flag.
    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 168;

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// EBS instrument long name.
    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 169;
        const BlockLength length = 35;

        return fixedStr<length>(offset);
    }

    /// Base/Local. Denotes the currency pair in CCY1/CCY2
    /// convention.
    StrRef fxCurrencySymbol() const
    {
        const BlockLength offset = 204;
        const BlockLength length = 7;

        return fixedStr<length>(offset);
    }

    /// For SPOTs will contain 0. For Fixed date NDFs will contain
    /// the value 'B'. For the standard NDFs tenors expressed
    /// using Dx, Mx, Wx, and Yx values, where 'x' does not denote
    /// business days, but calendar days.
    StrRef settlType() const
    {
        const BlockLength offset = 211;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// For SPOT, number of business days between trade date and
    /// value (settlement) date. For NDF, number of business days
    /// between NDF valuation (fixing) and settlement.
    UInt16 interveningDays() const
    {
        const BlockLength offset = 214;

        return ordinary<UInt16>(offset);
    }

    /// Fixing Rate Description.
    StrRef fxBenchmarkRateFix() const
    {
        const BlockLength offset = 216;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Source.
    StrRef rateSource() const
    {
        const BlockLength offset = 236;
        const BlockLength length = 12;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Local Time, denoted in HH:MM:SS format.
    StrRef fixRateLocalTime() const
    {
        const BlockLength offset = 248;
        const BlockLength length = 8;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Local Time Zone corresponding to Fixing Local
    /// Time.
    StrRef fixRateLocalTimeZone() const
    {
        const BlockLength offset = 256;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Minimum Quote Life in number of microseconds.
    UInt32 minQuoteLife() const
    {
        const BlockLength offset = 276;

        return ordinary<UInt32>(offset);
    }

    /// Max allowed discretionary offset from Limit order price.
    /// When the value in this field = 0, discretionary price
    /// cannot be submitted for the instrument.
    Decimal maxPriceDiscretionOffset() const
    {
        const BlockLength offset = 280;

        return decimal<PRICE9>(offset);
    }

    /// External unique instrument ID.
    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 288;

        return ordinary(value, offset, Null());
    }

    /// Fixed Date NDF Maturity.
    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;

        const BlockLength offset = 296;

        return ordinary(value, offset, Null());
    }

    /// Settlement Locale. Optionally used to differentiate
    /// settlement location.
    StrRef settlementLocale() const
    {
        const BlockLength offset = 301;
        const BlockLength length = 8;

        return fixedStr<length>(offset);
    }

    /// New sub-tick which is only available for order entry when
    /// certain conditions are met, tick value which corresponds
    /// to the Alt Min Quote Life.
    bool altMinPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 309;
        const SchemaVersion since = 13;

        return decimal(value, offset, Null(), since);
    }

    /// MQL duration in number of microseconds applied to orders
    /// at AltMinPriceIncrement.
    bool altMinQuoteLife(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 317;
        const SchemaVersion since = 13;

        return ordinary(value, offset, Null(), since);
    }

    /// Minimum price offset better than the best Standard Tick
    /// order for an order to be allowed into the market.
    bool altPriceIncrementConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 321;
        const SchemaVersion since = 13;

        return decimal(value, offset, Null(), since);
    }

    /// Maximum bid/ask spread for which sub-tick orders will be
    /// accepted (Sub tick orders will be rejected if bid/ask
    /// spread is greater than this value).
    bool maxBidAskConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 329;
        const SchemaVersion since = 13;

        return decimal(value, offset, Null(), since);
    }

    /// Returns instance of Events repeating group. 
    Events events() const
    {
        return     groups().head<Events>();
    }

    /// Returns instance of FeedTypes repeating group. 
    FeedTypes feedTypes() const
    {
        return     groups().tail<Events>().head<FeedTypes>();
    }

    /// Returns instance of InstAttrib repeating group. 
    InstAttrib instAttrib() const
    {
        return     groups().tail<Events>().tail<FeedTypes>().head<InstAttrib>();
    }

    /// Returns instance of LotTypeRules repeating group. 
    LotTypeRules lotTypeRules() const
    {
        return     groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().head<LotTypeRules>();
    }

    /// Returns instance of TradingSessions repeating group. 
    TradingSessions tradingSessions() const
    {
        return     groups().tail<Events>().tail<FeedTypes>().tail<InstAttrib>().tail<LotTypeRules>().head<TradingSessions>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 13)
            return 337;

        if (version >= 12)
            return 309;

        if (version >= 10)
            return 204;

        return 169;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "InstrumentDefinitionFX63";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

/// MDIncrementalRefreshBookLongQty.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshBookLongQty64 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 64 
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        Entry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Aggregate booked qty at price level, notional.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// SecurityID.
        Int32 securityId() const
        {
            const BlockLength offset = 16;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 20;

            return ordinary<UInt32>(offset);
        }

        /// In Book entry - aggregate number of orders at given price
        /// level.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 24;

            return ordinary(value, offset, Null());
        }

        /// Aggregate book level.
        UInt8 priceLevel() const
        {
            const BlockLength offset = 28;

            return ordinary<UInt8>(offset);
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 29;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeBook::Enum entryType() const
        {
            const BlockLength offset = 30;

            return enumeration<EntryTypeBook>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 31;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshBookLongQty64.Entry";
        }
    };

    /// Repeating group containing Entry entries. 
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Number of OrderID entries.
    /// Entry of OrderIDEntry repeating group.
    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize8Byte::BlockLength> Base;

        /// Initializes blank instance. 
        OrderIDEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique Order ID.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Order priority for execution on the order book.
        bool orderPriority(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Visible qty of order.
        bool displayQty(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 16;

            return ordinary(value, offset, Null());
        }

        /// Reference to corresponding Price and SecurityID, sequence
        /// of MD entry in the message.
        bool referenceId(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 20;

            return ordinary(value, offset, Null());
        }

        /// Order book update action to be applied to the order
        /// referenced by OrderID.
        OrderUpdateAction::Enum orderUpdateAction() const
        {
            const BlockLength offset = 21;

            return enumeration<OrderUpdateAction>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 22;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshBookLongQty64.OrderIDEntry";
        }
    };

    /// Repeating group containing OrderIDEntry entries. 
    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    /// Initializes blank instance. 
    IncrementalRefreshBookLongQty64() {}

    /// Initializes instance over given memory block. 
    IncrementalRefreshBookLongQty64(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group. 
    Entries entries() const
    {
        return     groups().head<Entries>();
    }

    /// Returns instance of OrderIDEntries repeating group. 
    OrderIDEntries orderIdEntries() const
    {
        return     groups().tail<Entries>().head<OrderIDEntries>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshBookLongQty64";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshTradeSummaryLongQty.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummaryLongQty65 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 65 
    };

    /// Number of Trade Summary entries.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        Entry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Trade price.
        Decimal entryPx() const
        {
            const BlockLength offset = 0;

            return decimal<PRICE9>(offset);
        }

        /// Consolidated trade quantity, notional.
        UInt64 entrySize() const
        {
            const BlockLength offset = 8;

            return ordinary<UInt64>(offset);
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 16;

            return ordinary<Int32>(offset);
        }

        /// MD Entry sequence number per instrument update. Reset
        /// weekly.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 20;

            return ordinary<UInt32>(offset);
        }

        /// The total number of real orders per instrument that
        /// participated in a match step within a match event.
        Int32 numberOfOrders() const
        {
            const BlockLength offset = 24;

            return ordinary<Int32>(offset);
        }

        /// Market Data Trade Entry ID.
        UInt32 tradeEntryId() const
        {
            const BlockLength offset = 28;

            return ordinary<UInt32>(offset);
        }

        /// Indicates which side is the aggressor or if there is no
        /// aggressor.
        bool aggressorSide(AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 32;

            return enumeration<AggressorSide>(value, offset, Null());
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 33;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 34;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummaryLongQty65.Entry";
        }
    };

    /// Repeating group containing Entry entries. 
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Number of OrderID and LastQty entries in Trade Summary
    /// message.
    /// Entry of OrderIDEntry repeating group.
    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize8Byte::BlockLength> Base;

        /// Initializes blank instance. 
        OrderIDEntry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        OrderIDEntry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Unique order identifier as assigned by the exchange.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Quantity bought or sold on this last fill.
        Int32 lastQty() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 12;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummaryLongQty65.OrderIDEntry";
        }
    };

    /// Repeating group containing OrderIDEntry entries. 
    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    /// Initializes blank instance. 
    IncrementalRefreshTradeSummaryLongQty65() {}

    /// Initializes instance over given memory block. 
    IncrementalRefreshTradeSummaryLongQty65(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group. 
    Entries entries() const
    {
        return     groups().head<Entries>();
    }

    /// Returns instance of OrderIDEntries repeating group. 
    OrderIDEntries orderIdEntries() const
    {
        return     groups().tail<Entries>().head<OrderIDEntries>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshTradeSummaryLongQty65";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshVolumeLongQty.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshVolumeLongQty66 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 66 
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        Entry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Cumulative traded volume, notional.
        UInt64 entrySize() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

        /// Market Data entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 12;

            return ordinary<UInt32>(offset);
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 16;

            return enumeration<UpdateAction>(offset);
        }

        /// Electronic Volume entry provides cumulative session trade
        /// volume updated with the event.
        EntryTypeVol entryType() const
        {
            return EntryTypeVol();
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 17;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshVolumeLongQty66.Entry";
        }
    };

    /// Repeating group containing Entry entries. 
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance. 
    IncrementalRefreshVolumeLongQty66() {}

    /// Initializes instance over given memory block. 
    IncrementalRefreshVolumeLongQty66(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group. 
    Entries entries() const
    {
        return     groups().head<Entries>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshVolumeLongQty66";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// MDIncrementalRefreshSessionStatisticsLongQty.
struct ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatisticsLongQty67 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 67 
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        Entry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        Decimal entryPx() const
        {
            const BlockLength offset = 0;

            return decimal<PRICE9>(offset);
        }

        /// Indicative Opening Quantity.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// Security ID.
        Int32 securityId() const
        {
            const BlockLength offset = 16;

            return ordinary<Int32>(offset);
        }

        /// MD Entry sequence number per instrument update.
        UInt32 rptSeq() const
        {
            const BlockLength offset = 20;

            return ordinary<UInt32>(offset);
        }

        /// Flag that additionally describes market data entry type.
        bool openCloseSettlFlag(OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 24;

            return enumeration<OpenCloseSettlFlag>(value, offset, Null());
        }

        /// Market Data update action.
        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 25;

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data entry type.
        EntryTypeStatistics::Enum entryType() const
        {
            const BlockLength offset = 26;

            return enumeration<EntryTypeStatistics>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 27;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshSessionStatisticsLongQty67.Entry";
        }
    };

    /// Repeating group containing Entry entries. 
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance. 
    IncrementalRefreshSessionStatisticsLongQty67() {}

    /// Initializes instance over given memory block. 
    IncrementalRefreshSessionStatisticsLongQty67(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 0;

        return ordinary<Timestamp>(offset);
    }

    /// Bitmap field of eight Boolean type indicators reflecting
    /// the end of updates for a given Globex event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Returns instance of Entries repeating group. 
    Entries entries() const
    {
        return     groups().head<Entries>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshSessionStatisticsLongQty67";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

/// SnapshotFullRefreshLongQty.
struct ONIXS_CMEMDH_LTWT SnapshotFullRefreshLongQty69 : BinaryMessage
{
    /// Message template ID from SBE schema.
    enum 
    {
        TemplateId = 69 
    };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        /// Aliases base class type. 
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        /// Initializes blank instance. 
        Entry() {}

        /// Initializes instance of given 
        /// version over given memory block.
        Entry(const void* data, EncodedLength length, SchemaVersion version)
            : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        /// Market Data entry price.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;

            const BlockLength offset = 0;

            return decimal(value, offset, Null());
        }

        /// Market Data entry size.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

            return ordinary(value, offset, Null());
        }

        /// In Book Entry - Aggregate number of orders at given price
        /// level. In Trade Entry - a total number of real orders per
        /// instrument that participated in a match step within a
        /// match event.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 16;

            return ordinary(value, offset, Null());
        }

        /// Aggregate book level.
        bool priceLevel(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 20;

            return ordinary(value, offset, Null());
        }

        /// Flag that additionally describes a market data entry.
        bool openCloseSettlFlag(OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 21;

            return enumeration<OpenCloseSettlFlag>(value, offset, Null());
        }

        /// Market Data entry type.
        EntryType::Enum entryType() const
        {
            const BlockLength offset = 22;

            return enumeration<EntryType>(offset);
        }

        /// Returns size of entry body in bytes 
        /// for given version of message template.
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 23;
        }

        /// Entity class name. 
        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "SnapshotFullRefreshLongQty69.Entry";
        }
    };

    /// Repeating group containing Entry entries. 
    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    /// Initializes blank instance. 
    SnapshotFullRefreshLongQty69() {}

    /// Initializes instance over given memory block. 
    SnapshotFullRefreshLongQty69(const void* data, EncodedLength length)
        : BinaryMessage(data, length, 12)
    {
        assert(TemplateId == templateId());

        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    /// Sequence number of the last Incremental feed packet
    /// processed. This value is used to synchronize the snapshot
    /// loop with the real-time feed.
    UInt32 lastMsgSeqNumProcessed() const
    {
        const BlockLength offset = 0;

        return ordinary<UInt32>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    UInt32 totNumReports() const
    {
        const BlockLength offset = 4;

        return ordinary<UInt32>(offset);
    }

    /// Unique instrument ID.
    Int32 securityId() const
    {
        const BlockLength offset = 8;

        return ordinary<Int32>(offset);
    }

    /// MD Entry sequence number per instrument update. Reset
    /// weekly.
    UInt32 rptSeq() const
    {
        const BlockLength offset = 12;

        return ordinary<UInt32>(offset);
    }

    /// Timestamp of the last event security participated in, sent
    /// as number of nanoseconds since Unix epoch.
    Timestamp transactTime() const
    {
        const BlockLength offset = 16;

        return ordinary<Timestamp>(offset);
    }

    /// UTC Date and time of last Security Definition add, update
    /// or delete on a given Market Data channel.
    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 24;

        return ordinary<Timestamp>(offset);
    }

    /// Trade session date sent as number of days since Unix epoch.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 32;

        FieldValue fieldValue;

        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

    /// Identifies the current trading state of the instrument.
    bool securityTradingStatus(SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 34;

        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    /// Upper price threshold for the instrument. Orders submitted
    /// with prices above the upper limit will be rejected.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 35;

        return decimal(value, offset, Null());
    }

    /// Lower price threshold for the instrument. Orders submitted
    /// with prices below the lower limit will be rejected.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 43;

        return decimal(value, offset, Null());
    }

    /// Differential value for price banding.
    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 51;

        return decimal(value, offset, Null());
    }

    /// Returns instance of Entries repeating group. 
    Entries entries() const
    {
        return     groups().head<Entries>();
    }

    /// Size of message body in bytes. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 59;
    }

    /// Returns class name. 
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "SnapshotFullRefreshLongQty69";
    }

    /// FIX message type.
    ONIXS_CMEMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("W");
    }
};


ONIXS_CMEMDH_NAMESPACE_END