Messages.h

Go to the documentation of this file.

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

struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFixedIncome57 : BinaryMessage
{
    enum
    {
        TemplateId = 57
    };

    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        EventsEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.EventsEntry";
        }
    };

    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        FeedTypesEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.FeedTypesEntry";
        }
    };

    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        InstAttribEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.InstAttribEntry";
        }
    };

    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        LotTypeRulesEntry() {}

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

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

        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;
 
            const BlockLength offset = 1;
 
            return decimal(value, offset, Null());
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFixedIncome57.LotTypeRulesEntry";
        }
    };

    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    InstrumentDefinitionFixedIncome57() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    StrRef countryOfIssue() const
    {
        const BlockLength offset = 232;
        const BlockLength length = 2;
 
        return fixedStr<length>(offset);
    }

    StrRef issuer() const
    {
        const BlockLength offset = 234;
        const BlockLength length = 25;
 
        return fixedStr<length>(offset);
    }

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

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

    bool securityAltIdSource(SecurityAltIDSource::Enum& value) const
    {
        typedef NullUInt8 Null;
 
        const BlockLength offset = 306;
 
        return enumeration<SecurityAltIDSource>(value, offset, Null());
    }

    StrRef priceQuoteMethod() const
    {
        const BlockLength offset = 307;
        const BlockLength length = 5;
 
        return fixedStr<length>(offset);
    }

    StrRef partyRoleClearingOrg() const
    {
        const BlockLength offset = 312;
        const BlockLength length = 5;
 
        return fixedStr<length>(offset);
    }

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

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

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 338;
 
        return 207;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionFixedIncome57";
    }

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

struct ONIXS_CMEMDH_LTWT ChannelReset4 : BinaryMessage
{
    enum
    {
        TemplateId = 4
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    ChannelReset4() {}

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

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

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT AdminHeartbeat12 : BinaryMessage
{
    enum
    {
        TemplateId = 12
    };

    AdminHeartbeat12() {}

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

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

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

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

struct ONIXS_CMEMDH_LTWT AdminLogin15 : BinaryMessage
{
    enum
    {
        TemplateId = 15
    };

    AdminLogin15() {}

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT AdminLogout16 : BinaryMessage
{
    enum
    {
        TemplateId = 16
    };

    AdminLogout16() {}

    AdminLogout16(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalVersion())
    {
        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_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

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

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

struct ONIXS_CMEMDH_LTWT AdminLogin408 : BinaryMessage
{
    enum
    {
        TemplateId = 408
    };

    AdminLogin408() {}

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT AdminLogout409 : BinaryMessage
{
    enum
    {
        TemplateId = 409
    };

    AdminLogout409() {}

    AdminLogout409(const void* data, EncodedLength length)
        : BinaryMessage(data, length, SchemaTraits::minimalTcpRecoveryVersion())
    {
        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_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 180;
    }

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

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

struct ONIXS_CMEMDH_LTWT AdminHeartbeat410 : BinaryMessage
{
    enum
    {
        TemplateId = 410
    };

    AdminHeartbeat410() {}

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

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

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

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

struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFuture54 : BinaryMessage
{
    enum
    {
        TemplateId = 54
    };

    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        EventsEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.EventsEntry";
        }
    };

    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        FeedTypesEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.FeedTypesEntry";
        }
    };

    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        InstAttribEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.InstAttribEntry";
        }
    };

    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        LotTypeRulesEntry() {}

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

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

        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;
 
            const BlockLength offset = 1;
 
            return decimal(value, offset, Null());
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionFuture54.LotTypeRulesEntry";
        }
    };

    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    InstrumentDefinitionFuture54() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 224;
 
        return 216;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionFuture54";
    }

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

struct ONIXS_CMEMDH_LTWT InstrumentDefinitionSpread56 : BinaryMessage
{
    enum
    {
        TemplateId = 56
    };

    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        EventsEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.EventsEntry";
        }
    };

    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        FeedTypesEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.FeedTypesEntry";
        }
    };

    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        InstAttribEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.InstAttribEntry";
        }
    };

    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        LotTypeRulesEntry() {}

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

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

        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;
 
            const BlockLength offset = 1;
 
            return decimal(value, offset, Null());
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.LotTypeRulesEntry";
        }
    };

    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

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

        Int32 legSecurityId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

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

        LegSide::Enum legSide() const
        {
            const BlockLength offset = 4;
 
            return enumeration<LegSide>(offset);
        }

        Int8 legRatioQty() const
        {
            const BlockLength offset = 5;
 
            return ordinary<Int8>(offset);
        }

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

        bool legOptionDelta(Decimal& value) const
        {
            typedef NullDecimalQty Null;
 
            const BlockLength offset = 14;
 
            return decimal(value, offset, Null());
        }

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionSpread56.LegsEntry";
        }
    };

    typedef BinaryGroup<LegsEntry, GroupSize, MessageSize> Legs;

    InstrumentDefinitionSpread56() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    StrRef securitySubType() const
    {
        const BlockLength offset = 79;
        const BlockLength length = 5;
 
        return fixedStr<length>(offset);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    StrRef priceQuoteMethod() const
    {
        const BlockLength offset = 195;
        const BlockLength length = 5;
        const SchemaVersion since = 10;
 
        return fixedStr<length>(offset, since);
    }

    StrRef riskSet() const
    {
        const BlockLength offset = 200;
        const BlockLength length = 6;
        const SchemaVersion since = 10;
 
        return fixedStr<length>(offset, since);
    }

    StrRef marketSet() const
    {
        const BlockLength offset = 206;
        const BlockLength length = 6;
        const SchemaVersion since = 10;
 
        return fixedStr<length>(offset, since);
    }

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

    StrRef financialInstrumentFullName() const
    {
        const BlockLength offset = 220;
        const BlockLength length = 35;
        const SchemaVersion since = 10;
 
        return fixedStr<length>(offset, since);
    }

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 255;
 
        return 195;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionSpread56";
    }

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

