Messages.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is 
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable 
// OnixS Software Services Agreement (the Agreement) and Customer end user license 
// agreements granting a non-assignable, non-transferable and non-exclusive license 
// to use the software for it's own data processing purposes under the terms defined 
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or 
// reproduction of any part of this source code or associated reference material 
// to any other location for further reproduction or redistribution, and any 
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in 
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <cassert>
#include <stdexcept>
 
#include <OnixS/CME/Streamlined/Composites.h>
#include <OnixS/CME/Streamlined/BinaryMessage.h>
 
ONIXS_CMESTREAMLINEDMDH_NAMESPACE_BEGIN

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminHeartbeat312 
: BinaryMessage
{
    enum { TemplateId = 312 };

    AdminHeartbeat312()
    {
    }

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

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminHeartbeat312";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminLogin315 
: BinaryMessage
{
    enum { TemplateId = 315 };

    AdminLogin315()
    {
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogin315";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
AdminLogout316 
: BinaryMessage
{
    enum { TemplateId = 316 };

    AdminLogout316()
    {
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "AdminLogout316";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshErisReferenceDataAndDailyStatistics333 
: BinaryMessage
{
    enum { TemplateId = 333 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            SecurityAltIDEntry()
            {
            }

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

            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;
 
                return fixedStr<length>(value, offset);
            }

            bool securityAltIdSource(CharNULL& value) const
            {
                typedef NullCharNULL Null;
 
                const BlockLength offset = 26;
 
                return ordinary(value, offset, Null());
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 27;
            }

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

        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        RelatedInstrumentsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            RelatedInstrumentsEntry()
            {
            }

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

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

            bool relatedSymbol(StrRef& value) const
            {
                const BlockLength offset = 1;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            bool relatedSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 51;
                const BlockLength length = 26;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 77;
            }

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

        typedef 
        BinaryGroup<RelatedInstrumentsEntry, GroupSize, MessageSize> 
        RelatedInstruments;

        ONIXS_CMESTREAMLINEDMDH_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());
            }

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

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

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

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

        typedef 
        BinaryGroup<EventsEntry, GroupSize, MessageSize> 
        Events;

        CHAR updateAction() const
        {
            const BlockLength offset = 0;
 
            return ordinary<CHAR>(offset);
        }

        CHAR entryType() const
        {
            const BlockLength offset = 1;
 
            return ordinary<CHAR>(offset);
        }

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

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

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

        SettlPriceType settlPriceType() const
        {
            const BlockLength offset = 16;
 
            return ordinary<SettlPriceType>(offset);
        }

        bool calFutPx(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 17;
 
            return decimal(value, offset, Null());
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 26;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 134;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

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

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 161;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

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

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 174;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32NULL Null;
 
            const BlockLength offset = 176;
 
            return decimal(value, offset, Null());
        }

        bool tradeDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 181;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool fairCouponPct(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 183;
 
            return decimal(value, offset, Null());
        }

        bool legPurchaseRate(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 192;
 
            return decimal(value, offset, Null());
        }

        bool fixedNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 201;
 
            return decimal(value, offset, Null());
        }

        bool floatNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 210;
 
            return decimal(value, offset, Null());
        }

        bool npv(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 219;
 
            return decimal(value, offset, Null());
        }

        bool accruedCoupons(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 228;
 
            return decimal(value, offset, Null());
        }

        bool dailyIncrementalErisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 237;
 
            return decimal(value, offset, Null());
        }

        bool erisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 246;
 
            return decimal(value, offset, Null());
        }

        bool fedFundsRate(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 255;
 
            return decimal(value, offset, Null());
        }

        bool minPriceIncrement(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 264;
 
            return decimal(value, offset, Null());
        }

        bool fixedPayment(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 273;
 
            return decimal(value, offset, Null());
        }

        bool floatingPayment(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 282;
 
            return decimal(value, offset, Null());
        }

        bool nextFixedPaymentDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 291;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool nextFixedPaymentAmount(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 293;
 
            return decimal(value, offset, Null());
        }

        bool nextFloatingPaymentAmount(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 302;
 
            return decimal(value, offset, Null());
        }

        bool tradingReferenceDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 311;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool previousErisPAI(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 313;
 
            return decimal(value, offset, Null());
        }

        bool fedFundsDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 322;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

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

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

        bool legCreditRating(StrRef& value) const
        {
            const BlockLength offset = 336;
            const BlockLength length = 6;
 
            return fixedStr<length>(value, offset);
        }

        bool legContractMultiplier(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 342;
 
            return decimal(value, offset, Null());
        }

        bool nextFloatingPaymentDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 351;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool pV01(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 353;
 
            return decimal(value, offset, Null());
        }

        bool dV01(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 362;
 
            return decimal(value, offset, Null());
        }

        bool settlementNPV(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 371;
 
            return decimal(value, offset, Null());
        }

        bool finalSettlementFuturesPrice(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 380;
 
            return decimal(value, offset, Null());
        }

        bool securityDescription(StrRef& value) const
        {
            const BlockLength offset = 389;
            const BlockLength length = 30;
 
            return fixedStr<length>(value, offset);
        }

        SecurityAltID securityAltId() const
        {
            return
                groups().
                    head<SecurityAltID>();
        }

        RelatedInstruments relatedInstruments() const
        {
            return
                groups().
                    tail<SecurityAltID>().
                    head<RelatedInstruments>();
        }

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 419;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshErisReferenceDataAndDailyStatistics333()
    {
    }

    IncrementalRefreshErisReferenceDataAndDailyStatistics333(
        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);
    }

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 9;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 11;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshErisReferenceDataAndDailyStatistics333";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
NewsIndices339 
: BinaryMessage
{
    enum { TemplateId = 339 };

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    RelatedSymEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        RelatedSymEntry()
        {
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 50;
        }

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

    typedef 
    BinaryGroup<RelatedSymEntry, GroupSize, MessageSize> 
    RelatedSym;

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    LinesOfTextEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        LinesOfTextEntry()
        {
        }

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

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 500;
        }

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

    typedef 
    BinaryGroup<LinesOfTextEntry, GroupSize, MessageSize> 
    LinesOfText;

    NewsIndices339()
    {
    }

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

    bool headline(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 50;
 
        return fixedStr<length>(value, offset);
    }

    bool origTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;
 
        const BlockLength offset = 50;
 
        return ordinary(value, offset, Null());
    }

    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 58;
        const BlockLength length = 2;
 
        return fixedStr<length>(value, offset);
    }

    RelatedSym relatedSym() const
    {
        return
            groups().
                head<RelatedSym>();
    }

    LinesOfText linesOfText() const
    {
        return
            groups().
                tail<RelatedSym>().
                head<LinesOfText>();
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 60;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "NewsIndices339";
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("B");
    }
};

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks340 
: BinaryMessage
{
    enum { TemplateId = 340 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        UnderlyingsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            UnderlyingsEntry()
            {
            }

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

            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 68;
            }

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

        typedef 
        BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> 
        Underlyings;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            PartyIDsEntry()
            {
            }

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

            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 52;
            }

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

        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        LegsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            LegsEntry()
            {
            }

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

            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;
 
                return fixedStr<length>(value, offset);
            }

            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;
 
                return fixedStr<length>(value, offset);
            }

            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

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

            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;
 
                const BlockLength offset = 101;
 
                FieldValue fieldValue;
 
                if (ordinary(fieldValue, offset, Null()))
                {
                    value = localMktDateToTimestamp(fieldValue);
                    return true;
                }
                return false;
            }

            bool legStrikePrice(Decimal& value) const
            {
                typedef NullPRICENULL Null;
 
                const BlockLength offset = 103;
 
                return decimal(value, offset, Null());
            }

            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 111;
                const BlockLength length = 5;
 
                return fixedStr<length>(value, offset);
            }

            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullPRICENULL Null;
 
                const BlockLength offset = 116;
 
                return decimal(value, offset, Null());
            }

            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 124;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;
 
                const BlockLength offset = 128;
 
                return ordinary(value, offset, Null());
            }

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

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

            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 132;
                const BlockLength length = 3;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 135;
            }

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

        typedef 
        BinaryGroup<LegsEntry, GroupSize, MessageSize> 
        Legs;

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

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

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

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

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

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

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

        Int32 tradeId() const
        {
            const BlockLength offset = 33;
 
            return ordinary<Int32>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 38;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 88;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 100;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

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

        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 116;
            const BlockLength length = 4;
 
            return fixedStr<length>(value, offset);
        }

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 120;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 122;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 3;
 
            return fixedStr<length>(value, offset);
        }

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

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 138;
 
            return decimal(value, offset, Null());
        }

        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 142;
 
            return ordinary(value, offset, Null());
        }

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

        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 145;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

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

        bool strikePrice(Decimal& value) const
        {
            typedef NullPRICENULL Null;
 
            const BlockLength offset = 172;
 
            return decimal(value, offset, Null());
        }

        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 184;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 284;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 310;
            const BlockLength length = 17;
 
            return fixedStr<length>(value, offset);
        }

        Underlyings underlyings() const
        {
            return
                groups().
                    head<Underlyings>();
        }

        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 327;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshTradeBlocks340()
    {
    }

    IncrementalRefreshTradeBlocks340(
        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);
    }

    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;
 
        return ordinary<UInt16>(offset);
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 11;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshTradeBlocks340";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
QuoteRequest345 
: BinaryMessage
{
    enum { TemplateId = 345 };

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    RelatedSymEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        RelatedSymEntry()
        {
        }

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

        ONIXS_CMESTREAMLINEDMDH_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());
            }

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

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

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

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

        typedef 
        BinaryGroup<EventsEntry, GroupSize, MessageSize> 
        Events;

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 50;
 
            return decimal(value, offset, Null());
        }

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

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

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

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 67;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 93;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 4;
 
            return fixedStr<length>(value, offset);
        }

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

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 100;
        }

        RelatedSymEntry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return RelatedSymEntry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<RelatedSymEntry, GroupSize, MessageSize> 
    RelatedSym;

    QuoteRequest345()
    {
    }

    QuoteRequest345(
        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);
    }

    bool quoteReqId(StrRef& value) const
    {
        const BlockLength offset = 9;
        const BlockLength length = 26;
 
        return fixedStr<length>(value, offset);
    }

    RelatedSym relatedSym() const
    {
        return
            groups().
                head<RelatedSym>();
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 35;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "QuoteRequest345";
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static StrRef fixType()
    {
        return toStrRef("R");
    }
};

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
InstrumentDefinitionIndices347 
: BinaryMessage
{
    enum { TemplateId = 347 };

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    InstAttribEntry : BinaryGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        InstAttribEntry()
        {
        }

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

        UInt8 instAttribType() const
        {
            const BlockLength offset = 0;
 
            return ordinary<UInt8>(offset);
        }

        bool instAttribValue(StrRef& value) const
        {
            const BlockLength offset = 1;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 101;
        }

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

    typedef 
    BinaryGroup<InstAttribEntry, GroupSizeEncoding, MessageSize> 
    InstAttrib;

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    EventsEntry : BinaryGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        EventsEntry()
        {
        }

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

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

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

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

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

    typedef 
    BinaryGroup<EventsEntry, GroupSizeEncoding, MessageSize> 
    Events;

    InstrumentDefinitionIndices347()
    {
    }

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

    bool symbol(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 50;
 
        return fixedStr<length>(value, offset);
    }

    Int8 product() const
    {
        const BlockLength offset = 50;
 
        return ordinary<Int8>(offset);
    }

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

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

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

    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 59;
        const BlockLength length = 2;
 
        return fixedStr<length>(value, offset);
    }

    bool applId(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 61;
 
        return ordinary(value, offset, Null());
    }

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

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 63;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "InstrumentDefinitionIndices347";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshIndices348 
: BinaryMessage
{
    enum { TemplateId = 348 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

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

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

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

        Decimal entryPx() const
        {
            const BlockLength offset = 5;
 
            return decimal<Decimal64>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool openCloseSettlFlag(Int8& value) const
        {
            typedef NullInt8 Null;
 
            const BlockLength offset = 72;
 
            return ordinary(value, offset, Null());
        }

        bool yieldType(StrRef& value) const
        {
            const BlockLength offset = 73;
            const BlockLength length = 8;
 
            return fixedStr<length>(value, offset);
        }

        Decimal yield() const
        {
            const BlockLength offset = 81;
 
            return decimal<Decimal64>(offset);
        }

        Decimal netChgPrevDay() const
        {
            const BlockLength offset = 90;
 
            return decimal<Decimal64>(offset);
        }

        Decimal netPctChg() const
        {
            const BlockLength offset = 99;
 
            return decimal<Decimal64>(offset);
        }

        Decimal percentTrading() const
        {
            const BlockLength offset = 108;
 
            return decimal<Decimal64>(offset);
        }

        bool entryCode(EntryCode::Enum& value) const
        {
            typedef NullUInt8 Null;
 
            const BlockLength offset = 117;
 
            return enumeration<EntryCode>(value, offset, Null());
        }

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

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

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 126;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 176;
        }

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

    typedef 
    BinaryGroup<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshIndices348()
    {
    }

    IncrementalRefreshIndices348(
        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);
    }

    bool feedType(StrRef& value) const
    {
        const BlockLength offset = 8;
        const BlockLength length = 2;
 
        return fixedStr<length>(value, offset);
    }

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

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 11;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 13;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshIndices348";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks349 
: BinaryMessage
{
    enum { TemplateId = 349 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        UnderlyingsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            UnderlyingsEntry()
            {
            }

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

            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 68;
            }

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

        typedef 
        BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> 
        Underlyings;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            PartyIDsEntry()
            {
            }

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

            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 52;
            }

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

        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        LegsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            LegsEntry()
            {
            }

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

            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;
 
                return fixedStr<length>(value, offset);
            }

            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;
 
                return fixedStr<length>(value, offset);
            }

            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

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

            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;
 
                const BlockLength offset = 101;
 
                FieldValue fieldValue;
 
                if (ordinary(fieldValue, offset, Null()))
                {
                    value = localMktDateToTimestamp(fieldValue);
                    return true;
                }
                return false;
            }

            bool legStrikePrice(Decimal& value) const
            {
                typedef NullPRICENULL Null;
 
                const BlockLength offset = 103;
 
                return decimal(value, offset, Null());
            }

            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 111;
                const BlockLength length = 5;
 
                return fixedStr<length>(value, offset);
            }

            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullPRICENULL Null;
 
                const BlockLength offset = 116;
 
                return decimal(value, offset, Null());
            }

            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 124;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;
 
                const BlockLength offset = 128;
 
                return ordinary(value, offset, Null());
            }

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

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

            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 132;
                const BlockLength length = 3;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 135;
            }

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

        typedef 
        BinaryGroup<LegsEntry, GroupSize, MessageSize> 
        Legs;

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

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

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

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

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

        Decimal entrySize() const
        {
            const BlockLength offset = 21;
 
            return decimal<Decimal64>(offset);
        }

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

        Int32 tradeId() const
        {
            const BlockLength offset = 34;
 
            return ordinary<Int32>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 39;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 89;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 101;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 110;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

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

        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 117;
            const BlockLength length = 4;
 
            return fixedStr<length>(value, offset);
        }

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 121;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 123;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 128;
            const BlockLength length = 3;
 
            return fixedStr<length>(value, offset);
        }

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

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 139;
 
            return decimal(value, offset, Null());
        }

        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 143;
 
            return ordinary(value, offset, Null());
        }

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

        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 146;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

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

        bool strikePrice(Decimal& value) const
        {
            typedef NullPRICENULL Null;
 
            const BlockLength offset = 173;
 
            return decimal(value, offset, Null());
        }

        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 181;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 183;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 185;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 285;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 311;
            const BlockLength length = 17;
 
            return fixedStr<length>(value, offset);
        }

        Underlyings underlyings() const
        {
            return
                groups().
                    head<Underlyings>();
        }

        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 328;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshTradeBlocks349()
    {
    }

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

    bool transactTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;
 
        const BlockLength offset = 0;
 
        return ordinary(value, offset, Null());
    }

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

    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;
 
        return ordinary<UInt16>(offset);
    }

    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;
 
        const BlockLength offset = 11;
 
        FieldValue fieldValue;
 
        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 13;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshTradeBlocks349";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshEris351 
