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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = 10;

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        if (length < blockLength(current))
            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;
        const SchemaVersion since = 10;

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

    /// 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;
        const SchemaVersion since = 10;

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

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

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

    /// 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;
        const SchemaVersion since = 10;

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

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

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

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

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

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

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

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

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

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

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

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

    /// 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;
        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 = 324;
        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 = 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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();

        const SchemaVersion since = SchemaTraits::minimalTcpRecoveryVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();

        const SchemaVersion since = SchemaTraits::minimalTcpRecoveryVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();

        const SchemaVersion since = SchemaTraits::minimalTcpRecoveryVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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)
    {
        assert(TemplateId == templateId());

        const SchemaVersion current = version();
        const SchemaVersion since = SchemaTraits::minimalVersion();

        if (current < since)
            throwBadMessageVersion(className(), current, since);

        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