struct ONIXS_CMEMDH_LTWT SecurityStatus30 : BinaryMessage
{
    enum
    {
        TemplateId = 30
    };

    SecurityStatus30() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshBook46 : BinaryMessage
{
    enum
    {
        TemplateId = 46
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

        bool tradeableSize(Int32& value) const
        {
            typedef NullInt32 Null;
 
            const BlockLength offset = 27;
            const SchemaVersion since = 10;
 
            return ordinary(value, offset, Null(), since);
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion version)
        {
            if (version >= 10)
                return 31;
 
            return 27;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshBook46.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize8Byte::BlockLength> Base;

        OrderIDEntry() {}

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshBook46.OrderIDEntry";
        }
    };

    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    IncrementalRefreshBook46() {}

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshBook46";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshDailyStatistics49 : BinaryMessage
{
    enum
    {
        TemplateId = 49
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 25;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshDailyStatistics49.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshDailyStatistics49() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshDailyStatistics49";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshLimitsBanding50 : BinaryMessage
{
    enum
    {
        TemplateId = 50
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

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

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshLimitsBanding50() {}

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

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

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatistics51 : BinaryMessage
{
    enum
    {
        TemplateId = 51
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshSessionStatistics51.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshSessionStatistics51() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshSessionStatistics51";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshVolume37 : BinaryMessage
{
    enum
    {
        TemplateId = 37
    };

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

        Int32 entrySize() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshVolume37.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshVolume37() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshVolume37";
    }

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

struct ONIXS_CMEMDH_LTWT SnapshotFullRefresh52 : BinaryMessage
{
    enum
    {
        TemplateId = 52
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "SnapshotFullRefresh52.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    SnapshotFullRefresh52() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "SnapshotFullRefresh52";
    }

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

struct ONIXS_CMEMDH_LTWT QuoteRequest39 : BinaryMessage
{
    enum
    {
        TemplateId = 39
    };

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

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

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

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

        Int8 quoteType() const
        {
            const BlockLength offset = 28;
 
            return ordinary<Int8>(offset);
        }

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "QuoteRequest39.RelatedSymEntry";
        }
    };

    typedef BinaryGroup<RelatedSymEntry, GroupSize, MessageSize> RelatedSym;

    QuoteRequest39() {}

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "QuoteRequest39";
    }

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

struct ONIXS_CMEMDH_LTWT InstrumentDefinitionOption55 : BinaryMessage
{
    enum
    {
        TemplateId = 55
    };

    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        EventsEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.EventsEntry";
        }
    };

    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        FeedTypesEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.FeedTypesEntry";
        }
    };

    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        InstAttribEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.InstAttribEntry";
        }
    };

    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        LotTypeRulesEntry() {}

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

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

        bool minLotSize(Decimal& value) const
        {
            typedef NullDecimalQty Null;
 
            const BlockLength offset = 1;
 
            return decimal(value, offset, Null());
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 5;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.LotTypeRulesEntry";
        }
    };

    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

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