: BinaryMessage
{
    enum { TemplateId = 351 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            SecurityAltIDEntry()
            {
            }

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

            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;
 
                return fixedStr<length>(value, offset);
            }

            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 26;
                const BlockLength length = 1;
 
                return fixedStr<length>(offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 27;
            }

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

        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        ONIXS_CMESTREAMLINEDMDH_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());
            }

            UInt8 eventType() const
            {
                const BlockLength offset = 0;
 
                return ordinary<UInt8>(offset);
            }

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

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

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

        typedef 
        BinaryGroup<EventsEntry, GroupSize, MessageSize> 
        Events;

        CHAR updateAction() const
        {
            const BlockLength offset = 0;
 
            return ordinary<CHAR>(offset);
        }

        CHAR entryType() const
        {
            const BlockLength offset = 1;
 
            return ordinary<CHAR>(offset);
        }

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

        Decimal entryPx() const
        {
            const BlockLength offset = 6;
 
            return decimal<Decimal64>(offset);
        }

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

        Decimal calFutPx() const
        {
            const BlockLength offset = 23;
 
            return decimal<Decimal64>(offset);
        }

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

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

        Int32 tradeId() const
        {
            const BlockLength offset = 40;
 
            return ordinary<Int32>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 45;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 121;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

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

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

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 135;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 137;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        SecurityAltID securityAltId() const
        {
            return
                groups().
                    head<SecurityAltID>();
        }

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 187;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshEris351()
    {
    }

    IncrementalRefreshEris351(
        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);
    }

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 9;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 11;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshEris351";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshEris353 
: BinaryMessage
{
    enum { TemplateId = 353 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            SecurityAltIDEntry()
            {
            }

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

            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;
 
                return fixedStr<length>(value, offset);
            }

            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 26;
                const BlockLength length = 1;
 
                return fixedStr<length>(offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 27;
            }

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

        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

        ONIXS_CMESTREAMLINEDMDH_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());
            }

            UInt8 eventType() const
            {
                const BlockLength offset = 0;
 
                return ordinary<UInt8>(offset);
            }

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

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

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

        typedef 
        BinaryGroup<EventsEntry, GroupSize, MessageSize> 
        Events;

        CHAR updateAction() const
        {
            const BlockLength offset = 0;
 
            return ordinary<CHAR>(offset);
        }

        CHAR entryType() const
        {
            const BlockLength offset = 1;
 
            return ordinary<CHAR>(offset);
        }

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

        Decimal entryPx() const
        {
            const BlockLength offset = 6;
 
            return decimal<Decimal64>(offset);
        }

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

        Decimal calFutPx() const
        {
            const BlockLength offset = 23;
 
            return decimal<Decimal64>(offset);
        }

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

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

        Int32 tradeId() const
        {
            const BlockLength offset = 40;
 
            return ordinary<Int32>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 45;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 95;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 121;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

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

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

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 135;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 137;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

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

        SecurityAltID securityAltId() const
        {
            return
                groups().
                    head<SecurityAltID>();
        }

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 188;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = events().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshEris353()
    {
    }

    IncrementalRefreshEris353(
        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);
    }

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 9;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 11;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshEris353";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshOTC356 
: BinaryMessage
{
    enum { TemplateId = 356 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        UnderlyingsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            UnderlyingsEntry()
            {
            }

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

            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

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

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 68;
            }

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

        typedef 
        BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> 
        Underlyings;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            SecurityAltIDEntry()
            {
            }

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

            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 50;
                const BlockLength length = 1;
 
                return fixedStr<length>(offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 51;
            }

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

        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

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

        CHAR entryType() const
        {
            const BlockLength offset = 0;
 
            return ordinary<CHAR>(offset);
        }

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

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

        Decimal entrySize() const
        {
            const BlockLength offset = 13;
 
            return decimal<Decimal64>(offset);
        }

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 72;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

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

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

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

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 103;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 105;
 
            return decimal(value, offset, Null());
        }

        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 111;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool tionalPercentageOutstanding(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 113;
 
            return decimal(value, offset, Null());
        }

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

        Decimal strikePrice() const
        {
            const BlockLength offset = 118;
 
            return decimal<Decimal64>(offset);
        }

        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

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

        Decimal unitOfMeasureQty() const
        {
            const BlockLength offset = 135;
 
            return decimal<Decimal64>(offset);
        }

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

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

        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 149;
 
            return ordinary(value, offset, Null());
        }

        bool settlDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 151;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        CHAR quoteCondition() const
        {
            const BlockLength offset = 153;
 
            return ordinary<CHAR>(offset);
        }

        bool marketSector(StrRef& value) const
        {
            const BlockLength offset = 154;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool sectorGroup(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool sectorSubGroup(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool productComplex(StrRef& value) const
        {
            const BlockLength offset = 208;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 234;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool volType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 236;
 
            return ordinary(value, offset, Null());
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 238;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        Underlyings underlyings() const
        {
            return
                groups().
                    head<Underlyings>();
        }

        SecurityAltID securityAltId() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<SecurityAltID>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 338;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = securityAltId().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

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

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshOTC356()
    {
    }

    IncrementalRefreshOTC356(
        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);
    }

    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;
 
        const BlockLength offset = 8;
 
        FieldValue fieldValue;
 
        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

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

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 11;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 13;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshOTC356";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
InstrumentDefinitionEris363 
: BinaryMessage
{
    enum { TemplateId = 363 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

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

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

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

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

    typedef 
    BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> 
    FeedTypes;

    ONIXS_CMESTREAMLINEDMDH_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());
        }

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

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

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

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

    typedef 
    BinaryGroup<EventsEntry, GroupSize, MessageSize> 
    Events;

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    SecurityAltIDEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        SecurityAltIDEntry()
        {
        }

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

        bool securityAltId(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        StrRef securityAltIdSource() const
        {
            const BlockLength offset = 26;
            const BlockLength length = 1;
 
            return fixedStr<length>(offset);
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 27;
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionEris363.SecurityAltIDEntry";
        }
    };

    typedef 
    BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
    SecurityAltID;

    ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
    LegsEntry : BinaryGroupEntry
    <
        GroupSize::BlockLength
    >
    {
        typedef 
        BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        Base;

        LegsEntry()
        {
        }

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

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        LegSecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            LegSecurityAltIDEntry()
            {
            }

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

            bool legSecurityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 26;
 
                return fixedStr<length>(value, offset);
            }

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

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 27;
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static const Char* className()
            {
                return "Legs.LegSecurityAltIDEntry";
            }
        };

        typedef 
        BinaryGroup<LegSecurityAltIDEntry, GroupSize, MessageSize> 
        LegSecurityAltID;

        bool legBenchmarkCurveName(StrRef& value) const
        {
            const BlockLength offset = 0;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

        bool rateDescriptor(StrRef& value) const
        {
            const BlockLength offset = 5;
            const BlockLength length = 8;
 
            return fixedStr<length>(value, offset);
        }

        bool previousFixingDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 13;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool legPayFrequencey(StrRef& value) const
        {
            const BlockLength offset = 15;
            const BlockLength length = 3;
 
            return fixedStr<length>(value, offset);
        }

        Decimal previousFixingRate() const
        {
            const BlockLength offset = 18;
 
            return decimal<Decimal64>(offset);
        }

        bool legSymbol(StrRef& value) const
        {
            const BlockLength offset = 27;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

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

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

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

        bool legSecurityType(StrRef& value) const
        {
            const BlockLength offset = 85;
            const BlockLength length = 8;
 
            return fixedStr<length>(value, offset);
        }

        bool legSecurityGroup(StrRef& value) const
        {
            const BlockLength offset = 93;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool legDateOffset(Int8& value) const
        {
            typedef NullInt8 Null;
 
            const BlockLength offset = 105;
 
            return ordinary(value, offset, Null());
        }

        Decimal interpolationFactor() const
        {
            const BlockLength offset = 106;
 
            return decimal<Decimal64>(offset);
        }

        LegSecurityAltID legSecurityAltId() const
        {
            return
                groups().
                    head<LegSecurityAltID>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 115;
        }

        LegsEntry next(SchemaVersion) const
        {
            const void* body = legSecurityAltId().end().get().body();
            return LegsEntry(
                body, 
                blockLength(version()), 
                version());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "InstrumentDefinitionEris363.LegsEntry";
        }
    };

    typedef 
    BinaryGroupWithNested<LegsEntry, GroupSize, MessageSize> 
    Legs;

    InstrumentDefinitionEris363()
    {
    }

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

    bool securityGroup(StrRef& value) const
    {
        const BlockLength offset = 0;
        const BlockLength length = 12;
 
        return fixedStr<length>(value, offset);
    }

    bool symbol(StrRef& value) const
    {
        const BlockLength offset = 12;
        const BlockLength length = 50;
 
        return fixedStr<length>(value, offset);
    }

    bool securityType(StrRef& value) const
    {
        const BlockLength offset = 62;
        const BlockLength length = 4;
 
        return fixedStr<length>(value, offset);
    }

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

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

    bool maturityDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;
 
        const BlockLength offset = 71;
 
        FieldValue fieldValue;
 
        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

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

    Decimal minPriceIncrement() const
    {
        const BlockLength offset = 76;
 
        return decimal<Decimal64>(offset);
    }

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

    bool rateType(StrRef& value) const
    {
        const BlockLength offset = 86;
        const BlockLength length = 2;
 
        return fixedStr<length>(value, offset);
    }

    bool couponRate(Decimal& value) const
    {
        typedef NullDecimal32 Null;
 
        const BlockLength offset = 88;
 
        return decimal(value, offset, Null());
    }

    bool userDefinedInstrument(ErisUDI& value) const
    {
        typedef NullErisUDI Null;
 
        const BlockLength offset = 92;
 
        return ordinary(value, offset, Null());
    }

    bool applId(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 93;
 
        return ordinary(value, offset, Null());
    }

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

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

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

    Legs legs() const
    {
        return
            groups().
                tail<FeedTypes>().
                tail<Events>().
                tail<SecurityAltID>().
                head<Legs>();
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 95;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "InstrumentDefinitionEris363";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshTradeBlocks365 
: BinaryMessage
{
    enum { TemplateId = 365 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        UnderlyingsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            UnderlyingsEntry()
            {
            }

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

            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

            bool underlyingSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 64;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 68;
            }

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

        typedef 
        BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> 
        Underlyings;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        PartyIDsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            PartyIDsEntry()
            {
            }

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

            bool partyId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            bool partyRole(StrRef& value) const
            {
                const BlockLength offset = 50;
                const BlockLength length = 2;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 52;
            }

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

        typedef 
        BinaryGroup<PartyIDsEntry, GroupSize, MessageSize> 
        PartyIDs;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        LegsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            LegsEntry()
            {
            }

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

            bool legSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            LegSecurityIDSource legSecurityIdSource() const
            {
                return LegSecurityIDSource();
            }

            bool legSecurityGroup(StrRef& value) const
            {
                const BlockLength offset = 58;
                const BlockLength length = 12;
 
                return fixedStr<length>(value, offset);
            }

            bool legId(StrRef& value) const
            {
                const BlockLength offset = 70;
                const BlockLength length = 17;
 
                return fixedStr<length>(value, offset);
            }

            bool legSecurityType(StrRef& value) const
            {
                const BlockLength offset = 87;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

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

            bool legMaturityDate(Timestamp& value) const
            {
                typedef NullLocalMktDate Null;
                typedef LocalMktDate FieldValue;
 
                const BlockLength offset = 101;
 
                FieldValue fieldValue;
 
                if (ordinary(fieldValue, offset, Null()))
                {
                    value = localMktDateToTimestamp(fieldValue);
                    return true;
                }
                return false;
            }

            bool legStrikePrice(Decimal& value) const
            {
                typedef NullDecimal64 Null;
 
                const BlockLength offset = 103;
 
                return decimal(value, offset, Null());
            }

            bool legUnitOfMeasure(StrRef& value) const
            {
                const BlockLength offset = 112;
                const BlockLength length = 5;
 
                return fixedStr<length>(value, offset);
            }

            bool legUnitOfMeasureQty(Decimal& value) const
            {
                typedef NullDecimal64 Null;
 
                const BlockLength offset = 117;
 
                return decimal(value, offset, Null());
            }

            bool legSecurityExchange(StrRef& value) const
            {
                const BlockLength offset = 126;
                const BlockLength length = 4;
 
                return fixedStr<length>(value, offset);
            }

            bool legRatioQty(UInt16& value) const
            {
                typedef NullUInt16 Null;
 
                const BlockLength offset = 130;
 
                return ordinary(value, offset, Null());
            }

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

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

            bool legUnitOfMeasureCurrency(StrRef& value) const
            {
                const BlockLength offset = 134;
                const BlockLength length = 3;
 
                return fixedStr<length>(value, offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 137;
            }

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

        typedef 
        BinaryGroup<LegsEntry, GroupSize, MessageSize> 
        Legs;

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

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

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

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

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

        Decimal entrySize() const
        {
            const BlockLength offset = 21;
 
            return decimal<Decimal64>(offset);
        }

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

        Int32 tradeId() const
        {
            const BlockLength offset = 34;
 
            return ordinary<Int32>(offset);
        }

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

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 39;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 89;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 101;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 110;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

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

        bool securityExchange(StrRef& value) const
        {
            const BlockLength offset = 117;
            const BlockLength length = 4;
 
            return fixedStr<length>(value, offset);
        }

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 121;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 123;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

        bool unitOfMeasureCurrency(StrRef& value) const
        {
            const BlockLength offset = 128;
            const BlockLength length = 3;
 
            return fixedStr<length>(value, offset);
        }

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

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 140;
 
            return decimal(value, offset, Null());
        }

        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 144;
 
            return ordinary(value, offset, Null());
        }

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

        bool entryId(StrRef& value) const
        {
            const BlockLength offset = 147;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

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

        bool strikePrice(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 174;
 
            return decimal(value, offset, Null());
        }

        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 183;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 185;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 187;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        bool strategyLinkId(StrRef& value) const
        {
            const BlockLength offset = 287;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool legRefId(StrRef& value) const
        {
            const BlockLength offset = 313;
            const BlockLength length = 17;
 
            return fixedStr<length>(value, offset);
        }

        Underlyings underlyings() const
        {
            return
                groups().
                    head<Underlyings>();
        }

        PartyIDs partyIds() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<PartyIDs>();
        }

        Legs legs() const
        {
            return
                groups().
                    tail<Underlyings>().
                    tail<PartyIDs>().
                    head<Legs>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 330;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = legs().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshTradeBlocks365.Entry";
        }
    };

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshTradeBlocks365()
    {
    }

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

    bool transactTime(Timestamp& value) const
    {
        typedef NullUInt64 Null;
 
        const BlockLength offset = 0;
 
        return ordinary(value, offset, Null());
    }

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

    UInt16 batchTotalMessages() const
    {
        const BlockLength offset = 9;
 
        return ordinary<UInt16>(offset);
    }

    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;
 
        const BlockLength offset = 11;
 
        FieldValue fieldValue;
 
        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 13;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshTradeBlocks365";
    }

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

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
IncrementalRefreshOTC366 
: BinaryMessage
{
    enum { TemplateId = 366 };

    ONIXS_CMESTREAMLINEDMDH_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());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        UnderlyingsEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            UnderlyingsEntry()
            {
            }

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

            bool underlyingSymbol(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

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

            bool underlyingSecurityType(StrRef& value) const
            {
                const BlockLength offset = 55;
                const BlockLength length = 9;
 
                return fixedStr<length>(value, offset);
            }

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

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 68;
            }

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

        typedef 
        BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> 
        Underlyings;

        ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT 
        SecurityAltIDEntry : BinaryGroupEntry
        <
            GroupSize::BlockLength
        >
        {
            typedef 
            BinaryGroupEntry
            <
                GroupSize::BlockLength
            >
            Base;

            SecurityAltIDEntry()
            {
            }

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

            bool securityAltId(StrRef& value) const
            {
                const BlockLength offset = 0;
                const BlockLength length = 50;
 
                return fixedStr<length>(value, offset);
            }

            StrRef securityAltIdSource() const
            {
                const BlockLength offset = 50;
                const BlockLength length = 1;
 
                return fixedStr<length>(offset);
            }

            ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
            static BlockLength blockLength(SchemaVersion)
            {
                return 51;
            }

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

        typedef 
        BinaryGroup<SecurityAltIDEntry, GroupSize, MessageSize> 
        SecurityAltID;

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

        CHAR entryType() const
        {
            const BlockLength offset = 0;
 
            return ordinary<CHAR>(offset);
        }

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

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

        Decimal entrySize() const
        {
            const BlockLength offset = 13;
 
            return decimal<Decimal64>(offset);
        }

        bool symbol(StrRef& value) const
        {
            const BlockLength offset = 22;
            const BlockLength length = 50;
 
            return fixedStr<length>(value, offset);
        }

        bool securityGroup(StrRef& value) const
        {
            const BlockLength offset = 72;
            const BlockLength length = 12;
 
            return fixedStr<length>(value, offset);
        }

        bool securityType(StrRef& value) const
        {
            const BlockLength offset = 84;
            const BlockLength length = 9;
 
            return fixedStr<length>(value, offset);
        }

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

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

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

        bool maturityDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 103;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        bool couponRate(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 105;
 
            return decimal(value, offset, Null());
        }

        bool restructuringType(StrRef& value) const
        {
            const BlockLength offset = 109;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool seniority(StrRef& value) const
        {
            const BlockLength offset = 111;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool tionalPercentageOutstanding(Decimal& value) const
        {
            typedef NullDecimal32 Null;
 
            const BlockLength offset = 113;
 
            return decimal(value, offset, Null());
        }

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

        bool strikePrice(Decimal& value) const
        {
            typedef NullDecimal64 Null;
 
            const BlockLength offset = 118;
 
            return decimal(value, offset, Null());
        }

        bool unitOfMeasure(StrRef& value) const
        {
            const BlockLength offset = 127;
            const BlockLength length = 5;
 
            return fixedStr<length>(value, offset);
        }

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

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

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

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

        bool priceType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 149;
 
            return ordinary(value, offset, Null());
        }

        bool settlDate(Timestamp& value) const
        {
            typedef NullLocalMktDate Null;
            typedef LocalMktDate FieldValue;
 
            const BlockLength offset = 151;
 
            FieldValue fieldValue;
 
            if (ordinary(fieldValue, offset, Null()))
            {
                value = localMktDateToTimestamp(fieldValue);
                return true;
            }
            return false;
        }

        CHAR quoteCondition() const
        {
            const BlockLength offset = 153;
 
            return ordinary<CHAR>(offset);
        }

        bool marketSector(StrRef& value) const
        {
            const BlockLength offset = 154;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool sectorGroup(StrRef& value) const
        {
            const BlockLength offset = 180;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool sectorSubGroup(StrRef& value) const
        {
            const BlockLength offset = 182;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool productComplex(StrRef& value) const
        {
            const BlockLength offset = 208;
            const BlockLength length = 26;
 
            return fixedStr<length>(value, offset);
        }

        bool securitySubType(StrRef& value) const
        {
            const BlockLength offset = 234;
            const BlockLength length = 2;
 
            return fixedStr<length>(value, offset);
        }

        bool volType(UInt16& value) const
        {
            typedef NullUInt16 Null;
 
            const BlockLength offset = 236;
 
            return ordinary(value, offset, Null());
        }

        bool referenceId(StrRef& value) const
        {
            const BlockLength offset = 238;
            const BlockLength length = 100;
 
            return fixedStr<length>(value, offset);
        }

        Underlyings underlyings() const
        {
            return
                groups().
                    head<Underlyings>();
        }

        SecurityAltID securityAltId() const
        {
            return
                groups().
                    tail<Underlyings>().
                    head<SecurityAltID>();
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 338;
        }

        Entry next(SchemaVersion) const
        {
            const void* body = securityAltId().end().get().body();
            return Entry(
                body, 
                blockLength(version()), 
                version());
        }

        ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshOTC366.Entry";
        }
    };

    typedef 
    BinaryGroupWithNested<Entry, GroupSize, MessageSize> 
    Entries;

    IncrementalRefreshOTC366()
    {
    }

    IncrementalRefreshOTC366(
        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);
    }

    bool tradeDate(Timestamp& value) const
    {
        typedef NullLocalMktDate Null;
        typedef LocalMktDate FieldValue;
 
        const BlockLength offset = 8;
 
        FieldValue fieldValue;
 
        if (ordinary(fieldValue, offset, Null()))
        {
            value = localMktDateToTimestamp(fieldValue);
            return true;
        }
        return false;
    }

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

    bool batchTotalMessages(UInt16& value) const
    {
        typedef NullUInt16 Null;
 
        const BlockLength offset = 11;
 
        return ordinary(value, offset, Null());
    }

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

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion)
    {
        return 13;
    }

    ONIXS_CMESTREAMLINEDMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshOTC366";
    }

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