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 <OnixS/CME/MDH/messaging/Messages.h>
#include <OnixS/CME/MDH/messaging/TagBased/Message.h>
 
ONIXS_CMEMDH_MESSAGING_TAGBASED_NAMESPACE_BEGIN
 
namespace Base = ONIXS_CMEMDH_MESSAGING_NAMESPACE;
 
class
ChannelReset4
: public Message
{
public:
    typedef
    Base::ChannelReset4
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    ChannelReset4(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    ChannelReset4(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    ChannelReset4() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminHeartbeat12
: public Message
{
public:
    typedef
    Base::AdminHeartbeat12
    Binary;

    explicit
    AdminHeartbeat12(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminHeartbeat12(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminHeartbeat12() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminLogin15
: public Message
{
public:
    typedef
    Base::AdminLogin15
    Binary;

    explicit
    AdminLogin15(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminLogin15(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminLogin15() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminLogout16
: public Message
{
public:
    typedef
    Base::AdminLogout16
    Binary;

    explicit
    AdminLogout16(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminLogout16(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminLogout16() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
SecurityStatus30
: public Message
{
public:
    typedef
    Base::SecurityStatus30
    Binary;

    explicit
    SecurityStatus30(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    SecurityStatus30(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    SecurityStatus30() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshVolume37
: public Message
{
public:
    typedef
    Base::IncrementalRefreshVolume37
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshVolume37(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshVolume37(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshVolume37() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
QuoteRequest39
: public Message
{
public:
    typedef
    Base::QuoteRequest39
    Binary;
 
    struct RelatedSym;
 
    class
    RelatedSymEntry : public GroupEntry
    {
    public:
        typedef
        Binary::RelatedSymEntry
        BinaryEntry;
 
        explicit
        RelatedSymEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct RelatedSym;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    RelatedSym : Group
    {
        typedef
        Binary::RelatedSym
        BinaryEntries;
 
        explicit
        RelatedSym(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                RelatedSymEntry::Accessor::self())
        {
        }
    };

    explicit
    QuoteRequest39(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    QuoteRequest39(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    QuoteRequest39() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshBook46
: public Message
{
public:
    typedef
    Base::IncrementalRefreshBook46
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };
 
    struct OrderIDEntries;
 
    class
    OrderIDEntry : public GroupEntry
    {
    public:
        typedef
        Binary::OrderIDEntry
        BinaryEntry;
 
        explicit
        OrderIDEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct OrderIDEntries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    OrderIDEntries : Group
    {
        typedef
        Binary::OrderIDEntries
        BinaryEntries;
 
        explicit
        OrderIDEntries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                OrderIDEntry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshBook46(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshBook46(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshBook46() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshOrderBook47
: public Message
{
public:
    typedef
    Base::IncrementalRefreshOrderBook47
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshOrderBook47(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshOrderBook47(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshOrderBook47() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshTradeSummary48
: public Message
{
public:
    typedef
    Base::IncrementalRefreshTradeSummary48
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };
 
    struct OrderIDEntries;
 
    class
    OrderIDEntry : public GroupEntry
    {
    public:
        typedef
        Binary::OrderIDEntry
        BinaryEntry;
 
        explicit
        OrderIDEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct OrderIDEntries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    OrderIDEntries : Group
    {
        typedef
        Binary::OrderIDEntries
        BinaryEntries;
 
        explicit
        OrderIDEntries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                OrderIDEntry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshTradeSummary48(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshTradeSummary48(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshTradeSummary48() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshDailyStatistics49
: public Message
{
public:
    typedef
    Base::IncrementalRefreshDailyStatistics49
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshDailyStatistics49(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshDailyStatistics49(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshDailyStatistics49() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshLimitsBanding50
: public Message
{
public:
    typedef
    Base::IncrementalRefreshLimitsBanding50
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshLimitsBanding50(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshLimitsBanding50(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshLimitsBanding50() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshSessionStatistics51
: public Message
{
public:
    typedef
    Base::IncrementalRefreshSessionStatistics51
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshSessionStatistics51(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshSessionStatistics51(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshSessionStatistics51() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
SnapshotFullRefresh52
: public Message
{
public:
    typedef
    Base::SnapshotFullRefresh52
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    SnapshotFullRefresh52(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    SnapshotFullRefresh52(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    SnapshotFullRefresh52() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
SnapshotFullRefreshOrderBook53
: public Message
{
public:
    typedef
    Base::SnapshotFullRefreshOrderBook53
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    SnapshotFullRefreshOrderBook53(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    SnapshotFullRefreshOrderBook53(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    SnapshotFullRefreshOrderBook53() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
InstrumentDefinitionFuture54
: public Message
{
public:
    typedef
    Base::InstrumentDefinitionFuture54
    Binary;
 
    struct Events;
 
    class
    EventsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::EventsEntry
        BinaryEntry;
 
        explicit
        EventsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Events;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Events : Group
    {
        typedef
        Binary::Events
        BinaryEntries;
 
        explicit
        Events(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                EventsEntry::Accessor::self())
        {
        }
    };
 
    struct FeedTypes;
 
    class
    FeedTypesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::FeedTypesEntry
        BinaryEntry;
 
        explicit
        FeedTypesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct FeedTypes;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    FeedTypes : Group
    {
        typedef
        Binary::FeedTypes
        BinaryEntries;
 
        explicit
        FeedTypes(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                FeedTypesEntry::Accessor::self())
        {
        }
    };
 
    struct InstAttrib;
 
    class
    InstAttribEntry : public GroupEntry
    {
    public:
        typedef
        Binary::InstAttribEntry
        BinaryEntry;
 
        explicit
        InstAttribEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct InstAttrib;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    InstAttrib : Group
    {
        typedef
        Binary::InstAttrib
        BinaryEntries;
 
        explicit
        InstAttrib(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                InstAttribEntry::Accessor::self())
        {
        }
    };
 
    struct LotTypeRules;
 
    class
    LotTypeRulesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LotTypeRulesEntry
        BinaryEntry;
 
        explicit
        LotTypeRulesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct LotTypeRules;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    LotTypeRules : Group
    {
        typedef
        Binary::LotTypeRules
        BinaryEntries;
 
        explicit
        LotTypeRules(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LotTypeRulesEntry::Accessor::self())
        {
        }
    };

    explicit
    InstrumentDefinitionFuture54(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    InstrumentDefinitionFuture54(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    InstrumentDefinitionFuture54() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
InstrumentDefinitionOption55
: public Message
{
public:
    typedef
    Base::InstrumentDefinitionOption55
    Binary;
 
    struct Events;
 
    class
    EventsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::EventsEntry
        BinaryEntry;
 
        explicit
        EventsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Events;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Events : Group
    {
        typedef
        Binary::Events
        BinaryEntries;
 
        explicit
        Events(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                EventsEntry::Accessor::self())
        {
        }
    };
 
    struct FeedTypes;
 
    class
    FeedTypesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::FeedTypesEntry
        BinaryEntry;
 
        explicit
        FeedTypesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct FeedTypes;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    FeedTypes : Group
    {
        typedef
        Binary::FeedTypes
        BinaryEntries;
 
        explicit
        FeedTypes(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                FeedTypesEntry::Accessor::self())
        {
        }
    };
 
    struct InstAttrib;
 
    class
    InstAttribEntry : public GroupEntry
    {
    public:
        typedef
        Binary::InstAttribEntry
        BinaryEntry;
 
        explicit
        InstAttribEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct InstAttrib;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    InstAttrib : Group
    {
        typedef
        Binary::InstAttrib
        BinaryEntries;
 
        explicit
        InstAttrib(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                InstAttribEntry::Accessor::self())
        {
        }
    };
 
    struct LotTypeRules;
 
    class
    LotTypeRulesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LotTypeRulesEntry
        BinaryEntry;
 
        explicit
        LotTypeRulesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct LotTypeRules;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    LotTypeRules : Group
    {
        typedef
        Binary::LotTypeRules
        BinaryEntries;
 
        explicit
        LotTypeRules(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LotTypeRulesEntry::Accessor::self())
        {
        }
    };
 
    struct Underlyings;
 
    class
    UnderlyingsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::UnderlyingsEntry
        BinaryEntry;
 
        explicit
        UnderlyingsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Underlyings;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Underlyings : Group
    {
        typedef
        Binary::Underlyings
        BinaryEntries;
 
        explicit
        Underlyings(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                UnderlyingsEntry::Accessor::self())
        {
        }
    };
 
    struct RelatedInstruments;
 
    class
    RelatedInstrumentsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::RelatedInstrumentsEntry
        BinaryEntry;
 
        explicit
        RelatedInstrumentsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct RelatedInstruments;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    RelatedInstruments : Group
    {
        typedef
        Binary::RelatedInstruments
        BinaryEntries;
 
        explicit
        RelatedInstruments(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                RelatedInstrumentsEntry::Accessor::self())
        {
        }
    };

    explicit
    InstrumentDefinitionOption55(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    InstrumentDefinitionOption55(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    InstrumentDefinitionOption55() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
InstrumentDefinitionSpread56
: public Message
{
public:
    typedef
    Base::InstrumentDefinitionSpread56
    Binary;
 
    struct Events;
 
    class
    EventsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::EventsEntry
        BinaryEntry;
 
        explicit
        EventsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Events;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Events : Group
    {
        typedef
        Binary::Events
        BinaryEntries;
 
        explicit
        Events(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                EventsEntry::Accessor::self())
        {
        }
    };
 
    struct FeedTypes;
 
    class
    FeedTypesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::FeedTypesEntry
        BinaryEntry;
 
        explicit
        FeedTypesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct FeedTypes;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    FeedTypes : Group
    {
        typedef
        Binary::FeedTypes
        BinaryEntries;
 
        explicit
        FeedTypes(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                FeedTypesEntry::Accessor::self())
        {
        }
    };
 
    struct InstAttrib;
 
    class
    InstAttribEntry : public GroupEntry
    {
    public:
        typedef
        Binary::InstAttribEntry
        BinaryEntry;
 
        explicit
        InstAttribEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct InstAttrib;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    InstAttrib : Group
    {
        typedef
        Binary::InstAttrib
        BinaryEntries;
 
        explicit
        InstAttrib(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                InstAttribEntry::Accessor::self())
        {
        }
    };
 
    struct LotTypeRules;
 
    class
    LotTypeRulesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LotTypeRulesEntry
        BinaryEntry;
 
        explicit
        LotTypeRulesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct LotTypeRules;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    LotTypeRules : Group
    {
        typedef
        Binary::LotTypeRules
        BinaryEntries;
 
        explicit
        LotTypeRules(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LotTypeRulesEntry::Accessor::self())
        {
        }
    };
 
    struct Legs;
 
    class
    LegsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LegsEntry
        BinaryEntry;
 
        explicit
        LegsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Legs;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Legs : Group
    {
        typedef
        Binary::Legs
        BinaryEntries;
 
        explicit
        Legs(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LegsEntry::Accessor::self())
        {
        }
    };

    explicit
    InstrumentDefinitionSpread56(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    InstrumentDefinitionSpread56(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    InstrumentDefinitionSpread56() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
InstrumentDefinitionFixedIncome57
: public Message
{
public:
    typedef
    Base::InstrumentDefinitionFixedIncome57
    Binary;
 
    struct Events;
 
    class
    EventsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::EventsEntry
        BinaryEntry;
 
        explicit
        EventsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Events;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Events : Group
    {
        typedef
        Binary::Events
        BinaryEntries;
 
        explicit
        Events(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                EventsEntry::Accessor::self())
        {
        }
    };
 
    struct FeedTypes;
 
    class
    FeedTypesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::FeedTypesEntry
        BinaryEntry;
 
        explicit
        FeedTypesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct FeedTypes;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    FeedTypes : Group
    {
        typedef
        Binary::FeedTypes
        BinaryEntries;
 
        explicit
        FeedTypes(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                FeedTypesEntry::Accessor::self())
        {
        }
    };
 
    struct InstAttrib;
 
    class
    InstAttribEntry : public GroupEntry
    {
    public:
        typedef
        Binary::InstAttribEntry
        BinaryEntry;
 
        explicit
        InstAttribEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct InstAttrib;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    InstAttrib : Group
    {
        typedef
        Binary::InstAttrib
        BinaryEntries;
 
        explicit
        InstAttrib(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                InstAttribEntry::Accessor::self())
        {
        }
    };
 
    struct LotTypeRules;
 
    class
    LotTypeRulesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LotTypeRulesEntry
        BinaryEntry;
 
        explicit
        LotTypeRulesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct LotTypeRules;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    LotTypeRules : Group
    {
        typedef
        Binary::LotTypeRules
        BinaryEntries;
 
        explicit
        LotTypeRules(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LotTypeRulesEntry::Accessor::self())
        {
        }
    };

    explicit
    InstrumentDefinitionFixedIncome57(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    InstrumentDefinitionFixedIncome57(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    InstrumentDefinitionFixedIncome57() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
InstrumentDefinitionFX63
: public Message
{
public:
    typedef
    Base::InstrumentDefinitionFX63
    Binary;
 
    struct Events;
 
    class
    EventsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::EventsEntry
        BinaryEntry;
 
        explicit
        EventsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Events;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Events : Group
    {
        typedef
        Binary::Events
        BinaryEntries;
 
        explicit
        Events(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                EventsEntry::Accessor::self())
        {
        }
    };
 
    struct FeedTypes;
 
    class
    FeedTypesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::FeedTypesEntry
        BinaryEntry;
 
        explicit
        FeedTypesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct FeedTypes;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    FeedTypes : Group
    {
        typedef
        Binary::FeedTypes
        BinaryEntries;
 
        explicit
        FeedTypes(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                FeedTypesEntry::Accessor::self())
        {
        }
    };
 
    struct InstAttrib;
 
    class
    InstAttribEntry : public GroupEntry
    {
    public:
        typedef
        Binary::InstAttribEntry
        BinaryEntry;
 
        explicit
        InstAttribEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct InstAttrib;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    InstAttrib : Group
    {
        typedef
        Binary::InstAttrib
        BinaryEntries;
 
        explicit
        InstAttrib(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                InstAttribEntry::Accessor::self())
        {
        }
    };
 
    struct LotTypeRules;
 
    class
    LotTypeRulesEntry : public GroupEntry
    {
    public:
        typedef
        Binary::LotTypeRulesEntry
        BinaryEntry;
 
        explicit
        LotTypeRulesEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct LotTypeRules;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    LotTypeRules : Group
    {
        typedef
        Binary::LotTypeRules
        BinaryEntries;
 
        explicit
        LotTypeRules(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                LotTypeRulesEntry::Accessor::self())
        {
        }
    };
 
    struct TradingSessions;
 
    class
    TradingSessionsEntry : public GroupEntry
    {
    public:
        typedef
        Binary::TradingSessionsEntry
        BinaryEntry;
 
        explicit
        TradingSessionsEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct TradingSessions;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    TradingSessions : Group
    {
        typedef
        Binary::TradingSessions
        BinaryEntries;
 
        explicit
        TradingSessions(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                TradingSessionsEntry::Accessor::self())
        {
        }
    };

    explicit
    InstrumentDefinitionFX63(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    InstrumentDefinitionFX63(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    InstrumentDefinitionFX63() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshBookLongQty64
: public Message
{
public:
    typedef
    Base::IncrementalRefreshBookLongQty64
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };
 
    struct OrderIDEntries;
 
    class
    OrderIDEntry : public GroupEntry
    {
    public:
        typedef
        Binary::OrderIDEntry
        BinaryEntry;
 
        explicit
        OrderIDEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct OrderIDEntries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    OrderIDEntries : Group
    {
        typedef
        Binary::OrderIDEntries
        BinaryEntries;
 
        explicit
        OrderIDEntries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                OrderIDEntry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshBookLongQty64(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshBookLongQty64(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshBookLongQty64() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshTradeSummaryLongQty65
: public Message
{
public:
    typedef
    Base::IncrementalRefreshTradeSummaryLongQty65
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };
 
    struct OrderIDEntries;
 
    class
    OrderIDEntry : public GroupEntry
    {
    public:
        typedef
        Binary::OrderIDEntry
        BinaryEntry;
 
        explicit
        OrderIDEntry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct OrderIDEntries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    OrderIDEntries : Group
    {
        typedef
        Binary::OrderIDEntries
        BinaryEntries;
 
        explicit
        OrderIDEntries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                OrderIDEntry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshTradeSummaryLongQty65(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshTradeSummaryLongQty65(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshTradeSummaryLongQty65() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshVolumeLongQty66
: public Message
{
public:
    typedef
    Base::IncrementalRefreshVolumeLongQty66
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshVolumeLongQty66(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshVolumeLongQty66(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshVolumeLongQty66() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
IncrementalRefreshSessionStatisticsLongQty67
: public Message
{
public:
    typedef
    Base::IncrementalRefreshSessionStatisticsLongQty67
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    IncrementalRefreshSessionStatisticsLongQty67(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    IncrementalRefreshSessionStatisticsLongQty67(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    IncrementalRefreshSessionStatisticsLongQty67() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
SnapshotFullRefreshLongQty69
: public Message
{
public:
    typedef
    Base::SnapshotFullRefreshLongQty69
    Binary;
 
    struct Entries;
 
    class
    Entry : public GroupEntry
    {
    public:
        typedef
        Binary::Entry
        BinaryEntry;
 
        explicit
        Entry(const BinaryEntry& entry) noexcept
          : GroupEntry(
                entry,
                Accessor::self())
        {
        }
 
    private:
        friend
        struct Entries;
 
        struct ONIXS_CMEMDH_EXPORTED
        Accessor : GroupEntryAccessor
        {
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
            void
            setField(
                BinaryBlockBase&,
                Tag,
                const Field&) const final;
 
            void
            resetField(
                BinaryBlockBase&,
                Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
            static
            const GroupEntryAccessor&
            self() noexcept
            {
                static
                const
                Accessor self_;
 
                return self_;
            }
        };
    };
 
    struct
    Entries : Group
    {
        typedef
        Binary::Entries
        BinaryEntries;
 
        explicit
        Entries(
            const BinaryEntries& group) noexcept
          : Group(
                group.entries(),
                Entry::Accessor::self())
        {
        }
    };

    explicit
    SnapshotFullRefreshLongQty69(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    SnapshotFullRefreshLongQty69(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    SnapshotFullRefreshLongQty69() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminLogin408
: public Message
{
public:
    typedef
    Base::AdminLogin408
    Binary;

    explicit
    AdminLogin408(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminLogin408(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminLogin408() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminLogout409
: public Message
{
public:
    typedef
    Base::AdminLogout409
    Binary;

    explicit
    AdminLogout409(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminLogout409(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminLogout409() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
class
AdminHeartbeat410
: public Message
{
public:
    typedef
    Base::AdminHeartbeat410
    Binary;

    explicit
    AdminHeartbeat410(const Binary& message) noexcept
      : Message(
            message,
            Accessor::self())
    {
    }

    AdminHeartbeat410(
        void* data,
        MessageSize length,
        SchemaVersion version = Binary::Schema::Version)
        : Message(
            Binary(data, length, version),
            Accessor::self())
    {
    }

    AdminHeartbeat410() = default;
 
private:
    struct ONIXS_CMEMDH_EXPORTED
    Accessor : MessageAccessor
    {
        StrRef type() const noexcept final
        {
            return Binary::fixType();
        }
 
        Field
        field(
            const BinaryBlockBase&,
            Tag) const noexcept final;
 
        void
        setField(
            BinaryBlockBase&,
            Tag,
            const Field&) const final;
 
        void
        resetField(
            BinaryBlockBase&,
            Tag) const final;
 
        void
        reset(
            BinaryBlockBase&) const noexcept final;
 
        MessageSize
        calculateBinarySize(
            const SbeMessage&) const noexcept final;
 
        Group
        group(
            const SbeMessage&,
            Tag) const noexcept final;
 
        Group
        group(
            SbeMessage&,
            Tag,
            MessageSize) const final;
 
        void
        toFix(
            std::string&,
            const SbeMessage&) const final;
 
        static const MessageAccessor& self() noexcept
        {
            static
            const
            Accessor self_;
 
            return self_;
        }
    };
};
 
 
 
ONIXS_CMEMDH_MESSAGING_TAGBASED_NAMESPACE_END