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

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

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

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

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

        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_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

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

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

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

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

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

        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_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

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

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

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

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

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

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

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

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

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

/// MDInstrumentDefinitionFX.
ONIXS_CONFLATEDUDP_LTWT_STRUCT 
InstrumentDefinitionFX63 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 63 };

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

            return enumeration<EventType>(offset);
        }

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

            return ordinary<Timestamp>(offset);
        }

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

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

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

    /// Number of FeedType entries.
    /// Entry of FeedTypesEntry repeating group.
    ONIXS_CONFLATEDUDP_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.
        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;

            return fixedStr<length>(offset);
        }

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

            return ordinary<Int8>(offset);
        }

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

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

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

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

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

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

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

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

            return ordinary<InstAttribValue>(offset);
        }

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

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

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

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

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

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

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

            return ordinary<Int8>(offset);
        }

        /// For FX instruments in the repeating group with Tag
        /// 1093-LotType=2, Tag 1231-MinLotSize provides a Regular
        /// Amount - a default order size on the Workstation screen.
        /// With tag 1093-LotType= 5, Tag 1231-MinLotSize value
        /// represents standard min order qty increment.  With  tag
        /// 1093-LotType=6 tag 1231-MinLotSize contains
        /// SizePriorityQty for instruments trading with Match
        /// Algorithm = P (Size Priority).
        UInt64 minLotSize() const
        {
            const BlockLength offset = 1;

            return ordinary<UInt64>(offset);
        }

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

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

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

    /// Number of scheduled Trading Dates.
    /// Entry of TradingSessionsEntry repeating group.
    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    TradingSessionsEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

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

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

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

            const BlockLength offset = 0;

            FieldValue fieldValue;

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

        /// Settle (Value) Date corresponding to Trade Date.
        bool settlDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 2;

            FieldValue fieldValue;

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

        /// For Spot instruments will not contain the value. For NDFs,
        /// the valuation (fixing) date of the NDF.  For Fixed Date
        /// NDFs Value Date and Maturity Date remain constant for all
        /// Trade Dates.
        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;

            const BlockLength offset = 4;

            FieldValue fieldValue;

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

        /// ISIN value as provided by ANNA, Association of National
        /// Numbering Agencies. This field is populated for MTF-
        /// Regulated NDFs and is unique for each Settle Date.
        StrRef securityAltId() const
        {
            const BlockLength offset = 6;
            const BlockLength length = 12;

            return fixedStr<length>(offset);
        }

        /// Identifies class or source of the SecurityAltID (455)
        /// value.
        SecurityAltIDSourceISIN securityAltIdSource() const
        {
            return SecurityAltIDSourceISIN();
        }

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

        /// Entity class name. 
        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionFX63.TradingSessionsEntry";
        }
    };

    /// Repeating group containing TradingSessionsEntry entries. 
    typedef 
    BinaryGroup<TradingSessionsEntry, GroupSize, MessageSize> 
    TradingSessions;

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

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

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

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

        const BlockLength offset = 1;

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

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

        return enumeration<SecurityUpdateAction>(offset);
    }

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

        return ordinary<Timestamp>(offset);
    }

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

        const BlockLength offset = 14;

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

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

        return ordinary<Int16>(offset);
    }

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

        return ordinary<UInt8>(offset);
    }

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

        return ordinary<UInt8>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        return ordinary<Int32>(offset);
    }

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

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

        return fixedStr<length>(offset);
    }

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

        return fixedStr<length>(offset);
    }

    /// Base currency.
    StrRef currency() const
    {
        const BlockLength offset = 71;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Currency used for settlement, which may be different from
    /// Local currency specified in Tag 1524 PriceQuoteCurrency.
    StrRef settlCurrency() const
    {
        const BlockLength offset = 74;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// Local (counter) currency.
    StrRef priceQuoteCurrency() const
    {
        const BlockLength offset = 77;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

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

        return ordinary<CHAR>(offset);
    }

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

        return ordinary<UInt32>(offset);
    }

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

        return ordinary<UInt32>(offset);
    }

    /// Minimum price tick.
    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 89;

        return decimal<PRICE9>(offset);
    }

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

        return decimal<Decimal9>(offset);
    }

    /// Specifies price decimal precision for EBS instrument.
    UInt8 pricePrecision() const
    {
        const BlockLength offset = 105;

        return ordinary<UInt8>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        const BlockLength offset = 136;

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

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

        const BlockLength offset = 144;

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

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

        const BlockLength offset = 152;

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

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

        const BlockLength offset = 160;

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

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

        return ordinary<UserDefinedInstrument>(offset);
    }

    /// EBS instrument long name.
    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 169;
        const BlockLength length = 35;

        return fixedStr<length>(offset);
    }

    /// Base/Local. Denotes the currency pair in CCY1/CCY2
    /// convention.
    StrRef fxCurrencySymbol() const
    {
        const BlockLength offset = 204;
        const BlockLength length = 7;

        return fixedStr<length>(offset);
    }

    /// For SPOTs will contain 0. For Fixed date NDFs will contain
    /// the value 'B'. For the standard NDFs tenors expressed
    /// using Dx, Mx, Wx, and Yx values, where 'x' does not denote
    /// business days, but calendar days.
    StrRef settlType() const
    {
        const BlockLength offset = 211;
        const BlockLength length = 3;

        return fixedStr<length>(offset);
    }

    /// For SPOT, number of business days between trade date and
    /// value (settlement) date. For NDF, number of business days
    /// between NDF valuation (fixing) and settlement.
    UInt16 interveningDays() const
    {
        const BlockLength offset = 214;

        return ordinary<UInt16>(offset);
    }

    /// Fixing Rate Description.
    StrRef fxBenchmarkRateFix() const
    {
        const BlockLength offset = 216;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Source.
    StrRef rateSource() const
    {
        const BlockLength offset = 236;
        const BlockLength length = 12;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Local Time, denoted in HH:MM:SS format.
    StrRef fixRateLocalTime() const
    {
        const BlockLength offset = 248;
        const BlockLength length = 8;

        return fixedStr<length>(offset);
    }

    /// Fixing Rate Local Time Zone corresponding to Fixing Local
    /// Time.
    StrRef fixRateLocalTimeZone() const
    {
        const BlockLength offset = 256;
        const BlockLength length = 20;

        return fixedStr<length>(offset);
    }

    /// Minimum Quote Life in number of microseconds.
    UInt32 minQuoteLife() const
    {
        const BlockLength offset = 276;

        return ordinary<UInt32>(offset);
    }

    /// Max allowed discretionary offset from Limit order price.
    /// When the value in this field = 0, discretionary price
    /// cannot be submitted for the instrument.
    Decimal maxPriceDiscretionOffset() const
    {
        const BlockLength offset = 280;

        return decimal<PRICE9>(offset);
    }

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

        const BlockLength offset = 288;

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

    /// Fixed Date NDF Maturity.
    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;

        const BlockLength offset = 296;

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

    /// Settlement Locale. Optionally used to differentiate
    /// settlement location.
    StrRef settlementLocale() const
    {
        const BlockLength offset = 301;
        const BlockLength length = 8;

        return fixedStr<length>(offset);
    }

    /// New sub-tick which is only available for order entry when
    /// certain conditions are met, tick value which corresponds
    /// to the Alt Min Quote Life.
    bool altMinPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 309;
        const SchemaVersion since = 13;

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

    /// MQL duration in number of microseconds applied to orders
    /// at AltMinPriceIncrement.
    bool altMinQuoteLife(UInt32& value) const
    {
        typedef NullUInt32 Null;

        const BlockLength offset = 317;
        const SchemaVersion since = 13;

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

    /// Minimum price offset better than the best Standard Tick
    /// order for an order to be allowed into the market.
    bool altPriceIncrementConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 321;
        const SchemaVersion since = 13;

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

    /// Maximum bid/ask spread for which sub-tick orders will be
    /// accepted (Sub tick orders will be rejected if bid/ask
    /// spread is greater than this value).
    bool maxBidAskConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 329;
        const SchemaVersion since = 13;

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

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

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

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

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

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

    /// Size of message body in bytes. 
    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 13)
            return 337;

        return 309;
    }

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

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

/// MDIncrementalRefreshBookLongQty.
ONIXS_CONFLATEDUDP_LTWT_STRUCT 
IncrementalRefreshBookLongQty64 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 64 };

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

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

            const BlockLength offset = 0;

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

        /// Aggregate booked qty at price level, notional.
        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;

            const BlockLength offset = 8;

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

        /// SecurityID.
        Int32 securityId() const
        {
            const BlockLength offset = 16;

            return ordinary<Int32>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

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

            const BlockLength offset = 24;

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

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

            return ordinary<UInt8>(offset);
        }

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

            return enumeration<UpdateAction>(offset);
        }

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

            return enumeration<EntryTypeBook>(offset);
        }

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

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

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

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

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

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

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

            return ordinary<UInt64>(offset);
        }

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

            const BlockLength offset = 8;

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

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

            const BlockLength offset = 16;

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

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

            const BlockLength offset = 20;

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

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

            return enumeration<OrderUpdateAction>(offset);
        }

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

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

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

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

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

