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

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminLogin408 
: BinaryMessage
{
    enum { TemplateId = 408 };

    AdminLogin408()
    {
    }

    AdminLogin408(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Int8 heartBtInt() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Int8>(offset);
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogin408";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("A");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminLogout409 
: BinaryMessage
{
    enum { TemplateId = 409 };

    AdminLogout409()
    {
    }

    AdminLogout409(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    StrRef text() const
    {
        const BlockLength offset = 0;
        const BlockLength length = 180;
 
        return fixedStr<length>(offset);
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogout409";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("5");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminHeartbeat410 
: BinaryMessage
{
    enum { TemplateId = 410 };

    AdminHeartbeat410()
    {
    }

    AdminHeartbeat410(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 0;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminHeartbeat410";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("0");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
InstrumentDefinitionFX63 
: BinaryMessage
{
    enum { TemplateId = 63 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    EventsEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        EventsEntry()
        {
        }

        EventsEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        EventType::Enum eventType() const
        {
            const BlockLength offset = 0;
 
            return enumeration<EventType>(offset);
        }

        Timestamp eventTime() const
        {
            const BlockLength offset = 1;
 
            return ordinary<Timestamp>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

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

    typedef 
    BinaryGroup<EventsEntry, GroupSize, MessageSize> 
    Events;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    FeedTypesEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        FeedTypesEntry()
        {
        }

        FeedTypesEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        StrRef feedType() const
        {
            const BlockLength offset = 0;
            const BlockLength length = 3;
 
            return fixedStr<length>(offset);
        }

        Int8 marketDepth() const
        {
            const BlockLength offset = 3;
 
            return ordinary<Int8>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

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

    typedef 
    BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> 
    FeedTypes;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    InstAttribEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        InstAttribEntry()
        {
        }

        InstAttribEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        InstAttribType instAttribType() const
        {
            return InstAttribType();
        }

        InstAttribValue instAttribValue() const
        {
            const BlockLength offset = 0;
 
            return ordinary<InstAttribValue>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 4;
        }

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

    typedef 
    BinaryGroup<InstAttribEntry, GroupSize, MessageSize> 
    InstAttrib;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    LotTypeRulesEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        LotTypeRulesEntry()
        {
        }

        LotTypeRulesEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        Int8 lotType() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int8>(offset);
        }

        UInt64 minLotSize() const
        {
            const BlockLength offset = 1;
 
            return ordinary<UInt64>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 9;
        }

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

    typedef 
    BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> 
    LotTypeRules;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    TradingSessionsEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        TradingSessionsEntry()
        {
        }

        TradingSessionsEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

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

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

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

        StrRef securityAltId() const
        {
            const BlockLength offset = 6;
            const BlockLength length = 12;
 
            return fixedStr<length>(offset);
        }

        SecurityAltIDSourceISIN securityAltIdSource() const
        {
            return SecurityAltIDSourceISIN();
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 18;
        }

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

    typedef 
    BinaryGroup<TradingSessionsEntry, GroupSize, MessageSize> 
    TradingSessions;

    InstrumentDefinitionFX63()
    {
    }

    InstrumentDefinitionFX63(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 0;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    bool totNumReports(UInt32& value) const
    {
        typedef NullUInt32 Null;
 
        const BlockLength offset = 1;
 
        return ordinary(value, offset, Null());
    }

    SecurityUpdateAction::Enum 
    securityUpdateAction() const
    {
        const BlockLength offset = 5;
 
        return enumeration<SecurityUpdateAction>(offset);
    }

    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 6;
 
        return ordinary<Timestamp>(offset);
    }

    bool 
    securityTradingStatus(
        SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;
 
        const BlockLength offset = 14;
 
        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    Int16 applId() const
    {
        const BlockLength offset = 15;
 
        return ordinary<Int16>(offset);
    }

    UInt8 marketSegmentId() const
    {
        const BlockLength offset = 17;
 
        return ordinary<UInt8>(offset);
    }

    UInt8 underlyingProduct() const
    {
        const BlockLength offset = 18;
 
        return ordinary<UInt8>(offset);
    }

    StrRef securityExchange() const
    {
        const BlockLength offset = 19;
        const BlockLength length = 4;
 
        return fixedStr<length>(offset);
    }

    StrRef securityGroup() const
    {
        const BlockLength offset = 23;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    StrRef asset() const
    {
        const BlockLength offset = 29;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    StrRef symbol() const
    {
        const BlockLength offset = 35;
        const BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    Int32 securityId() const
    {
        const BlockLength offset = 55;
 
        return ordinary<Int32>(offset);
    }

    SecurityIDSource securityIdSource() const
    {
        return SecurityIDSource();
    }

    StrRef securityType() const
    {
        const BlockLength offset = 59;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    StrRef cfiCode() const
    {
        const BlockLength offset = 65;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    StrRef currency() const
    {
        const BlockLength offset = 71;
        const BlockLength length = 3;
 
        return fixedStr<length>(offset);
    }

    StrRef settlCurrency() const
    {
        const BlockLength offset = 74;
        const BlockLength length = 3;
 
        return fixedStr<length>(offset);
    }

    StrRef priceQuoteCurrency() const
    {
        const BlockLength offset = 77;
        const BlockLength length = 3;
 
        return fixedStr<length>(offset);
    }

    CHAR matchAlgorithm() const
    {
        const BlockLength offset = 80;
 
        return ordinary<CHAR>(offset);
    }

    UInt32 minTradeVol() const
    {
        const BlockLength offset = 81;
 
        return ordinary<UInt32>(offset);
    }

    UInt32 maxTradeVol() const
    {
        const BlockLength offset = 85;
 
        return ordinary<UInt32>(offset);
    }

    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 89;
 
        return decimal<PRICE9>(offset);
    }

    Decimal displayFactor() const
    {
        const BlockLength offset = 97;
 
        return decimal<Decimal9>(offset);
    }

    UInt8 pricePrecision() const
    {
        const BlockLength offset = 105;
 
        return ordinary<UInt8>(offset);
    }

    StrRef unitOfMeasure() const
    {
        const BlockLength offset = 106;
        const BlockLength length = 30;
 
        return fixedStr<length>(offset);
    }

    bool unitOfMeasureQty(Decimal& value) const
    {
        typedef NullDecimal9 Null;
 
        const BlockLength offset = 136;
 
        return decimal(value, offset, Null());
    }

    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 144;
 
        return decimal(value, offset, Null());
    }

    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 152;
 
        return decimal(value, offset, Null());
    }

    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 160;
 
        return decimal(value, offset, Null());
    }

    UserDefinedInstrument userDefinedInstrument() const
    {
        const BlockLength offset = 168;
 
        return ordinary<UserDefinedInstrument>(offset);
    }

    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 169;
        const BlockLength length = 35;
 
        return fixedStr<length>(offset);
    }

    StrRef fxCurrencySymbol() const
    {
        const BlockLength offset = 204;
        const BlockLength length = 7;
 
        return fixedStr<length>(offset);
    }

    StrRef settlType() const
    {
        const BlockLength offset = 211;
        const BlockLength length = 3;
 
        return fixedStr<length>(offset);
    }

    UInt16 interveningDays() const
    {
        const BlockLength offset = 214;
 
        return ordinary<UInt16>(offset);
    }

    StrRef fxBenchmarkRateFix() const
    {
        const BlockLength offset = 216;
        const BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    StrRef rateSource() const
    {
        const BlockLength offset = 236;
        const BlockLength length = 12;
 
        return fixedStr<length>(offset);
    }

    StrRef fixRateLocalTime() const
    {
        const BlockLength offset = 248;
        const BlockLength length = 8;
 
        return fixedStr<length>(offset);
    }

    StrRef fixRateLocalTimeZone() const
    {
        const BlockLength offset = 256;
        const BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    UInt32 minQuoteLife() const
    {
        const BlockLength offset = 276;
 
        return ordinary<UInt32>(offset);
    }

    Decimal maxPriceDiscretionOffset() const
    {
        const BlockLength offset = 280;
 
        return decimal<PRICE9>(offset);
    }

    bool instrumentGUId(UInt64& value) const
    {
        typedef NullUInt64 Null;
 
        const BlockLength offset = 288;
 
        return ordinary(value, offset, Null());
    }

    bool maturityMonthYear(MaturityMonthYear& value) const
    {
        typedef NullMaturityMonthYear Null;
 
        const BlockLength offset = 296;
 
        return ordinary(value, offset, Null());
    }

    StrRef settlementLocale() const
    {
        const BlockLength offset = 301;
        const BlockLength length = 8;
 
        return fixedStr<length>(offset);
    }

    bool altMinPriceIncrement(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 309;
        const SchemaVersion since = 13;
 
        return decimal(value, offset, Null(), since);
    }

    bool altMinQuoteLife(UInt32& value) const
    {
        typedef NullUInt32 Null;
 
        const BlockLength offset = 317;
        const SchemaVersion since = 13;
 
        return ordinary(value, offset, Null(), since);
    }

    bool altPriceIncrementConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 321;
        const SchemaVersion since = 13;
 
        return decimal(value, offset, Null(), since);
    }

    bool maxBidAskConstraint(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 329;
        const SchemaVersion since = 13;
 
        return decimal(value, offset, Null(), since);
    }

    Events events() const
    {
        return
            groups().
                head<Events>();
    }

    FeedTypes feedTypes() const
    {
        return
            groups().
                tail<Events>().
                head<FeedTypes>();
    }

    InstAttrib instAttrib() const
    {
        return
            groups().
                tail<Events>().
                tail<FeedTypes>().
                head<InstAttrib>();
    }

    LotTypeRules lotTypeRules() const
    {
        return
            groups().
                tail<Events>().
                tail<FeedTypes>().
                tail<InstAttrib>().
                head<LotTypeRules>();
    }

    TradingSessions tradingSessions() const
    {
        return
            groups().
                tail<Events>().
                tail<FeedTypes>().
                tail<InstAttrib>().
                tail<LotTypeRules>().
                head<TradingSessions>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 13)
            return 337;
 
        return 309;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "InstrumentDefinitionFX63";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("d");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
IncrementalRefreshBookLongQty64 
: BinaryMessage
{
    enum { TemplateId = 64 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    Entry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        Entry()
        {
        }

        Entry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;
 
            const BlockLength offset = 0;
 
            return decimal(value, offset, Null());
        }

        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;
 
            const BlockLength offset = 8;
 
            return ordinary(value, offset, Null());
        }

        Int32 securityId() const
        {
            const BlockLength offset = 16;
 
            return ordinary<Int32>(offset);
        }

        UInt32 rptSeq() const
        {
            const BlockLength offset = 20;
 
            return ordinary<UInt32>(offset);
        }

        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;
 
            const BlockLength offset = 24;
 
            return ordinary(value, offset, Null());
        }

        UInt8 priceLevel() const
        {
            const BlockLength offset = 28;
 
            return ordinary<UInt8>(offset);
        }

        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 29;
 
            return enumeration<UpdateAction>(offset);
        }

        EntryTypeBook::Enum entryType() const
        {
            const BlockLength offset = 30;
 
            return enumeration<EntryTypeBook>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 31;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    OrderIDEntry : BinaryGroupEntry
    <
        GroupSize8Byte::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize8Byte::BlockLength
        >
        Base;

        OrderIDEntry()
        {
        }

        OrderIDEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        UInt64 orderId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<UInt64>(offset);
        }

        bool orderPriority(UInt64& value) const
        {
            typedef NullUInt64 Null;
 
            const BlockLength offset = 8;
 
            return ordinary(value, offset, Null());
        }

        bool displayQty(Int32& value) const
        {
            typedef NullInt32 Null;
 
            const BlockLength offset = 16;
 
            return ordinary(value, offset, Null());
        }

        bool referenceId(UInt8& value) const
        {
            typedef NullUInt8 Null;
 
            const BlockLength offset = 20;
 
            return ordinary(value, offset, Null());
        }

        OrderUpdateAction::Enum orderUpdateAction() const
        {
            const BlockLength offset = 21;
 
            return enumeration<OrderUpdateAction>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 22;
        }

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

    typedef 
    BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> 
    OrderIDEntries;

    IncrementalRefreshBookLongQty64()
    {
    }

    IncrementalRefreshBookLongQty64(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Timestamp>(offset);
    }

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    Entries entries() const
    {
        return
            groups().
                head<Entries>();
    }

    OrderIDEntries orderIdEntries() const
    {
        return
            groups().
                tail<Entries>().
                head<OrderIDEntries>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshBookLongQty64";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
IncrementalRefreshTradeSummaryLongQty65 
: BinaryMessage
{
    enum { TemplateId = 65 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    Entry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        Entry()
        {
        }

        Entry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        Decimal entryPx() const
        {
            const BlockLength offset = 0;
 
            return decimal<PRICE9>(offset);
        }

        UInt64 entrySize() const
        {
            const BlockLength offset = 8;
 
            return ordinary<UInt64>(offset);
        }

        Int32 securityId() const
        {
            const BlockLength offset = 16;
 
            return ordinary<Int32>(offset);
        }

        UInt32 rptSeq() const
        {
            const BlockLength offset = 20;
 
            return ordinary<UInt32>(offset);
        }

        Int32 numberOfOrders() const
        {
            const BlockLength offset = 24;
 
            return ordinary<Int32>(offset);
        }

        UInt32 tradeEntryId() const
        {
            const BlockLength offset = 28;
 
            return ordinary<UInt32>(offset);
        }

        bool 
        aggressorSide(
            AggressorSide::Enum& value) const
        {
            typedef NullUInt8 Null;
 
            const BlockLength offset = 32;
 
            return enumeration<AggressorSide>(value, offset, Null());
        }

        UpdateAction::Enum updateAction() const
        {
            const BlockLength offset = 33;
 
            return enumeration<UpdateAction>(offset);
        }

        EntryTypeTrade entryType() const
        {
            return EntryTypeTrade();
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 34;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    OrderIDEntry : BinaryGroupEntry
    <
        GroupSize8Byte::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize8Byte::BlockLength
        >
        Base;

        OrderIDEntry()
        {
        }

        OrderIDEntry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        UInt64 orderId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<UInt64>(offset);
        }

        Int32 lastQty() const
        {
            const BlockLength offset = 8;
 
            return ordinary<Int32>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 12;
        }

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

    typedef 
    BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> 
    OrderIDEntries;

    IncrementalRefreshTradeSummaryLongQty65()
    {
    }

    IncrementalRefreshTradeSummaryLongQty65(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Timestamp>(offset);
    }

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    Entries entries() const
    {
        return
            groups().
                head<Entries>();
    }

    OrderIDEntries orderIdEntries() const
    {
        return
            groups().
                tail<Entries>().
                head<OrderIDEntries>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshTradeSummaryLongQty65";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
SnapshotFullRefreshLongQty69 
: BinaryMessage
{
    enum { TemplateId = 69 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    Entry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        Entry()
        {
        }

        Entry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        bool entryPx(Decimal& value) const
        {
            typedef NullPRICE9 Null;
 
            const BlockLength offset = 0;
 
            return decimal(value, offset, Null());
        }

        bool entrySize(UInt64& value) const
        {
            typedef NullUInt64 Null;
 
            const BlockLength offset = 8;
 
            return ordinary(value, offset, Null());
        }

        bool numberOfOrders(Int32& value) const
        {
            typedef NullInt32 Null;
 
            const BlockLength offset = 16;
 
            return ordinary(value, offset, Null());
        }

        bool priceLevel(UInt8& value) const
        {
            typedef NullUInt8 Null;
 
            const BlockLength offset = 20;
 
            return ordinary(value, offset, Null());
        }

        bool 
        openCloseSettlFlag(
            OpenCloseSettlFlag::Enum& value) const
        {
            typedef NullUInt8 Null;
 
            const BlockLength offset = 21;
 
            return enumeration<OpenCloseSettlFlag>(value, offset, Null());
        }

        EntryType::Enum entryType() const
        {
            const BlockLength offset = 22;
 
            return enumeration<EntryType>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 23;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    SnapshotFullRefreshLongQty69()
    {
    }

    SnapshotFullRefreshLongQty69(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    UInt32 lastMsgSeqNumProcessed() const
    {
        const BlockLength offset = 0;
 
        return ordinary<UInt32>(offset);
    }

    UInt32 totNumReports() const
    {
        const BlockLength offset = 4;
 
        return ordinary<UInt32>(offset);
    }

    Int32 securityId() const
    {
        const BlockLength offset = 8;
 
        return ordinary<Int32>(offset);
    }

    UInt32 rptSeq() const
    {
        const BlockLength offset = 12;
 
        return ordinary<UInt32>(offset);
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 16;
 
        return ordinary<Timestamp>(offset);
    }

    Timestamp lastUpdateTime() const
    {
        const BlockLength offset = 24;
 
        return ordinary<Timestamp>(offset);
    }

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

    bool 
    securityTradingStatus(
        SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;
 
        const BlockLength offset = 34;
 
        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    bool highLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 35;
 
        return decimal(value, offset, Null());
    }

    bool lowLimitPrice(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 43;
 
        return decimal(value, offset, Null());
    }

    bool maxPriceVariation(Decimal& value) const
    {
        typedef NullPRICE9 Null;
 
        const BlockLength offset = 51;
 
        return decimal(value, offset, Null());
    }

    Entries entries() const
    {
        return
            groups().
                head<Entries>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 59;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "SnapshotFullRefreshLongQty69";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("W");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
ChannelReset4 
: BinaryMessage
{
    enum { TemplateId = 4 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    Entry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        Entry()
        {
        }

        Entry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        UpdateTypeNew updateAction() const
        {
            return UpdateTypeNew();
        }

        EntryTypeChannelReset entryType() const
        {
            return EntryTypeChannelReset();
        }

        Int16 applId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int16>(offset);
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 2;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    ChannelReset4()
    {
    }

    ChannelReset4(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Timestamp>(offset);
    }

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    Entries entries() const
    {
        return
            groups().
                head<Entries>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "ChannelReset4";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminHeartbeat12 
: BinaryMessage
{
    enum { TemplateId = 12 };

    AdminHeartbeat12()
    {
    }

    AdminHeartbeat12(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 0;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminHeartbeat12";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("0");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminLogin15 
: BinaryMessage
{
    enum { TemplateId = 15 };

    AdminLogin15()
    {
    }

    AdminLogin15(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Int8 heartBtInt() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Int8>(offset);
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 1;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogin15";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("A");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
AdminLogout16 
: BinaryMessage
{
    enum { TemplateId = 16 };

    AdminLogout16()
    {
    }

    AdminLogout16(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    StrRef text() const
    {
        const BlockLength offset = 0;
        const BlockLength length = 180;
 
        return fixedStr<length>(offset);
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogout16";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("5");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
SecurityStatus30 
: BinaryMessage
{
    enum { TemplateId = 30 };

    SecurityStatus30()
    {
    }

    SecurityStatus30(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Timestamp>(offset);
    }

    StrRef securityGroup() const
    {
        const BlockLength offset = 8;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    StrRef asset() const
    {
        const BlockLength offset = 14;
        const BlockLength length = 6;
 
        return fixedStr<length>(offset);
    }

    bool securityId(Int32& value) const
    {
        typedef NullInt32 Null;
 
        const BlockLength offset = 20;
 
        return ordinary(value, offset, Null());
    }

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

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 26;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    bool 
    securityTradingStatus(
        SecurityTradingStatus::Enum& value) const
    {
        typedef NullUInt8 Null;
 
        const BlockLength offset = 27;
 
        return enumeration<SecurityTradingStatus>(value, offset, Null());
    }

    HaltReason::Enum haltReason() const
    {
        const BlockLength offset = 28;
 
        return enumeration<HaltReason>(offset);
    }

    SecurityTradingEvent::Enum 
    securityTradingEvent() const
    {
        const BlockLength offset = 29;
 
        return enumeration<SecurityTradingEvent>(offset);
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 30;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "SecurityStatus30";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("f");
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT 
IncrementalRefreshLimitsBanding50 
: BinaryMessage
{
    enum { TemplateId = 50 };

    ONIXS_CONFLATEDUDP_LTWT_STRUCT 
    Entry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        Entry()
        {
        }

        Entry(
            const void* data, 
            EncodedLength length, 
            SchemaVersion version)
          : Base(data, length, version)
        {
            if (length < blockLength(version))
                throwBadBinaryData(className());
        }

        bool highLimitPrice(Decimal& value) const
        {
            typedef NullPRICE9 Null;
 
            const BlockLength offset = 0;
 
            return decimal(value, offset, Null());
        }

        bool lowLimitPrice(Decimal& value) const
        {
            typedef NullPRICE9 Null;
 
            const BlockLength offset = 8;
 
            return decimal(value, offset, Null());
        }

        bool maxPriceVariation(Decimal& value) const
        {
            typedef NullPRICE9 Null;
 
            const BlockLength offset = 16;
 
            return decimal(value, offset, Null());
        }

        Int32 securityId() const
        {
            const BlockLength offset = 24;
 
            return ordinary<Int32>(offset);
        }

        UInt32 rptSeq() const
        {
            const BlockLength offset = 28;
 
            return ordinary<UInt32>(offset);
        }

        UpdateActionNew updateAction() const
        {
            return UpdateActionNew();
        }

        EntryTypeLimits entryType() const
        {
            return EntryTypeLimits();
        }

        ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 32;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshLimitsBanding50()
    {
    }

    IncrementalRefreshLimitsBanding50(
        const void* data, 
        EncodedLength length)
      : BinaryMessage(data, length)
    {
        assert(TemplateId == templateId());
 
        if (length < blockLength(version()))
            throwBadBinaryData(className());
    }

    Timestamp transactTime() const
    {
        const BlockLength offset = 0;
 
        return ordinary<Timestamp>(offset);
    }

    MatchEventIndicator matchEventIndicator() const
    {
        const BlockLength offset = 8;
 
        return ordinary<MatchEventIndicator>(offset);
    }

    Entries entries() const
    {
        return
            groups().
                head<Entries>();
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 9;
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshLimitsBanding50";
    }

    ONIXS_CONFLATEDUDP_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("X");
    }
};
 
 
ONIXS_CONFLATEDUDP_NAMESPACE_END