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/Streamlined/Composites.h>
#include <OnixS/CME/Streamlined/BinaryMessage.h>

ONIXS_CMESTREAMLINEDMDH_NAMESPACE_BEGIN

/// AdminHeartbeat.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminHeartbeat312 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 312 };

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

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

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

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

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

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

/// AdminLogin.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminLogin315 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 315 };

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

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

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

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

        return ordinary<Int8>(offset);
    }

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

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

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

/// AdminLogout.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminLogout316 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 316 };

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

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

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

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

        return fixedStr<length>(offset);
    }

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

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

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

/// MDIncrementalRefreshErisReferenceDataAndDailyStatistics.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshErisReferenceDataAndDailyStatistics333 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 333 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of entries in AltID group.
        /// Entry of SecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Expanded instrument description.
            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;

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

            /// Identifies class or source of the SecurityAltID (455)
            /// value.
            bool securityAltIdSource(CharNULL& value) const
            {
                typedef NullCharNULL Null;

                const BlockLength offset = 26;

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

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.SecurityAltIDEntry";
            }
        };

        /// Repeating group containing SecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        /// Number of related instruments group.
        /// Entry of RelatedInstrumentsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// The type of instrument relationship.
            bool relatedInstrumentType(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 0;

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

            /// Related instrument Symbol.
            bool relatedSymbol(StrRef& value) const
            {
                const BlockLength offset = 1;
                const BlockLength length = 50;

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

            /// Instrument Symbol Suffix for T+1 (Next Trading day).
            bool relatedSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 51;
                const BlockLength length = 26;

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

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

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

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

        /// Number of repeating EventType entries.
        /// Entry of EventsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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.
            bool eventType(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 0;

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

            /// Time of event. This is number of days since unix epoch.
            bool eventTime(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 1;

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

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

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

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

        /// Indicates the type of Market Data update action.
        CHAR updateAction() const
        {
            const BlockLength offset = 0;

            return ordinary<CHAR>(offset);
        }

        /// Indicates the type of Market Data entry.
        CHAR entryType() const
        {
            const BlockLength offset = 1;

            return ordinary<CHAR>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 6;

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

        /// Flag that identifies a market data entry.
        bool openCloseSettlFlag(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 15;

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

        /// Indicates reference price as calculated, final or
        /// preliminary settle.
        SettlPriceType settlPriceType() const
        {
            const BlockLength offset = 16;

            return ordinary<SettlPriceType>(offset);
        }

        /// Calculated Futures Price using Swap NPV, Historical fixed
        /// and floating amounts and synthetic interest on variation
        /// margin.
        bool calFutPx(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 17;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 26;
            const BlockLength length = 50;

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

        /// Quantity or volume represented by the Market Data Entry.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 76;

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

        /// Instrument, Index, Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 134;
            const BlockLength length = 26;

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

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 160;

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

        /// Indicates type of security.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 161;
            const BlockLength length = 9;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 170;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

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

            const BlockLength offset = 174;

            FieldValue fieldValue;

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

        /// The rate of the fixed leg.
        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32NULL Null;

            const BlockLength offset = 176;

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

        /// Pricing date.
        bool tradeDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 181;

            FieldValue fieldValue;

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

        /// Shows the coupon rate that would result in a zero-NPV swap.
        bool fairCouponPct(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 183;

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

        /// The date the floating rate was set for the next floating
        /// payment.
        bool legPurchaseRate(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 192;

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

        /// The NPV (Net Present Value) for the fixed leg of the
        /// trade, calculated that day. NPV is per 100 notional.
        bool fixedNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 201;

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

        /// The NPV (Net Present Value) for the floating leg of the
        /// trade, calculated that day. NPV is per 100 notional.
        bool floatNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 210;

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

        /// The NPV represents net present value of the future cash
        /// flows at time t.
        bool npv(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 219;

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

        /// This value represents accumulated fixed and floating
        /// amounts.
        bool accruedCoupons(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 228;

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

        /// This number represents the day over day variation margin
        /// for 1 contract for this instrument ID or Eris PAI.
        bool dailyIncrementalErisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 237;

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

        /// This is the cumulative daily interest adjustment.
        bool erisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 246;

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

        /// The Fed Funds Rate published for the Fed Funds Date by the
        /// New York Federal Reserve.
        bool fedFundsRate(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 255;

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

        /// Minimum tick for a product (only sent if not eligible for
        /// VTT).
        bool minPriceIncrement(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 264;

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

        /// Fixed payment that occurs on the Evaluation Date.
        bool fixedPayment(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 273;

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

        /// Floating Payment that occurs on the Evaulation Date.
        bool floatingPayment(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 282;

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

        /// The date the next fixed payment will be made.
        bool nextFixedPaymentDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 291;

            FieldValue fieldValue;

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

        /// The next fixed payment amount.
        bool nextFixedPaymentAmount(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 293;

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

        /// The next floating payment amount.
        bool nextFloatingPaymentAmount(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 302;

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

        /// Indicates the business date for previous settlement price.
        bool tradingReferenceDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 311;

            FieldValue fieldValue;

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

        /// The Eris PAI on the Previous Settlement Date.
        bool previousErisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 313;

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

        /// The date that the for which the fed funds date was
        /// published.
        bool fedFundsDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 322;

            FieldValue fieldValue;

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

        /// How many days have passed since settlement price was last
        /// calculated.
        bool accrualDays(UInt32& value) const
        {
            typedef NullUInt32 Null;

            const BlockLength offset = 324;

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

        /// This is the notional value used to calculate NPV and Fixed
        /// and Floating Payment amounts.
        bool minal(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 328;

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

        /// Description of Float Rate.
        bool legCreditRating(StrRef& value) const
        {
            const BlockLength offset = 336;
            const BlockLength length = 6;

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

        /// Multiplier that when applied on longer rate results in
        /// PreviousFixingRate.
        bool legContractMultiplier(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 342;

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

        /// The date the next floating payment will be made.
        bool nextFloatingPaymentDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 351;

            FieldValue fieldValue;

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

        /// The present value of a 1bp change in the fixed rate.
        bool pV01(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 353;

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

        /// Present value of on basis points change in value if yield
        /// curve shifts 1bp.
        bool dV01(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 362;

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

        /// Final Settlement Price in NPV terms.
        bool settlementNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 371;

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

        /// Final Settlement Futures Prices.
        bool finalSettlementFuturesPrice(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 380;

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

        /// Ticker symbol. Common, &amp;quot;human
        /// understood&amp;quot; representation of the security.
        bool securityDescription(StrRef& value) const
        {
            const BlockLength offset = 389;
            const BlockLength length = 30;

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

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

        /// Returns instance of RelatedInstruments repeating group. 
        RelatedInstruments relatedInstruments() const
        {
            return
                groups().
                    tail<SecurityAltID>().
                    head<RelatedInstruments>();
        }

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

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 9;

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

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

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

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

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

/// MDNewsIndices.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
NewsIndices339 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 339 };

    /// Specifies the number of repeating symbols specified.
    /// Entry of RelatedSymEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// A specific moniter assigned to a group of related
        /// securities which may be concurrently affected by market
        /// events and actions. Falcon ignores the incoming value
        /// except when null and returns back the correct one in the
        /// outgoing execution report.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 50;

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

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

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

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

    /// Identifies number of lines of text body.
    /// Entry of LinesOfTextEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    LinesOfTextEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

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

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

        /// This general purpose text field could contain any post-
        /// trade instructions used by customers based on mutual
        /// understanding with their clearing firm. If incoming value
        /// is greater than max length then take the right most fifty
        /// bytes. No validation is done for valid values and this is
        /// a pass through to clearing. After any right justification
        /// if applicable the incoming value is flipped back in the
        /// execution report and also becomes an attribute of the
        /// order.
        StrRef text() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 500;

            return fixedStr<length>(offset);
        }

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

        /// Entity class name. 
        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "NewsIndices339.LinesOfTextEntry";
        }
    };

    /// Repeating group containing LinesOfTextEntry entries. 
    typedef 
    BinaryGroup<LinesOfTextEntry, GroupSize, MessageSize> 
    LinesOfText;

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

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

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

    /// The headline of a News  message.
    bool headline(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 50;

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

    /// Time of message origination expressed as number of
    /// nanoseconds since unix epoch.
    bool origTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 50;

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

    /// Describes a class of service for a given data feed.
    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 58;
        const BlockLength length = 2;

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

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

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

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

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

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

/// MDIncrementalRefreshTradeBlocks.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks340 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 340 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of underlying legs that make up the security.
        /// Entry of UnderlyingsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// Underlying Security's symbol.
            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Underlying Security's MaturityMonthYear.
            bool underlyingMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 50;

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

            /// Underlying Security's SecurityType.
            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;

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

            /// Underlying Security's SecurityExchange.
            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;

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

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

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

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

        /// Number of party roles.
        /// Entry of PartyIDsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Party identifier/code.
            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Identifies the type or role of the PartyID specified.
            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;

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

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.PartyIDsEntry";
            }
        };

        /// Repeating group containing PartyIDsEntry entries. 
        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        /// Number of legs (repeating groups).
        /// Entry of LegsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// This tag contains the instrument group of the requested
            /// security definition. Must be present when tag 555-NoLegs
            /// is present. Also must be first tag in repeating group.
            /// Multileg instrument's individual security's Symbol.
            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Multileg instrument's individual security's SecurityID.
            bool legSecurityId(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 50;

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

            /// Identifies source of tag 602-LegSecurityID value. This
            /// value is always 'H' for CME.
            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
            /// 'product code').
            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;

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

            /// Used to correlate leg instrument definitions with their
            /// executions.Cross referenced in Tag 654.
            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;

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

            /// Identifies the type of leg instrument.
            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;

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

            /// Multileg instrument's individual security's leg
            /// MaturityMonthYear.
            bool legMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 96;

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

            /// Multileg instrument's individual security's leg
            /// MaturityDate.
            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;

                const BlockLength offset = 101;

                FieldValue fieldValue;

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

            /// Multileg instrument's individual security's StrikePrice.
            bool legStrikePrice(Decimal& value) const
            {
                typedef NullPRICENULL Null;

                const BlockLength offset = 103;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasure.
            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 111;
                const BlockLength length = 5;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasureQty.
            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullPRICENULL Null;

                const BlockLength offset = 116;

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

            /// Multileg instrument's individual security's leg
            /// SecurityExchange.
            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 124;
                const BlockLength length = 4;

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

            /// The ratio of quantity for this individual leg relative to
            /// the entire multileg security.
            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;

                const BlockLength offset = 128;

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

            /// The side of this individual leg (multileg security).
            bool legSide(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 130;

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

            /// Multileg instrument's individual security's leg option put
            /// or call.
            bool legPutOrCall(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 131;

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

            /// Indicates the currency of the unit of measure.
            /// Conditionally required when LegUnitOfMeasure(999) = Ccy.
            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 132;
                const BlockLength length = 3;

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

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

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

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

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

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data Entry Type.
        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        /// Unique security ID.
        bool securityId(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 1;

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

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICENULL Null;

            const BlockLength offset = 13;

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

        /// Traded quantity.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 21;

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

        /// The total number of real orders per instrument that
        /// participated in a match step within a match event.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 29;

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

        /// Unique Trade Entry ID per Instrument  and Trading Date.
        Int32 tradeId() const
        {
            const BlockLength offset = 33;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is aggressor of the trade. If there
        /// is no value present, then there is no aggressor.
        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 37;

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 38;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 88;
            const BlockLength length = 12;

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

        /// Identifies the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 100;
            const BlockLength length = 9;

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

        /// SecuritySubType for CDS only.
        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;

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

        /// This field provides the actual calendar date for contract
        /// maturity month and year (used for standardized futures and
        /// options).
        bool maturityMonthYear(MaturityMonthYear& value) const
        {
            typedef NullMaturityMonthYear Null;

            const BlockLength offset = 111;

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

        /// Market used to help identify an instrument.
        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 116;
            const BlockLength length = 4;

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

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

            const BlockLength offset = 120;

            FieldValue fieldValue;

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

        /// Unit of measure for the products' original contract size.
        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 122;
            const BlockLength length = 5;

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

        /// Indicates the ISO Currency code if it is a currency
        /// product.
        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 3;

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

        /// This field contains the notional value for each
        /// instrument. The notional value is equivalent to the
        /// corresponding premium-quoted contract.
        bool unitOfMeasureQty(Decimal& value) const
        {
            typedef NullPRICENULL Null;

            const BlockLength offset = 130;

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

        /// 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 NullDecimal32 Null;

            const BlockLength offset = 138;

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

        /// Valid price types for intraday trade.
        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 142;

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

        /// Valid trade types for intraday trade.
        bool trdType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 144;

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

        /// Market data entry identifier to map multiple prices of a
        /// single trade.
        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 145;
            const BlockLength length = 26;

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

        /// Indicates whether an option instrument is a put or call.
        bool putOrCall(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 171;

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

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

            const BlockLength offset = 172;

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

        /// A category of CDS credit event in which the underlying
        /// bond experiences a restructuring.
        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;

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

        /// Specifies which issue (underlying bond) will receive
        /// payment priority in the event of a default.
        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 2;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 184;
            const BlockLength length = 100;

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

        /// Identifies the multileg strategy (e.g. spread) to which
        /// the trade belongs. This links together trade legs executed
        /// as part of a strategy during a single match event.
        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 284;
            const BlockLength length = 26;

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

        /// Used to correlate leg instrument definitions with their
        /// executions. Cross referenced to Tag 1788.
        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 310;
            const BlockLength length = 17;

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

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

        /// Returns instance of PartyIDs repeating group. 
        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        /// Returns instance of Legs repeating group. 
        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;

        return ordinary<UInt16>(offset);
    }

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

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

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

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

/// QuoteRequest.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
QuoteRequest345 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 345 };

    /// Specifies the number of repeating symbols specified.
    /// Entry of RelatedSymEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of repeating EventType entries.
        /// Entry of EventsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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.
            bool eventType(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 0;

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

            /// Time of event. This is number of days since unix epoch.
            bool eventTime(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 1;

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

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

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

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 50;

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

        /// Coupon Rate of the swap.
        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;

            const BlockLength offset = 50;

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

        /// Quantity Requested.
        bool orderQty(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 54;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 62;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 66;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 67;
            const BlockLength length = 26;

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

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

            const BlockLength offset = 93;

            FieldValue fieldValue;

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

        /// Indicates type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 4;

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

        /// Type of quote requested. A tradable quote can trade
        /// against other orders and quotes upon acceptance.
        bool quoteType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 99;

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

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

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

        /// Returns reference to the next item.
        RelatedSymEntry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return RelatedSymEntry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

    /// Time of quote request creation, expressed in UTC.
    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);
    }

    /// Quote request ID defined by the exchange.
    bool quoteReqId(StrRef& value) const
    {
        const BlockLength offset = 9;
        const BlockLength length = 26;

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

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

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

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

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

/// MDInstrumentDefinitionIndices.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
InstrumentDefinitionIndices347 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 347 };

    /// Number of repeating InstrAttribType entries.
    /// Entry of InstAttribEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    InstAttribEntry : BinaryGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSizeEncoding::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());
        }

        /// Code to represent the type of instrument attribute.
        UInt8 instAttribType() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt8>(offset);
        }

        /// Attribute value appropriate to the InstrAttribType (871)
        /// field.
        bool instAttribValue(StrRef& value) const
        {
            const BlockLength offset = 1;
            const BlockLength length = 100;

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

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

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

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

    /// Number of repeating EventType entries.
    /// Entry of EventsEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    EventsEntry : BinaryGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSizeEncoding::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.
        EventTypeIndices::Enum eventType() const
        {
            const BlockLength offset = 0;

            return enumeration<EventTypeIndices>(offset);
        }

        /// Time of event. This is number of days since unix epoch.
        UInt64 eventTime() const
        {
            const BlockLength offset = 1;

            return ordinary<UInt64>(offset);
        }

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

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

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

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

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

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

    /// Instrument Name or Symbol.
    bool symbol(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 50;

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

    /// Indicates the type of product the instrument is associated
    /// with in the message.
    Int8 product() const
    {
        const BlockLength offset = 50;

        return ordinary<Int8>(offset);
    }

    /// Market used to help identify an instrument.
    StrRef securityExchange() const
    {
        const BlockLength offset = 51;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

    /// Identifies the currency for the instrument traded.
    StrRef currency() const
    {
        const BlockLength offset = 55;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Included on the message when a modification or deletion
    /// occurs.
    SecurityUpdateAction::Enum 
    securityUpdateAction() const
    {
        const BlockLength offset = 58;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Describes a class of service for a given data feed.
    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 59;
        const BlockLength length = 2;

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

    /// This value indicates the channel ID as defined in the XML
    /// configuration file.
    bool applId(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 61;

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

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

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

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

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

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

/// MDIncrementalRefreshIndices.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshIndices348 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 348 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Indicates Market data Update Action which is always New.
        UpdateActionNew updateAction() const
        {
            return UpdateActionNew();
        }

        /// Indicates Market Data Entry Type.
        EntryTypeIndices::Enum entryType() const
        {
            const BlockLength offset = 0;

            return enumeration<EntryTypeIndices>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        Decimal entryPx() const
        {
            const BlockLength offset = 5;

            return decimal<Decimal64>(offset);
        }

        /// Quantity of the MD Entry.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 14;

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

        /// Index Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;

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

        /// Indicates whether the price is preliminary or previous day.
        bool openCloseSettlFlag(Int8& value) const
        {
            typedef NullInt8 Null;

            const BlockLength offset = 72;

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

        /// Type of yield.
        bool yieldType(StrRef& value) const
        {
            const BlockLength offset = 73;
            const BlockLength length = 8;

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

        /// Yield of the index's underlying constituents and
        /// applicable for FI indices only.
        Decimal yield() const
        {
            const BlockLength offset = 81;

            return decimal<Decimal64>(offset);
        }

        /// Net change from previous day's closing price.
        Decimal netChgPrevDay() const
        {
            const BlockLength offset = 90;

            return decimal<Decimal64>(offset);
        }

        /// Index percentage change with respect to previous close.
        Decimal netPctChg() const
        {
            const BlockLength offset = 99;

            return decimal<Decimal64>(offset);
        }

        /// Percent trading of the underlying index constituents.
        Decimal percentTrading() const
        {
            const BlockLength offset = 108;

            return decimal<Decimal64>(offset);
        }

        /// List of conditions describing a index value.
        bool entryCode(EntryCode::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 117;

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

        /// Indicates Market Data Entry Date.
        bool entryDate(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 118;

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

        /// Indicates Market Data Entry Timestamp.
        bool entryTime(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 122;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 126;
            const BlockLength length = 50;

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

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

    /// Describes a class of service for a given data feed.
    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 8;
        const BlockLength length = 2;

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

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 11;

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

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

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

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

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

/// MDIncrementalRefreshTradeBlocks.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks349 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 349 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of underlying legs that make up the security.
        /// Entry of UnderlyingsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// Underlying Security's symbol.
            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Underlying Security's MaturityMonthYear.
            bool underlyingMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 50;

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

            /// Underlying Security's SecurityType.
            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;

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

            /// Underlying Security's SecurityExchange.
            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;

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

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

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

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

        /// Number of party roles.
        /// Entry of PartyIDsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Party identifier/code.
            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Identifies the type or role of the PartyID specified.
            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;

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

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.PartyIDsEntry";
            }
        };

        /// Repeating group containing PartyIDsEntry entries. 
        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        /// Number of legs (repeating groups).
        /// Entry of LegsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// This tag contains the instrument group of the requested
            /// security definition. Must be present when tag 555-NoLegs
            /// is present. Also must be first tag in repeating group.
            /// Multileg instrument's individual security's Symbol.
            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Multileg instrument's individual security's SecurityID.
            bool legSecurityId(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 50;

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

            /// Identifies source of tag 602-LegSecurityID value. This
            /// value is always 'H' for CME.
            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
            /// 'product code').
            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;

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

            /// Used to correlate leg instrument definitions with their
            /// executions.Cross referenced in Tag 654.
            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;

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

            /// Identifies the type of leg instrument.
            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;

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

            /// Multileg instrument's individual security's leg
            /// MaturityMonthYear.
            bool legMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 96;

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

            /// Multileg instrument's individual security's leg
            /// MaturityDate.
            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;

                const BlockLength offset = 101;

                FieldValue fieldValue;

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

            /// Multileg instrument's individual security's StrikePrice.
            bool legStrikePrice(Decimal& value) const
            {
                typedef NullPRICENULL Null;

                const BlockLength offset = 103;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasure.
            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 111;
                const BlockLength length = 5;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasureQty.
            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullPRICENULL Null;

                const BlockLength offset = 116;

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

            /// Multileg instrument's individual security's leg
            /// SecurityExchange.
            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 124;
                const BlockLength length = 4;

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

            /// The ratio of quantity for this individual leg relative to
            /// the entire multileg security.
            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;

                const BlockLength offset = 128;

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

            /// The side of this individual leg (multileg security).
            bool legSide(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 130;

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

            /// Multileg instrument's individual security's leg option put
            /// or call.
            bool legPutOrCall(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 131;

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

            /// Indicates the currency of the unit of measure.
            /// Conditionally required when LegUnitOfMeasure(999) = Ccy.
            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 132;
                const BlockLength length = 3;

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

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

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

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

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

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data Entry Type.
        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        /// Unique security ID.
        bool securityId(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 1;

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

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICENULL Null;

            const BlockLength offset = 13;

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

        /// Traded quantity.
        Decimal entrySize() const
        {
            const BlockLength offset = 21;

            return decimal<Decimal64>(offset);
        }

        /// The total number of real orders per instrument that
        /// participated in a match step within a match event.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 30;

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

        /// Unique Trade Entry ID per Instrument  and Trading Date.
        Int32 tradeId() const
        {
            const BlockLength offset = 34;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is aggressor of the trade. If there
        /// is no value present, then there is no aggressor.
        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 38;

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 39;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 89;
            const BlockLength length = 12;

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

        /// Identifies the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 101;
            const BlockLength length = 9;

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

        /// SecuritySubType for CDS only.
        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 110;
            const BlockLength length = 2;

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

        /// This field provides the actual calendar date for contract
        /// maturity month and year (used for standardized futures and
        /// options).
        bool maturityMonthYear(MaturityMonthYear& value) const
        {
            typedef NullMaturityMonthYear Null;

            const BlockLength offset = 112;

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

        /// Market used to help identify an instrument.
        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 117;
            const BlockLength length = 4;

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

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

            const BlockLength offset = 121;

            FieldValue fieldValue;

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

        /// Unit of measure for the products' original contract size.
        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 123;
            const BlockLength length = 5;

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

        /// Indicates the ISO Currency code if it is a currency
        /// product.
        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 128;
            const BlockLength length = 3;

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

        /// This field contains the notional value for each
        /// instrument. The notional value is equivalent to the
        /// corresponding premium-quoted contract.
        bool unitOfMeasureQty(Decimal& value) const
        {
            typedef NullPRICENULL Null;

            const BlockLength offset = 131;

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

        /// 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 NullDecimal32 Null;

            const BlockLength offset = 139;

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

        /// Valid price types for intraday trade.
        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 143;

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

        /// Valid trade types for intraday trade.
        bool trdType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 145;

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

        /// Market data entry identifier to map multiple prices of a
        /// single trade.
        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 146;
            const BlockLength length = 26;

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

        /// Indicates whether an option instrument is a put or call.
        bool putOrCall(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 172;

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

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

            const BlockLength offset = 173;

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

        /// A category of CDS credit event in which the underlying
        /// bond experiences a restructuring.
        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 181;
            const BlockLength length = 2;

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

        /// Specifies which issue (underlying bond) will receive
        /// payment priority in the event of a default.
        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 183;
            const BlockLength length = 2;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 185;
            const BlockLength length = 100;

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

        /// Identifies the multileg strategy (e.g. spread) to which
        /// the trade belongs. This links together trade legs executed
        /// as part of a strategy during a single match event.
        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 285;
            const BlockLength length = 26;

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

        /// Used to correlate leg instrument definitions with their
        /// executions. Cross referenced to Tag 1788.
        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 311;
            const BlockLength length = 17;

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

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

        /// Returns instance of PartyIDs repeating group. 
        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        /// Returns instance of Legs repeating group. 
        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch. Not present for EFP (828=2) and EFR
    /// (828=11) transactions.
    bool transactTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 0;

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

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;

        return ordinary<UInt16>(offset);
    }

    /// Indicates date of trade referenced in this message in
    /// YYYYMMDD format (expressed in local time at place of
    /// trade). Returned only in trade and trade cancel execution
    /// reports.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 11;

        FieldValue fieldValue;

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

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

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

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

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

/// MDIncrementalRefreshEris.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshEris351 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 351 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of entries in AltID group.
        /// Entry of SecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Expanded instrument description.
            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;

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

            /// Identifies class or source of the SecurityAltID (455)
            /// value.
            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 26;
                const BlockLength length = 1;

                return fixedStr<length>(offset);
            }

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.SecurityAltIDEntry";
            }
        };

        /// Repeating group containing SecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        /// Number of repeating EventType entries.
        /// Entry of EventsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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.
            UInt8 eventType() const
            {
                const BlockLength offset = 0;

                return ordinary<UInt8>(offset);
            }

            /// Time of event. This is UTC Time.
            bool eventTime(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 1;

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

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

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

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

        /// Indicates the type of Market Data update action.
        CHAR updateAction() const
        {
            const BlockLength offset = 0;

            return ordinary<CHAR>(offset);
        }

        /// Indicates the type of Market Data entry.
        CHAR entryType() const
        {
            const BlockLength offset = 1;

            return ordinary<CHAR>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        Decimal entryPx() const
        {
            const BlockLength offset = 6;

            return decimal<Decimal64>(offset);
        }

        /// Quantity or volume represented by the Market Data Entry.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 15;

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

        /// Calculated Futures Price using Swap NPV, Historical fixed
        /// and floating amounts and synthetic interest on variation
        /// margin.
        Decimal calFutPx() const
        {
            const BlockLength offset = 23;

            return decimal<Decimal64>(offset);
        }

        /// Position in the book.
        bool entryPositionNo(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 32;

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

        /// Number of orders working at a price level. Not sent on
        /// implied.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 36;

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

        /// The unique identifier for the trade entry, per instrument
        /// + trading date.
        Int32 tradeId() const
        {
            const BlockLength offset = 40;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is aggressor of the trade. If there
        /// is no value present, then there is no aggressor.
        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 44;

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 45;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 26;

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

        /// Identifies the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 121;
            const BlockLength length = 9;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 130;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 134;

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

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

            const BlockLength offset = 135;

            FieldValue fieldValue;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 137;
            const BlockLength length = 50;

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

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

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

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 9;

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

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

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

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

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

/// MDIncrementalRefreshEris.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshEris353 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 353 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of entries in AltID group.
        /// Entry of SecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Expanded instrument description.
            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;

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

            /// Identifies class or source of the SecurityAltID (455)
            /// value.
            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 26;
                const BlockLength length = 1;

                return fixedStr<length>(offset);
            }

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.SecurityAltIDEntry";
            }
        };

        /// Repeating group containing SecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        /// Number of repeating EventType entries.
        /// Entry of EventsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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.
            UInt8 eventType() const
            {
                const BlockLength offset = 0;

                return ordinary<UInt8>(offset);
            }

            /// Time of event. This is number of days since unix epoch.
            bool eventTime(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 1;

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

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

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

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

        /// Indicates the type of Market Data update action.
        CHAR updateAction() const
        {
            const BlockLength offset = 0;

            return ordinary<CHAR>(offset);
        }

        /// Indicates the type of Market Data entry.
        CHAR entryType() const
        {
            const BlockLength offset = 1;

            return ordinary<CHAR>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        Decimal entryPx() const
        {
            const BlockLength offset = 6;

            return decimal<Decimal64>(offset);
        }

        /// Quantity or volume represented by the Market Data Entry.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 15;

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

        /// Calculated Futures Price using Swap NPV, Historical fixed
        /// and floating amounts and synthetic interest on variation
        /// margin.
        Decimal calFutPx() const
        {
            const BlockLength offset = 23;

            return decimal<Decimal64>(offset);
        }

        /// Position in the book.
        bool entryPositionNo(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 32;

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

        /// Number of orders working at a price level. Not sent on
        /// implied.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 36;

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

        /// The unique identifier for the trade entry, per instrument
        /// + trading date.
        Int32 tradeId() const
        {
            const BlockLength offset = 40;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is aggressor of the trade. If there
        /// is no value present, then there is no aggressor.
        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 44;

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 45;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 26;

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

        /// Identifies the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 121;
            const BlockLength length = 9;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 130;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 134;

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

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

            const BlockLength offset = 135;

            FieldValue fieldValue;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 137;
            const BlockLength length = 50;

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

        /// Identifies the type of quote. 0=Indicative, 1=Tradeable.
        bool quoteType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 187;

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

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

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

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 9;

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

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

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

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

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

/// MDIncrementalRefreshOTC.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshOTC356 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 356 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of underlying legs that make up the security.
        /// Entry of UnderlyingsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// Underlying Security's symbol.
            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Underlying Security's MaturityMonthYear.
            bool underlyingMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 50;

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

            /// Underlying Security's SecurityType.
            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;

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

            /// Underlying Security's SecurityExchange and it can be used
            /// to identify the underlying security.
            StrRef underlyingSecurityExchange() const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;

                return fixedStr<length>(offset);
            }

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

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

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

        /// Number of entries in AltID group.
        /// Entry of SecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Expanded instrument description.
            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Identifies class or source of the SecurityAltID (455)
            /// value.
            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 50;
                const BlockLength length = 1;

                return fixedStr<length>(offset);
            }

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.SecurityAltIDEntry";
            }
        };

        /// Repeating group containing SecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        /// Indicates the type of Market Data update action.
        UpdateActionNew updateAction() const
        {
            return UpdateActionNew();
        }

        /// Indicates the type of Market Data entry.
        CHAR entryType() const
        {
            const BlockLength offset = 0;

            return ordinary<CHAR>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICENULL Null;

            const BlockLength offset = 5;

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

        /// Quantity or volume represented by the Market Data Entry.
        Decimal entrySize() const
        {
            const BlockLength offset = 13;

            return decimal<Decimal64>(offset);
        }

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 72;
            const BlockLength length = 12;

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

        /// Indicates the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 9;

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

        /// This field provides the actual calendar date for contract
        /// maturity month and year (used for standardized futures and
        /// options).
        bool maturityMonthYear(MaturityMonthYear& value) const
        {
            typedef NullMaturityMonthYear Null;

            const BlockLength offset = 93;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 98;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 102;

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

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

            const BlockLength offset = 103;

            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 NullDecimal32 Null;

            const BlockLength offset = 105;

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

        /// A category of CDS credit event in which the underlying
        /// bond experiences a restructuring.
        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;

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

        /// Specifies which issue (underlying bond) will receive
        /// payment priority in the event of a default.
        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 111;
            const BlockLength length = 2;

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

        /// Indicates the notional percentage of the deal that is
        /// still outstanding based on the remaining components of the
        /// index.
        bool tionalPercentageOutstanding(Decimal& value) const
        {
            typedef NullDecimal32 Null;

            const BlockLength offset = 113;

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

        /// Indicates whether an option instrument is a put or call.
        bool putOrCall(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 117;

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

        /// Strike Price for an option instrument.
        Decimal strikePrice() const
        {
            const BlockLength offset = 118;

            return decimal<Decimal64>(offset);
        }

        /// Unit of measure for the products' original contract size.
        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 5;

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

        /// Indicates the ISO Currency code if it is a currency
        /// product.
        StrRef unitOfMeasureCurrency() const
        {
            const BlockLength offset = 132;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// This field contains the notional value for each
        /// instrument. The notional value is equivalent to the
        /// corresponding premium-quoted contract.
        Decimal unitOfMeasureQty() const
        {
            const BlockLength offset = 135;

            return decimal<Decimal64>(offset);
        }

        /// Date of the Market Data Entry Format: YYYYMMDD (i.e.
        /// 20071215).
        bool entryDate(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 144;

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

        /// Flag that identifies a market data entry.
        bool openCloseSettlFlag(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 148;

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

        /// Valid price types for intraday trade.
        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 149;

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

        /// Indicates date of settlement.
        bool settlDate(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;
        }

        /// Condition describing a quote.
        CHAR quoteCondition() const
        {
            const BlockLength offset = 153;

            return ordinary<CHAR>(offset);
        }

        /// Identifies the market in which a product trades. For e.g.
        /// CDS, Dairy.
        bool marketSector(StrRef& value) const
        {
            const BlockLength offset = 154;
            const BlockLength length = 26;

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

        /// Group of related products. For e.g. High Yield, Cheese.
        bool sectorGroup(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;

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

        /// A further qualification of Sector Group For e.g. North
        /// American.
        bool sectorSubGroup(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 26;

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

        /// Identifies an entire suite of products for a given market.
        bool productComplex(StrRef& value) const
        {
            const BlockLength offset = 208;
            const BlockLength length = 26;

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

        /// SecuritySubType for CDS only.
        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 234;
            const BlockLength length = 2;

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

        /// Volume types for end of day volume.
        bool volType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 236;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 238;
            const BlockLength length = 100;

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

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

        /// Returns instance of SecurityAltID repeating group. 
        SecurityAltID securityAltId() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<SecurityAltID>();
        }

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = securityAltId().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

    /// Indicates date of trade referenced in this message in
    /// YYYYMMDD format (expressed in local time at place of
    /// trade). Returned only in trade and trade cancel execution
    /// reports.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 8;

        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 event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 10;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 11;

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

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

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

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

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

/// MDInstrumentDefinitionEris.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
InstrumentDefinitionEris363 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 363 };

    /// Number of feed type repeating group entries.
    /// Entry of FeedTypesEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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. This
        /// value will always be EBX for Eris.
        bool feedType(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

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

        /// Indicated the level on the book traded.
        bool marketDepth(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 3;

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

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

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

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

    /// Number of repeating EventType entries.
    /// Entry of EventsEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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.
        bool eventType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 0;

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

        /// Time of event. This is number of days since unix epoch.
        bool eventTime(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 1;

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

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

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

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

    /// Number of entries in AltID group.
    /// Entry of SecurityAltIDEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    SecurityAltIDEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

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

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

        /// Expanded instrument description.
        bool securityAltId(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 26;

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

        /// Identifies class or source of the SecurityAltID (455)
        /// value.
        StrRef securityAltIdSource() const
        {
            const BlockLength offset = 26;
            const BlockLength length = 1;

            return fixedStr<length>(offset);
        }

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

        /// Entity class name. 
        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionEris363.SecurityAltIDEntry";
        }
    };

    /// Repeating group containing SecurityAltIDEntry entries. 
    typedef 
    BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
    SecurityAltID;

    /// Number of legs (repeating groups).
    /// Entry of LegsEntry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Multileg instrument's individual security's
        /// NoSecurityAltID.
        /// Entry of LegSecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        LegSecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Multileg instrument's individual security's SecurityAltID.
            bool legSecurityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;

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

            /// Multileg instrument's individual security's
            /// SecurityAltIDSource.
            bool legSecurityAltIdSource(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 26;

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

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Legs.LegSecurityAltIDEntry";
            }
        };

        /// Repeating group containing LegSecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<LegSecurityAltIDEntry, GroupSize, MessageSize> 
        LegSecurityAltID;

        /// Required for Floating Rate Leg. Floating rate reference.
        bool legBenchmarkCurveName(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 5;

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

        /// Rate Descriptor.
        bool rateDescriptor(StrRef& value) const
        {
            const BlockLength offset = 5;
            const BlockLength length = 8;

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

        /// Issue date for one leg of a multi-issue trade. It is the
        /// previous fixing date on the float leg.
        bool previousFixingDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 13;

            FieldValue fieldValue;

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

        /// Payment frequency of fixed and floating rates expresses as
        /// a period.
        bool legPayFrequencey(StrRef& value) const
        {
            const BlockLength offset = 15;
            const BlockLength length = 3;

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

        /// The Rate set on the last reset date. It is the previous
        /// fixing rate.
        Decimal previousFixingRate() const
        {
            const BlockLength offset = 18;

            return decimal<Decimal64>(offset);
        }

        /// For Eris Interest rate swaps values would be FIXED, FLOAT
        /// and for Spread, value would be underline instrument.
        bool legSymbol(StrRef& value) const
        {
            const BlockLength offset = 27;
            const BlockLength length = 50;

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

        /// The ratio of quantity for this individual leg relative to
        /// the entire multi-leg instrument.
        bool legRatioQty(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 77;

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

        /// The side of this individual leg.
        bool legSide(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 81;

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

        /// Currency associated with a particular Leg's quantity.
        StrRef legCurrency() const
        {
            const BlockLength offset = 82;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// Identifies the type of instrument.
        bool legSecurityType(StrRef& value) const
        {
            const BlockLength offset = 85;
            const BlockLength length = 8;

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

        /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
        /// 'product code').
        bool legSecurityGroup(StrRef& value) const
        {
            const BlockLength offset = 93;
            const BlockLength length = 12;

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

        /// Float reset date offset, specified when LegType = FLOAT.
        bool legDateOffset(Int8& value) const
        {
            typedef NullInt8 Null;

            const BlockLength offset = 105;

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

        /// Multiplier that when applied on longer rate results in
        /// previous fixing rate.
        Decimal interpolationFactor() const
        {
            const BlockLength offset = 106;

            return decimal<Decimal64>(offset);
        }

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

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

        /// Returns reference to the next item.
        LegsEntry next(SchemaVersion) const
        {
            const void* body = legSecurityAltId().end().get().body();
            return LegsEntry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

    /// Product code.
    bool securityGroup(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 12;

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

    /// Instrument/Index/Swap Name.
    bool symbol(StrRef& value) const
    {
        const BlockLength offset = 12;
        const BlockLength length = 50;

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

    /// Identifies the type of instrument.
    bool securityType(StrRef& value) const
    {
        const BlockLength offset = 62;
        const BlockLength length = 4;

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

    /// Identifies the type of product.
    bool product(UInt8& value) const
    {
        typedef NullUInt8 Null;

        const BlockLength offset = 66;

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

    /// Market used to help identify a security.
    StrRef securityExchange() const
    {
        const BlockLength offset = 67;
        const BlockLength length = 4;

        return fixedStr<length>(offset);
    }

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

        const BlockLength offset = 71;

        FieldValue fieldValue;

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

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

        return fixedStr<length>(offset);
    }

    /// Minimum constant tick for the instrument.
    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 76;

        return decimal<Decimal64>(offset);
    }

    /// Included in the message on the Incremental feed when a
    /// mid-week deletion or modification (i.e. extension) occurs.
    SecurityUpdateAction::Enum 
    securityUpdateAction() const
    {
        const BlockLength offset = 85;

        return enumeration<SecurityUpdateAction>(offset);
    }

    /// Rate type for the swap  and spread.
    bool rateType(StrRef& value) const
    {
        const BlockLength offset = 86;
        const BlockLength length = 2;

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

    /// Coupon Rate of the Swap.
    bool couponRate(Decimal& value) const
    {
        typedef NullDecimal32 Null;

        const BlockLength offset = 88;

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

    /// Identifies user-defined instruments. If the tag is not
    /// present, the instrument is not user-defined.
    bool userDefinedInstrument(ErisUDI& value) const
    {
        typedef NullErisUDI Null;

        const BlockLength offset = 92;

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

    /// This value indicates the channel ID as defined in the XML
    /// configuration file.
    bool applId(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 93;

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

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

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

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

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

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

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

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

/// MDIncrementalRefreshTradeBlocks.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks365 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 365 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of underlying legs that make up the security.
        /// Entry of UnderlyingsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// Underlying Security's symbol.
            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Underlying Security's MaturityMonthYear.
            bool underlyingMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 50;

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

            /// Underlying Security's SecurityType.
            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;

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

            /// Underlying Security's SecurityExchange.
            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;

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

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

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

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

        /// Number of party roles.
        /// Entry of PartyIDsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Party identifier/code.
            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Identifies the type or role of the PartyID specified.
            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;

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

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.PartyIDsEntry";
            }
        };

        /// Repeating group containing PartyIDsEntry entries. 
        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        /// Number of legs (repeating groups).
        /// Entry of LegsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// This tag contains the instrument group of the requested
            /// security definition. Must be present when tag 555-NoLegs
            /// is present. Also must be first tag in repeating group.
            /// Multileg instrument's individual security's Symbol.
            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Multileg instrument's individual security's SecurityID.
            bool legSecurityId(UInt64& value) const
            {
                typedef NullUInt64 Null;

                const BlockLength offset = 50;

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

            /// Identifies source of tag 602-LegSecurityID value. This
            /// value is always 'H' for CME.
            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            /// Leg equivalent of body tag 1151-SecurityGroup (i.e. leg
            /// 'product code').
            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;

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

            /// Used to correlate leg instrument definitions with their
            /// executions.Cross referenced in Tag 654.
            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;

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

            /// Identifies the type of leg instrument.
            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;

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

            /// Multileg instrument's individual security's leg
            /// MaturityMonthYear.
            bool legMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 96;

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

            /// Multileg instrument's individual security's leg
            /// MaturityDate.
            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;

                const BlockLength offset = 101;

                FieldValue fieldValue;

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

            /// Multileg instrument's individual security's StrikePrice.
            bool legStrikePrice(Decimal& value) const
            {
                typedef NullDecimal64 Null;

                const BlockLength offset = 103;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasure.
            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 112;
                const BlockLength length = 5;

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

            /// Multileg instrument's individual security's leg
            /// UnitOfMeasureQty.
            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullDecimal64 Null;

                const BlockLength offset = 117;

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

            /// Multileg instrument's individual security's leg
            /// SecurityExchange.
            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 126;
                const BlockLength length = 4;

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

            /// The ratio of quantity for this individual leg relative to
            /// the entire multileg security.
            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;

                const BlockLength offset = 130;

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

            /// The side of this individual leg (multileg security).
            bool legSide(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 132;

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

            /// Multileg instrument's individual security's leg option put
            /// or call.
            bool legPutOrCall(UInt8& value) const
            {
                typedef NullUInt8 Null;

                const BlockLength offset = 133;

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

            /// Indicates the currency of the unit of measure.
            /// Conditionally required when LegUnitOfMeasure(999) = Ccy.
            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 134;
                const BlockLength length = 3;

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

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

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

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

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

            return enumeration<UpdateAction>(offset);
        }

        /// Market Data Entry Type.
        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        /// Unique security ID.
        bool securityId(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 1;

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

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICENULL9 Null;

            const BlockLength offset = 13;

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

        /// Traded quantity.
        Decimal entrySize() const
        {
            const BlockLength offset = 21;

            return decimal<Decimal64>(offset);
        }

        /// The total number of real orders per instrument that
        /// participated in a match step within a match event.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 30;

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

        /// Unique Trade Entry ID per Instrument  and Trading Date.
        Int32 tradeId() const
        {
            const BlockLength offset = 34;

            return ordinary<Int32>(offset);
        }

        /// Indicates which side is aggressor of the trade. If there
        /// is no value present, then there is no aggressor.
        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 38;

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

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 39;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 89;
            const BlockLength length = 12;

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

        /// Identifies the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 101;
            const BlockLength length = 9;

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

        /// SecuritySubType for CDS only.
        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 110;
            const BlockLength length = 2;

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

        /// This field provides the actual calendar date for contract
        /// maturity month and year (used for standardized futures and
        /// options).
        bool maturityMonthYear(MaturityMonthYear& value) const
        {
            typedef NullMaturityMonthYear Null;

            const BlockLength offset = 112;

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

        /// Market used to help identify an instrument.
        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 117;
            const BlockLength length = 4;

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

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

            const BlockLength offset = 121;

            FieldValue fieldValue;

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

        /// Unit of measure for the products' original contract size.
        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 123;
            const BlockLength length = 5;

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

        /// Indicates the ISO Currency code if it is a currency
        /// product.
        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 128;
            const BlockLength length = 3;

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

        /// This field contains the notional value for each
        /// instrument. The notional value is equivalent to the
        /// corresponding premium-quoted contract.
        bool unitOfMeasureQty(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 131;

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

        /// 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 NullDecimal32 Null;

            const BlockLength offset = 140;

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

        /// Valid price types for intraday trade.
        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 144;

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

        /// Valid trade types for intraday trade.
        bool trdType(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 146;

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

        /// Market data entry identifier to map multiple prices of a
        /// single trade.
        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 147;
            const BlockLength length = 26;

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

        /// Indicates whether an option instrument is a put or call.
        bool putOrCall(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 173;

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

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

            const BlockLength offset = 174;

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

        /// A category of CDS credit event in which the underlying
        /// bond experiences a restructuring.
        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 183;
            const BlockLength length = 2;

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

        /// Specifies which issue (underlying bond) will receive
        /// payment priority in the event of a default.
        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 185;
            const BlockLength length = 2;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 187;
            const BlockLength length = 100;

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

        /// Identifies the multileg strategy (e.g. spread) to which
        /// the trade belongs. This links together trade legs executed
        /// as part of a strategy during a single match event.
        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 287;
            const BlockLength length = 26;

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

        /// Used to correlate leg instrument definitions with their
        /// executions. Cross referenced to Tag 1788.
        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 313;
            const BlockLength length = 17;

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

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

        /// Returns instance of PartyIDs repeating group. 
        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        /// Returns instance of Legs repeating group. 
        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

    /// Start of event processing time in number of nanoseconds
    /// since Unix epoch. Not present for EFP (828=2) and EFR
    /// (828=11) transactions.
    bool transactTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;

        const BlockLength offset = 0;

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

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

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;

        return ordinary<UInt16>(offset);
    }

    /// Indicates date of trade referenced in this message in
    /// YYYYMMDD format (expressed in local time at place of
    /// trade). Returned only in trade and trade cancel execution
    /// reports.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 11;

        FieldValue fieldValue;

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

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

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

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

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

/// MDIncrementalRefreshOTC.
ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshOTC366 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 366 };

    /// Number of entries in Market Data message.
    /// Entry of Entry repeating group.
    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    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());
        }

        /// Number of underlying legs that make up the security.
        /// Entry of UnderlyingsEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        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());
            }

            /// Underlying Security's symbol.
            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Underlying Security's MaturityMonthYear.
            bool underlyingMaturityMonthYear(MaturityMonthYear& value) const
            {
                typedef NullMaturityMonthYear Null;

                const BlockLength offset = 50;

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

            /// Underlying Security's SecurityType.
            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;

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

            /// Underlying Security's SecurityExchange and it can be used
            /// to identify the underlying security.
            StrRef underlyingSecurityExchange() const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;

                return fixedStr<length>(offset);
            }

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

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

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

        /// Number of entries in AltID group.
        /// Entry of SecurityAltIDEntry repeating group.
        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            /// Aliases base class type. 
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

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

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

            /// Expanded instrument description.
            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;

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

            /// Identifies class or source of the SecurityAltID (455)
            /// value.
            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 50;
                const BlockLength length = 1;

                return fixedStr<length>(offset);
            }

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

            /// Entity class name. 
            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Entries.SecurityAltIDEntry";
            }
        };

        /// Repeating group containing SecurityAltIDEntry entries. 
        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        /// Indicates the type of Market Data update action.
        UpdateActionNew updateAction() const
        {
            return UpdateActionNew();
        }

        /// Indicates the type of Market Data entry.
        CHAR entryType() const
        {
            const BlockLength offset = 0;

            return ordinary<CHAR>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

        /// Price of the Market Data Entry.
        bool entryPx(Decimal& value) const
        {
            typedef NullPRICENULL9 Null;

            const BlockLength offset = 5;

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

        /// Quantity or volume represented by the Market Data Entry.
        Decimal entrySize() const
        {
            const BlockLength offset = 13;

            return decimal<Decimal64>(offset);
        }

        /// Instrument/Index/Swap Name.
        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;

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

        /// Indicates the product code for the instrument.
        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 72;
            const BlockLength length = 12;

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

        /// Indicates the type of instrument.
        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 9;

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

        /// This field provides the actual calendar date for contract
        /// maturity month and year (used for standardized futures and
        /// options).
        bool maturityMonthYear(MaturityMonthYear& value) const
        {
            typedef NullMaturityMonthYear Null;

            const BlockLength offset = 93;

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

        /// Market used to help identify an instrument.
        StrRef securityExchange() const
        {
            const BlockLength offset = 98;
            const BlockLength length = 4;

            return fixedStr<length>(offset);
        }

        /// Indicates the type of product the instrument is associated
        /// with in the message.
        bool product(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 102;

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

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

            const BlockLength offset = 103;

            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 NullDecimal32 Null;

            const BlockLength offset = 105;

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

        /// A category of CDS credit event in which the underlying
        /// bond experiences a restructuring.
        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;

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

        /// Specifies which issue (underlying bond) will receive
        /// payment priority in the event of a default.
        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 111;
            const BlockLength length = 2;

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

        /// Indicates the notional percentage of the deal that is
        /// still outstanding based on the remaining components of the
        /// index.
        bool tionalPercentageOutstanding(Decimal& value) const
        {
            typedef NullDecimal32 Null;

            const BlockLength offset = 113;

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

        /// Indicates whether an option instrument is a put or call.
        bool putOrCall(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 117;

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

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

            const BlockLength offset = 118;

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

        /// Unit of measure for the products' original contract size.
        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 5;

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

        /// Indicates the ISO Currency code if it is a currency
        /// product.
        StrRef unitOfMeasureCurrency() const
        {
            const BlockLength offset = 132;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

        /// This field contains the notional value for each
        /// instrument. The notional value is equivalent to the
        /// corresponding premium-quoted contract.
        bool unitOfMeasureQty(Decimal& value) const
        {
            typedef NullDecimal64 Null;

            const BlockLength offset = 135;

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

        /// Date of the Market Data Entry Format: YYYYMMDD (i.e.
        /// 20071215).
        bool entryDate(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 144;

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

        /// Flag that identifies a market data entry.
        bool openCloseSettlFlag(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 148;

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

        /// Valid price types for intraday trade.
        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 149;

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

        /// Indicates date of settlement.
        bool settlDate(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;
        }

        /// Condition describing a quote.
        CHAR quoteCondition() const
        {
            const BlockLength offset = 153;

            return ordinary<CHAR>(offset);
        }

        /// Identifies the market in which a product trades. For e.g.
        /// CDS, Dairy.
        bool marketSector(StrRef& value) const
        {
            const BlockLength offset = 154;
            const BlockLength length = 26;

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

        /// Group of related products. For e.g. High Yield, Cheese.
        bool sectorGroup(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;

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

        /// A further qualification of Sector Group For e.g. North
        /// American.
        bool sectorSubGroup(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 26;

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

        /// Identifies an entire suite of products for a given market.
        bool productComplex(StrRef& value) const
        {
            const BlockLength offset = 208;
            const BlockLength length = 26;

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

        /// SecuritySubType for CDS only.
        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 234;
            const BlockLength length = 2;

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

        /// Volume types for end of day volume.
        bool volType(UInt16& value) const
        {
            typedef NullUInt16 Null;

            const BlockLength offset = 236;

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

        /// For future use.
        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 238;
            const BlockLength length = 100;

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

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

        /// Returns instance of SecurityAltID repeating group. 
        SecurityAltID securityAltId() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<SecurityAltID>();
        }

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

        /// Returns reference to the next item.
        Entry next(SchemaVersion) const
        {
            const void* body = securityAltId().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

    /// Indicates date of trade referenced in this message in
    /// YYYYMMDD format (expressed in local time at place of
    /// trade). Returned only in trade and trade cancel execution
    /// reports.
    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;

        const BlockLength offset = 8;

        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 event.
    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 10;

        return ordinary<MatchEventIndicator>(offset);
    }

    /// Total number of messages contained within batch which is
    /// defined by match event indicator (5799).
    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;

        const BlockLength offset = 11;

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

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

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

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

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


ONIXS_CMESTREAMLINEDMDH_NAMESPACE_END