        Int32 underlyingSecurityId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 24;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.UnderlyingsEntry";
        }
    };

    typedef BinaryGroup<UnderlyingsEntry, GroupSize, MessageSize> Underlyings;

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

        Int32 relatedSecurityId() const
        {
            const BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 24;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "InstrumentDefinitionOption55.RelatedInstrumentsEntry";
        }
    };

    typedef BinaryGroup<RelatedInstrumentsEntry, GroupSize, MessageSize> RelatedInstruments;

    InstrumentDefinitionOption55() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    PutOrCall::Enum putOrCall() const
    {
        const BlockLength offset = 71;
 
        return enumeration<PutOrCall>(offset);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 10)
            return 221;
 
        return 213;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "InstrumentDefinitionOption55";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummary48 : BinaryMessage
{
    enum
    {
        TemplateId = 48
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummary48.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize8Byte::BlockLength> Base;

        OrderIDEntry() {}

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshTradeSummary48.OrderIDEntry";
        }
    };

    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    IncrementalRefreshTradeSummary48() {}

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshTradeSummary48";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshOrderBook47 : BinaryMessage
{
    enum
    {
        TemplateId = 47
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry<GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "IncrementalRefreshOrderBook47.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshOrderBook47() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "IncrementalRefreshOrderBook47";
    }

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

struct ONIXS_CMEMDH_LTWT SnapshotFullRefreshOrderBook53 : BinaryMessage
{
    enum
    {
        TemplateId = 53
    };

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED
        static BlockLength blockLength(SchemaVersion)
        {
            return 29;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED
        static const Char* className()
        {
            return "SnapshotFullRefreshOrderBook53.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    SnapshotFullRefreshOrderBook53() {}

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

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

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

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

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

    UInt32 currentChunk() const
    {
        const BlockLength offset = 16;
 
        return ordinary<UInt32>(offset);
    }

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED
    static BlockLength blockLength(SchemaVersion)
    {
        return 28;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const Char* className()
    {
        return "SnapshotFullRefreshOrderBook53";
    }

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

struct ONIXS_CMEMDH_LTWT InstrumentDefinitionFX63 : BinaryMessage
{
    enum 
    {
        TemplateId = 63 
    };

    struct ONIXS_CMEMDH_LTWT EventsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        EventsEntry() {}

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

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

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

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

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

    typedef BinaryGroup<EventsEntry, GroupSize, MessageSize> Events;

    struct ONIXS_CMEMDH_LTWT FeedTypesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        FeedTypesEntry() {}

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

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

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

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

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

    typedef BinaryGroup<FeedTypesEntry, GroupSize, MessageSize> FeedTypes;

    struct ONIXS_CMEMDH_LTWT InstAttribEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        InstAttribEntry() {}

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

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

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

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

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

    typedef BinaryGroup<InstAttribEntry, GroupSize, MessageSize> InstAttrib;

    struct ONIXS_CMEMDH_LTWT LotTypeRulesEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        LotTypeRulesEntry() {}

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

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

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

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

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

    typedef BinaryGroup<LotTypeRulesEntry, GroupSize, MessageSize> LotTypeRules;

    struct ONIXS_CMEMDH_LTWT TradingSessionsEntry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        TradingSessionsEntry() {}

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion version)
        {
            if (version >= 10)
                return 18;
 
            return 6;
        }

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

    typedef BinaryGroup<TradingSessionsEntry, GroupSize, MessageSize> TradingSessions;

    InstrumentDefinitionFX63() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED 
    static BlockLength blockLength(SchemaVersion version)
    {
        if (version >= 13)
            return 337;
 
        if (version >= 12)
            return 309;
 
        if (version >= 10)
            return 204;
 
        return 169;
    }

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

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshBookLongQty64 : BinaryMessage
{
    enum 
    {
        TemplateId = 64 
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

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

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

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize8Byte::BlockLength> Base;

        OrderIDEntry() {}

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

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

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

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

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

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

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

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

    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    IncrementalRefreshBookLongQty64() {}

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

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

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

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummaryLongQty65 : BinaryMessage
{
    enum 
    {
        TemplateId = 65 
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

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

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

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

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    struct ONIXS_CMEMDH_LTWT OrderIDEntry : BinaryGroupEntry<GroupSize8Byte::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize8Byte::BlockLength> Base;

        OrderIDEntry() {}

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

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

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

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

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

    typedef BinaryGroup<OrderIDEntry, GroupSize8Byte, MessageSize> OrderIDEntries;

    IncrementalRefreshTradeSummaryLongQty65() {}

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

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

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

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

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

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

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

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshVolumeLongQty66 : BinaryMessage
{
    enum 
    {
        TemplateId = 66 
    };

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED 
        static BlockLength blockLength(SchemaVersion)
        {
            return 17;
        }

        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshVolumeLongQty66.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshVolumeLongQty66() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshVolumeLongQty66";
    }

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

struct ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatisticsLongQty67 : BinaryMessage
{
    enum 
    {
        TemplateId = 67 
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

        ONIXS_CMEMDH_LTWT_EXPORTED 
        static const Char* className()
        {
            return "IncrementalRefreshSessionStatisticsLongQty67.Entry";
        }
    };

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    IncrementalRefreshSessionStatisticsLongQty67() {}

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

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

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

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

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

    ONIXS_CMEMDH_LTWT_EXPORTED 
    static const Char* className()
    {
        return "IncrementalRefreshSessionStatisticsLongQty67";
    }

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

struct ONIXS_CMEMDH_LTWT SnapshotFullRefreshLongQty69 : BinaryMessage
{
    enum 
    {
        TemplateId = 69 
    };

    struct ONIXS_CMEMDH_LTWT Entry : BinaryGroupEntry<GroupSize::BlockLength>
    {
        typedef BinaryGroupEntry <GroupSize::BlockLength> Base;

        Entry() {}

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

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

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

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

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

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

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

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

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

    typedef BinaryGroup<Entry, GroupSize, MessageSize> Entries;

    SnapshotFullRefreshLongQty69() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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