/// MDIncrementalRefreshTradeSummaryLongQty.
ONIXS_CONFLATEDUDP_LTWT_STRUCT 
IncrementalRefreshTradeSummaryLongQty65 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 65 };

    /// Number of Trade Summary entries.
    /// Entry of Entry repeating group.
    ONIXS_CONFLATEDUDP_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());
        }

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

            return decimal<PRICE9>(offset);
        }

        /// Consolidated trade quantity, notional.
        UInt64 entrySize() const
        {
            const BlockLength offset = 8;

            return ordinary<UInt64>(offset);
        }

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

            return ordinary<Int32>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

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

            return ordinary<Int32>(offset);
        }

        /// Market Data Trade Entry ID.
        UInt32 tradeEntryId() const
        {
            const BlockLength offset = 28;

            return ordinary<UInt32>(offset);
        }

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

            const BlockLength offset = 32;

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

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

            return enumeration<UpdateAction>(offset);
        }

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

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

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

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

    /// Number of OrderID and LastQty entries in Trade Summary
    /// message.
    /// Entry of OrderIDEntry repeating group.
    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    OrderIDEntry : BinaryGroupEntry
    <
        GroupSize8Byte::BlockLength
    >
    {
        /// Aliases base class type. 
        typedef 
        BinaryGroupEntry
        <
            GroupSize8Byte::BlockLength
        >
        Base;

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

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

        /// Unique order identifier as assigned by the exchange.
        UInt64 orderId() const
        {
            const BlockLength offset = 0;

            return ordinary<UInt64>(offset);
        }

        /// Quantity bought or sold on this last fill.
        Int32 lastQty() const
        {
            const BlockLength offset = 8;

            return ordinary<Int32>(offset);
        }

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

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

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

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

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

/// SnapshotFullRefreshLongQty.
ONIXS_CONFLATEDUDP_LTWT_STRUCT 
SnapshotFullRefreshLongQty69 
: BinaryMessage
{
    /// Message template ID from SBE schema.
    enum { TemplateId = 69 };

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

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

            const BlockLength offset = 0;

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

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

            const BlockLength offset = 8;

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

        /// In Book Entry - Aggregate number of orders at given price
        /// level. In Trade Entry - a total number of real orders per
        /// instrument that participated in a match step within a
        /// match event.
        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;

            const BlockLength offset = 16;

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

        /// Aggregate book level.
        bool priceLevel(UInt8& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 20;

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

        /// Flag that additionally describes a market data entry.
        bool 
        openCloseSettlFlag(
            OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;

            const BlockLength offset = 21;

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

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

            return enumeration<EntryType>(offset);
        }

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

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

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

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

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

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

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

        return ordinary<UInt32>(offset);
    }

    /// Total number of instruments in the Replay loop. Used on
    /// Replay Feed only.
    UInt32 totNumReports() const
    {
        const BlockLength offset = 4;

        return ordinary<UInt32>(offset);
    }

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

        return ordinary<Int32>(offset);
    }

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

        return ordinary<UInt32>(offset);
    }

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<Timestamp>(offset);
    }

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

        const BlockLength offset = 32;

        FieldValue fieldValue;

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

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

        const BlockLength offset = 34;

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

    /// Upper price threshold for the instrument. Orders submitted
    /// with prices above the upper limit will be rejected.
    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 35;

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

    /// Lower price threshold for the instrument. Orders submitted
    /// with prices below the lower limit will be rejected.
    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;

        const BlockLength offset = 43;

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

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

        const BlockLength offset = 51;

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

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

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

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

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

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

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

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

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

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

            return ordinary<Int16>(offset);
        }

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        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_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

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

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

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

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

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

        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_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        return fixedStr<length>(offset);
    }

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

        const BlockLength offset = 20;

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

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

        const BlockLength offset = 24;

        FieldValue fieldValue;

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

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

        const BlockLength offset = 27;

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

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

        return enumeration<HaltReason>(offset);
    }

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

        return enumeration<SecurityTradingEvent>(offset);
    }

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

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

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

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

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

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

            const BlockLength offset = 0;

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

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

            const BlockLength offset = 8;

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

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

            const BlockLength offset = 16;

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

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

            return ordinary<Int32>(offset);
        }

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

            return ordinary<UInt32>(offset);
        }

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

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

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

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

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

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

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

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

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

        return ordinary<Timestamp>(offset);
    }

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

        return ordinary<MatchEventIndicator>(offset);
    }

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

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

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

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


ONIXS_CONFLATEDUDP_NAMESPACE_END