SbeMessage.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/ABI.h>
#include <OnixS/CME/MDH/messaging/Aliases.h>
#include <OnixS/CME/MDH/messaging/StrRef.h>
#include <OnixS/CME/MDH/messaging/Time.h>
#include <OnixS/CME/MDH/messaging/Memory.h>
#include <OnixS/CME/MDH/messaging/Decimal.h>
#include <OnixS/CME/MDH/messaging/Decimal.Operations.h>
#include <OnixS/CME/MDH/messaging/Composites.h>
#include <OnixS/CME/MDH/messaging/SchemaTraits.h>
#include <OnixS/CME/MDH/messaging/MaxMessageSize.h>
#include <OnixS/CME/MDH/messaging/ExceptionHelpers.h>
 
#include <cassert>
#include <limits>
#include <stdexcept>
 
ONIXS_CMEMDH_MESSAGING_NAMESPACE_BEGIN

typedef MessageHeader::TemplateId MessageTemplateId;

template <typename Message>
inline void checkBinaryLength(const Message&, MessageSize length, MessageSize minimalRequiredLength)
{
    if ONIXS_CMEMDH_UNLIKELY (length < minimalRequiredLength)
    {
        throwBinaryBlockIsTooSmall(length, minimalRequiredLength, Message::className());
    }
}
 
class BinaryBlockBase
{
protected:
    ~BinaryBlockBase() = default;
};

template <class Container, class BlockLength>
class BinaryBlock : public BinaryBlockBase
{
    ONIXS_CMEMDH_FORCEINLINE
    const Container& container() const noexcept
    {
        return *static_cast<const Container*>(this);
    }
 
protected:
    BinaryBlock() = default;
 
    ~BinaryBlock() = default;

    template <class Value>
    ONIXS_CMEMDH_FORCEINLINE
    Value ordinary(BlockLength offset) const noexcept
    {
        assert(
            container().blockLength() >= (offset + size<Value>())
            && "The requested field exceeds provided block boundaries."
        );
 
        const void* const location = advanceByBytes(container().block(), offset);
        return getValue<Value>(location);
    }

    template <class Value>
    ONIXS_CMEMDH_FORCEINLINE
    Value ordinary(BlockLength offset, SchemaVersion since) const
    {
        if ONIXS_CMEMDH_UNLIKELY (since > container().version())
            throwDisallowedField();
 
        return ordinary<Value>(offset);
    }

    template <class Value, class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool ordinary(Value& value, BlockLength offset, NullValue null) const noexcept
    {
        value = ordinary<Value>(offset);
 
        return (null != value);
    }

    template <class Value, class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool ordinary(Value& value, BlockLength offset, NullValue null, SchemaVersion since) const noexcept
    {
        return (since <= container().version() && ordinary(value, offset, null));
    }

    template <class Enumeration>
    ONIXS_CMEMDH_FORCEINLINE
    typename Enumeration::Enum enumeration(BlockLength offset) const noexcept
    {
        typedef typename Enumeration::Base Base;
        typedef typename Enumeration::Enum Enum;
 
        return static_cast<Enum>(ordinary<Base>(offset));
    }

    template <class Enumeration, class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool enumeration(typename Enumeration::Enum& value, BlockLength offset, NullValue null) const noexcept
    {
        typedef typename Enumeration::Base Base;
        typedef typename Enumeration::Enum Enum;
 
        value = static_cast<Enum>(ordinary<Base>(offset));
        return null != value;
    }

    template <class Enumeration, class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool enumeration(typename Enumeration::Enum& value, BlockLength offset, NullValue null, SchemaVersion since) const noexcept
    {
        return (since <= container().version() && enumeration<Enumeration>(value, offset, null));
    }

    template <class Value>
    ONIXS_CMEMDH_FORCEINLINE
    Decimal decimal(BlockLength offset) const
    {
        return Decimal(ordinary<Value>(offset));
    }

    template <class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool decimal(Decimal& value, BlockLength offset, NullValue null) const noexcept
    {
        typedef typename NullValue::Value Value;
        const Value optional = ordinary<Value>(offset);
        value = optional;
 
        return null != optional;
    }

    template <class Value, class NullValue>
    ONIXS_CMEMDH_FORCEINLINE
    bool decimal(Value& value, BlockLength offset, NullValue null, SchemaVersion since) const noexcept
    {
        return (since <= container().version() && decimal(value, offset, null));
    }

    template <BlockLength Length>
    ONIXS_CMEMDH_FORCEINLINE
    StrRef fixedStr(BlockLength offset) const noexcept
    {
        assert(
            container().blockLength() >= (offset + Length) && "The requested field exceeds provided block boundaries."
        );
 
        const Char* const text = reinterpret_cast<const Char*>(advanceByBytes(container().block(), offset));
        return StrRef(text, strnlen(text, Length));
    }

    template <BlockLength Length>
    ONIXS_CMEMDH_FORCEINLINE
    bool fixedStr(StrRef& value, BlockLength offset) const noexcept
    {
        value = fixedStr<Length>(offset);
        return !value.empty();
    }

    template <BlockLength Length>
    ONIXS_CMEMDH_FORCEINLINE
    bool fixedStr(StrRef& value, BlockLength offset, SchemaVersion since) const noexcept
    {
        return (since <= container().version() && fixedStr<Length>(value, offset));
    }
};

template <class Container, class BlockLength>
class SbeFields : public BinaryBlock<Container, BlockLength>
{
public:
    ONIXS_CMEMDH_FORCEINLINE
    Container& container() noexcept
    {
        return *static_cast<Container*>(this);
    }

    ONIXS_CMEMDH_HOTPATH
    void zeroPaddingBytes(BlockLength offset) noexcept
    {
        const BlockLength encodedBlockLength = container().blockLength();
 
        assert(encodedBlockLength >= offset);
 
        const size_t paddingLength = encodedBlockLength - offset;
        std::memset(advanceByBytes(container().block(), offset), 0, paddingLength);
    }

    template <class FieldValue>
    ONIXS_CMEMDH_FORCEINLINE
    void setOrdinary(BlockLength offset, FieldValue value) noexcept
    {
        assert(
            container().blockLength() >= (offset + size<FieldValue>())
            && "The requested field exceeds provided block boundaries."
        );
 
        void* const fieldPos = advanceByBytes(container().block(), offset);
        setValue(fieldPos, value);
    }

    template <class FieldValue>
    ONIXS_CMEMDH_FORCEINLINE
    void setOrdinary(BlockLength offset, FieldValue value, SchemaVersion since)
    {
        if ONIXS_CMEMDH_UNLIKELY (since > container().version())
        {
            throwDisallowedField();
        }
 
        setOrdinary(offset, value);
    }

    template <class Enumeration>
    ONIXS_CMEMDH_FORCEINLINE
    void setEnumeration(BlockLength offset, typename Enumeration::Enum value) noexcept
    {
        typedef typename Enumeration::Base Base;
        setOrdinary<Base>(offset, static_cast<Base>(value));
    }

    template <class Enumeration>
    ONIXS_CMEMDH_FORCEINLINE
    void setEnumeration(BlockLength offset, typename Enumeration::Enum value, SchemaVersion since)
    {
        typedef typename Enumeration::Base Base;
        setOrdinary(offset, static_cast<Base>(value), since);
    }

    template <BlockLength Size>
    ONIXS_CMEMDH_FORCEINLINE
    void setFixedStr(BlockLength offset, StrRef value) noexcept
    {
        assert(
            container().blockLength() >= (offset + Size) && "The requested field exceeds provided block boundaries."
        );
        assert(value.size() <= Size && "The string is truncated.");
 
        void* const fieldPos = advanceByBytes(container().block(), offset);
        const size_t sizeToCopy = (std::min)(Size, static_cast<BlockLength>(value.size()));
 
        if (sizeToCopy > 0)
            std::memcpy(fieldPos, value.data(), sizeToCopy);
 
        std::memset(advanceByBytes(fieldPos, sizeToCopy), 0, Size - sizeToCopy);
    }

    template <BlockLength Size>
    ONIXS_CMEMDH_FORCEINLINE
    void setFixedStr(BlockLength offset, StrRef value, SchemaVersion since)
    {
        if ONIXS_CMEMDH_UNLIKELY (since > container().version())
        {
            throwDisallowedField();
        }
 
        setFixedStr<Size>(offset, value);
    }
 
protected:
    SbeFields() = default;
 
    ~SbeFields() = default;
};

template <class BodySizeType>
class SbeGroupEntry : public SbeFields<SbeGroupEntry<BodySizeType>, BodySizeType>
{
public:
    typedef BodySizeType BlockLength;

    SbeGroupEntry()
        : encoded_(nullptr)
        , size_(0)
        , version_(0)
    {
    }

    ONIXS_CMEMDH_HOTPATH
    SbeGroupEntry(void* encoded, BlockLength size, SchemaVersion version)
        : encoded_(encoded)
        , size_(size)
        , version_(version)
    {
        assert(encoded);
    }

    ONIXS_CMEMDH_FORCEINLINE
    bool valid() const noexcept
    {
        return (encoded_ != nullptr);
    }

    ONIXS_CMEMDH_FORCEINLINE
    const void* encoded() const noexcept
    {
        assert(valid());
 
        return encoded_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    void* encoded() noexcept
    {
        assert(valid());
 
        return encoded_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    const void* block() const noexcept
    {
        assert(valid());
 
        return encoded_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    void* block() noexcept
    {
        assert(valid());
 
        return encoded_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    BlockLength blockLength() const noexcept
    {
        return size_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    SchemaVersion version() const noexcept
    {
        return version_;
    }
 
private:
    void* encoded_;
    BodySizeType size_;
    SchemaVersion version_;
};

template <class EntryType, class BlockLength, class NumInGroup, class Length>
class SbeGroupEntries
{
public:
    typedef Length EncodedLength;

    typedef EntryType Entry;

    typedef NumInGroup Size;

    class Iterator
    {
    public:
        typedef EntryType Entry;
        typedef Entry value_type;
 
        typedef Entry* pointer;
        typedef Entry& reference;
 
        typedef ptrdiff_t difference_type;
 
        typedef std::random_access_iterator_tag iterator_category;

        Iterator() noexcept
            : entry_(nullptr)
            , size_(0)
            , version_(0)
        {
        }

        ONIXS_CMEMDH_HOTPATH
        Iterator(void* entry, EncodedLength size, SchemaVersion version) noexcept
            : entry_(entry)
            , size_(size)
            , version_(version)
        {
            assert(valid());
        }

        bool valid() const noexcept
        {
            return (entry_ != nullptr);
        }

        ONIXS_CMEMDH_HOTPATH
        Entry get() const
        {
            assert(valid());
 
            return Entry(entry_, size_, version_);
        }

        Entry operator*() const
        {
            return get();
        }

        bool operator==(const Iterator& other) const noexcept
        {
            return entry_ == other.entry_;
        }

        bool operator!=(const Iterator& other) const noexcept
        {
            return entry_ != other.entry_;
        }

        bool operator<(const Iterator& other) const noexcept
        {
            return entry_ < other.entry_;
        }

        bool operator>(const Iterator& other) const noexcept
        {
            return entry_ > other.entry_;
        }

        Iterator& operator++()
        {
            assert(valid());
 
            entry_ = advanceByBytes(entry_, size_);
 
            return *this;
        }

        Iterator& operator--()
        {
            assert(valid());
 
            entry_ = advanceBackByBytes(entry_, size_);
 
            return *this;
        }

        ONIXS_CMEMDH_HOTPATH
        Iterator operator+(difference_type distance) const
        {
            assert(valid());
 
            return Iterator(advanceByBytes(entry_, distance * size_), size_, version_);
        }

        ONIXS_CMEMDH_HOTPATH
        Iterator operator-(difference_type distance) const
        {
            assert(valid());
 
            return Iterator(advanceBackByBytes(entry_, distance * size_), size_, version_);
        }
 
    private:
        void* entry_;
        EncodedLength size_;
        SchemaVersion version_;
    };

    SbeGroupEntries() noexcept
        : encoded_(nullptr)
        , blockLength_(0)
        , size_(0)
        , version_(0)
    {
    }

    SbeGroupEntries(void* encoded, BlockLength blockLength, Size groupSize, SchemaVersion version) noexcept
        : encoded_(encoded)
        , blockLength_(blockLength)
        , size_(groupSize)
        , version_(version)
    {
        assert(encoded_);
        assert(blockLength > 0);
        assert(version != 0);
    }

    bool valid() const noexcept
    {
        return (nullptr != encoded_);
    }

    bool empty() const noexcept
    {
        return (0 == size_);
    }

    Size size() const noexcept
    {
        return size_;
    }

    Iterator begin() const
    {
        return Iterator(encoded(), blockLength_, version_);
    }

    Iterator end() const
    {
        return Iterator(advanceByBytes(encoded(), encodedLength()), blockLength_, version_);
    }

    Entry operator[](Size index) const
    {
        assert(index < size_);
        assert(encoded_);
 
        return Entry(advanceByBytes(encoded_, static_cast<ptrdiff_t>(index) * blockLength_), blockLength_, version_);
    }

    void* encoded() const noexcept
    {
        return encoded_;
    }

    EncodedLength encodedLength() const noexcept
    {
        return (static_cast<EncodedLength>(blockLength_) * static_cast<EncodedLength>(size_));
    }

    template <class OtherEntry, class OtherBlockLength, class OtherNumInGroup, class OtherLength>
    SbeGroupEntries(const SbeGroupEntries<OtherEntry, OtherBlockLength, OtherNumInGroup, OtherLength>& other) noexcept
        : encoded_(other.encoded_)
        , blockLength_(other.blockLength_)
        , size_(other.size_)
        , version_(other.version_)
    {
        // Dimension types may vary for the different instantiations of the template.
        // Therefore, truncation of the dimensions must be avoided.
 
        assert(blockLength_ == other.blockLength_);
        assert(size_ == other.size_);
    }
 
    template <class OtherEntry, class OtherBlockLength, class OtherNumInGroup, class OtherLength>
    SbeGroupEntries& operator=(const SbeGroupEntries<OtherEntry, OtherBlockLength, OtherNumInGroup, OtherLength>& other
    ) noexcept
    {
        encoded_ = other.encoded_;
 
        blockLength_ = other.blockLength_;
 
        assert(blockLength_ == other.blockLength_);
 
        size_ = other.size_;
 
        assert(size_ == other.size_);
 
        version_ = other.version_;
 
        return *this;
    }
 
private:
    // Allows coping and cloning for different instantiations.
    template <class OtherEntry, class OtherBlockLength, class OtherNumInGroup, class OtherLength>
    friend class SbeGroupEntries;
 
    void* encoded_;
    BlockLength blockLength_;
    NumInGroup size_;
    SchemaVersion version_;
};

template <class EntryType, class DimensionType, class GroupSizeType>
class SbeGroup
{
public:
    typedef DimensionType Dimension;

    typedef GroupSizeType BinarySize;

    enum
    {
        EmptySize = Dimension::Size
    };

    typedef typename DimensionType::BlockLength EntrySize;

    typedef SbeGroupEntries<EntryType, typename Dimension::BlockLength, typename Dimension::NumInGroup, GroupSizeType>
        Entries;

    typedef typename Entries::Iterator Iterator;

    typedef typename Entries::Entry Entry;

    typedef typename Entries::Size Size;

    SbeGroup() noexcept
        : header_(nullptr)
        , entries_(nullptr)
        , version_(0)
    {
    }

    ONIXS_CMEMDH_HOTPATH
    SbeGroup(void* data, ONIXS_CMEMDH_UNUSED BinarySize size, SchemaVersion version) noexcept
        : header_(static_cast<Dimension*>(data))
        , entries_(advanceByBytes(data, Dimension::Size))
        , version_(version)
    {
        ONIXS_CMEMDH_ASSERT(size >= Dimension::Size);
        assert(header_);
        assert(entries_);
 
        assert(valid());
    }

    bool valid() const noexcept
    {
        return (entries_ != nullptr);
    }

    bool empty() const noexcept
    {
        assert(valid());
 
        return 0 == size();
    }

    ONIXS_CMEMDH_HOTPATH
    Size size() const noexcept
    {
        assert(valid());
        assert(header_);
 
        const Dimension* const group = static_cast<const Dimension*>(header_);
 
        return group->numInGroup();
    }

    ONIXS_CMEMDH_HOTPATH
    Iterator begin() const noexcept
    {
        assert(valid());
 
        return Iterator(entries_, numericCast<EntrySize>(entrySize()), version_);
    }

    ONIXS_CMEMDH_HOTPATH
    Iterator end() const noexcept
    {
        assert(valid());
 
        return Iterator(advanceByBytes(binary(), binarySize()), numericCast<EntrySize>(entrySize()), version_);
    }

    ONIXS_CMEMDH_HOTPATH
    Entry operator[](Size index) const
    {
        assert(valid());
        assert(index < size());
 
        return Entry(advanceByBytes(entries_, static_cast<ptrdiff_t>(index) * entrySize()), entrySize(), version_);
    }

    ONIXS_CMEMDH_NODISCARD
    Entries entries() const noexcept
    {
        assert(valid());
        assert(header_);
 
        return Entries(entries_, header_->blockLength(), header_->numInGroup(), version_);
    }

    const void* encoded() const noexcept
    {
        return header_;
    }

    const void* tail() const noexcept
    {
        return advanceByBytes(toByteBlock(encoded()), binarySize());
    }

    ONIXS_CMEMDH_HOTPATH
    void* binary() const noexcept
    {
        return header_;
    }

    ONIXS_CMEMDH_HOTPATH
    BinarySize binarySize() const noexcept
    {
        return Dimension::Size + (static_cast<BinarySize>(entrySize()) * static_cast<BinarySize>(size()));
    }

    ONIXS_CMEMDH_HOTPATH
    EntrySize entrySize() const noexcept
    {
        assert(valid());
        assert(header_);
 
        Dimension* const group = static_cast<Dimension*>(header_);
        return group->blockLength();
    }
 
private:
    void init(EntrySize entrySize) noexcept
    {
        assert(valid());
        assert(header_);
 
        Dimension* const group = static_cast<Dimension*>(header_);
        group->setBlockLength(entrySize);
        group->setNumInGroup(0);
    }

    Size allocate(Size entryCount, const void* messageTail, const void* blockEnd)
    {
        assert(valid());
        assert(blockEnd);
        assert(messageTail);
 
        Dimension* const group = static_cast<Dimension*>(header_);
 
        const EntrySize entrySize = group->blockLength();
 
        if ONIXS_CMEMDH_UNLIKELY (entrySize < EntryType::blockLength(version_))
        {
            throwBadBinaryBlock();
        }
 
        const Size oldEntryCount = group->numInGroup();
 
        if (oldEntryCount == entryCount)
            return entryCount;
 
        const ptrdiff_t memShift = (entryCount - oldEntryCount) * static_cast<ptrdiff_t>(entrySize);
 
        const void* const newMessageTail = advanceByBytes(messageTail, memShift);
 
        if ONIXS_CMEMDH_UNLIKELY (byteDistance(blockEnd, newMessageTail) < 0)
        {
            throwNotEnoughSpace();
        }
 
        const void* const oldEndOfGroup = advanceByBytes(entries_, static_cast<ptrdiff_t>(entrySize) * oldEntryCount);
 
        void* const newEndGroup = advanceByBytes(entries_, static_cast<ptrdiff_t>(entrySize) * entryCount);
 
        std::memmove(newEndGroup, oldEndOfGroup, byteDistance(messageTail, oldEndOfGroup));
 
        group->setNumInGroup(entryCount);
 
        return oldEntryCount;
    }

    ONIXS_CMEMDH_HOTPATH
    void setup(Size entryCount, const void* messageTail, const void* blockEnd)
    {
        assert(valid());
        assert(blockEnd);
        assert(messageTail);
 
        const Size oldEntryCount = allocate(entryCount, messageTail, blockEnd);
 
        for (Size index = oldEntryCount; index < entryCount; ++index)
            zeroPaddingBytes((*this)[index].resetVariableFields());
    }

    ONIXS_CMEMDH_HOTPATH
    void construct(Size entryCount, const void* messageTail, const void* blockEnd)
    {
        assert(valid());
        assert(blockEnd);
        assert(messageTail);
 
        const Size oldEntryCount = allocate(entryCount, messageTail, blockEnd);
 
        for (Size index = oldEntryCount; index < entryCount; ++index)
            zeroPaddingBytes((*this)[index].reset());
    }
 
    ONIXS_CMEMDH_HOTPATH
    static void zeroPaddingBytes(Entry& entry)
    {
        assert(entry.valid());
        entry.zeroPaddingBytes(EntryType::minimalBlockLength(entry.version()));
    }
 
private:
    Dimension* header_;
    void* entries_;
    SchemaVersion version_;
 
    friend class SbeMessage;
};

template <class BinarySize>
class SbeVariableLengthFieldList
{
public:
    ONIXS_CMEMDH_HOTPATH
    SbeVariableLengthFieldList(void* binary, BinarySize size, SchemaVersion version) noexcept
        : binary_(binary)
        , size_(size)
        , version_(version)
    {
    }

    bool empty() const noexcept
    {
        return (0 == size_);
    }

    template <class BinaryVariableLengthFieldType>
    BinaryVariableLengthFieldType& head() const noexcept
    {
        return *static_cast<BinaryVariableLengthFieldType*>(binary_);
    }

    template <class BinaryVariableLengthFieldType>
    ONIXS_CMEMDH_HOTPATH SbeVariableLengthFieldList tail() const noexcept
    {
        assert(!empty());
 
        const BinarySize headSize = head<BinaryVariableLengthFieldType>().binarySize();
 
        assert(headSize <= size_);
 
        return SbeVariableLengthFieldList(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }

    template <class BinaryVariableLengthFieldType>
    ONIXS_CMEMDH_HOTPATH SbeVariableLengthFieldList checkTail() const
    {
        if ONIXS_CMEMDH_UNLIKELY (empty() || (size_ < BinaryVariableLengthFieldType::Size))
        {
            throwBadBinaryBlock();
        }
 
        const BinarySize headSize = head<BinaryVariableLengthFieldType>().binarySize();
 
        if ONIXS_CMEMDH_UNLIKELY (headSize > size_)
        {
            throwBadBinaryBlock();
        }
 
        return SbeVariableLengthFieldList(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }
 
private:
    void* binary_;
    BinarySize size_;
    SchemaVersion version_;
};

template <class BinarySize>
class SbeGroupList
{
public:
    ONIXS_CMEMDH_HOTPATH
    SbeGroupList(void* binary, BinarySize size, SchemaVersion version) noexcept
        : binary_(binary)
        , size_(size)
        , version_(version)
    {
    }

    ONIXS_CMEMDH_FORCEINLINE
    bool empty() const noexcept
    {
        return (0 == size_);
    }

    template <class Group>
    ONIXS_CMEMDH_FORCEINLINE
    ONIXS_CMEMDH_HOTPATH Group head() const noexcept
    {
        assert(!empty());
 
        return Group(binary_, size_, version_);
    }

    template <class Group>
    ONIXS_CMEMDH_HOTPATH SbeGroupList tail() const noexcept
    {
        assert(!empty());
 
        const BinarySize headSize = head<Group>().binarySize();
 
        assert(headSize <= size_);
 
        return SbeGroupList(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }

    template <class Group>
    ONIXS_CMEMDH_HOTPATH SbeVariableLengthFieldList<BinarySize> variableLengthFields() const noexcept
    {
        assert(!empty());
 
        const BinarySize headSize = head<Group>().binarySize();
 
        assert(headSize <= size_);
 
        return SbeVariableLengthFieldList<BinarySize>(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }

    template <class Group>
    ONIXS_CMEMDH_HOTPATH SbeGroupList checkTail() const
    {
        const BinarySize headSize = checkHead<Group>();
 
        return SbeGroupList(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }

    template <class Group>
    ONIXS_CMEMDH_HOTPATH SbeVariableLengthFieldList<BinarySize> checkVariableLengthFields() const
    {
        const BinarySize headSize = checkHead<Group>();
 
        return SbeVariableLengthFieldList<BinarySize>(advanceByBytes(binary_, headSize), size_ - headSize, version_);
    }
 
private:
    template <class Group>
    BinarySize checkHead() const
    {
        if ONIXS_CMEMDH_UNLIKELY (size_ < Group::Dimension::Size)
        {
            throwBadBinaryBlock();
        }
 
        const Group group = head<Group>();
 
        const BinarySize headSize = group.binarySize();
 
        if ONIXS_CMEMDH_UNLIKELY (headSize > size_)
        {
            throwBadBinaryBlock();
        }
 
        if (!group.empty())
        {
            const BinarySize entrySize = group.entrySize();
            const BinarySize expectedEntrySize = Group::Entry::minimalBlockLength(version_);
 
            if ONIXS_CMEMDH_UNLIKELY (entrySize < expectedEntrySize)
            {
                throwBadBinaryBlock();
            }
        }
 
        return headSize;
    }
 
    void* binary_;
    BinarySize size_;
    SchemaVersion version_;
};

template <typename Traits>
void checkVersion(SchemaVersion version)
{
    if ONIXS_CMEMDH_UNLIKELY (version < Traits::MinimalVersion)
    {
        throwBadMessageVersion(version, Traits::MinimalVersion);
    }
}

template <typename Traits>
void checkVersion(SchemaVersion since, SchemaVersion version)
{
    checkVersion<Traits>(version);
 
    if ONIXS_CMEMDH_UNLIKELY (version < since)
    {
        throwBadMessageVersion(version, since);
    }
}

template <typename Traits>
void checkSchemaId(SchemaId id)
{
    if ONIXS_CMEMDH_UNLIKELY (id != Traits::Id)
    {
        throwBadSchemaId(Traits::Id, id);
    }
}

template <typename Traits>
void checkSchema(SchemaId id, SchemaVersion version)
{
    checkSchemaId<Traits>(id);
    checkVersion<Traits>(version);
}

class SbeMessage : public SbeFields<Messaging::SbeMessage, MessageSize>
{
public:
    struct NoFieldsInit{};
    struct NoInit{};
    struct NoCheck{};

    typedef MessageSize EncodedLength;

    typedef MessageSize BlockLength;

    SbeMessage() noexcept
        : header_(nullptr)
        , size_(0)
    {
    }

    ONIXS_CMEMDH_HOTPATH
    SbeMessage(void* data, MessageSize size, SchemaVersion version)
        : header_(static_cast<MessageHeader*>(data))
        , size_(size)
    {
        assert(data);
        assert(size <= MaxMessageSize);
 
        if ONIXS_CMEMDH_UNLIKELY (size < MessageHeader::Size)
        {
            throwBinaryBlockIsTooSmall(size, MessageHeader::Size);
        }
 
        this->version(version);
    }

    ONIXS_CMEMDH_HOTPATH
    SbeMessage(void* data, MessageSize size)
        : header_(static_cast<MessageHeader*>(data))
        , size_(size)
    {
        assert(data);
        assert(size <= MaxMessageSize);
 
        if ONIXS_CMEMDH_UNLIKELY (size < MessageHeader::Size)
            throwBinaryBlockIsTooSmall(size, MessageHeader::Size);
 
        // Now it is safe to read header_.
        if ONIXS_CMEMDH_UNLIKELY (size < (MessageHeader::Size + header_->blockLength()))
        {
            throwBinaryBlockIsTooSmall(size, MessageHeader::Size + header_->blockLength());
        }
    }

    ONIXS_CMEMDH_HOTPATH
    SbeMessage(void* data, MessageSize size, NoCheck) noexcept
        : header_(static_cast<MessageHeader*>(data))
        , size_(size)
    {
        assert(data);
        assert(size <= MaxMessageSize);
 
        assert(size >= MessageHeader::Size);
        assert(size >= MessageHeader::Size + header_->blockLength());
    }

    void clear() noexcept
    {
        *this = SbeMessage();
        assert(!valid());
    }

    ONIXS_CMEMDH_FORCEINLINE
    bool valid() const noexcept
    {
        return (nullptr != header_);
    }

    ONIXS_CMEMDH_FORCEINLINE
    MessageTemplateId templateId() const noexcept
    {
        assert(valid());
 
        return header_->templateId();
    }

    ONIXS_CMEMDH_FORCEINLINE
    SchemaVersion version() const noexcept
    {
        assert(valid());
 
        return header_->version();
    }

    ONIXS_CMEMDH_FORCEINLINE
    SchemaId schemaId() const noexcept
    {
        assert(valid());
 
        return header_->schemaId();
    }

    ONIXS_CMEMDH_FORCEINLINE
    const void* binary() const noexcept
    {
        assert(valid());
 
        return header_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    void* binary() noexcept
    {
        assert(valid());
 
        return header_;
    }
 
    // \return the end of the memory block.
    ONIXS_CMEMDH_FORCEINLINE
    const void* blockEnd() noexcept
    {
        assert(valid());
 
        return advanceByBytes(header_, size_);
    }
 
    // \return the end of the memory block.
    ONIXS_CMEMDH_FORCEINLINE
    const void* blockEnd() const noexcept
    {
        assert(valid());
 
        return advanceByBytes(header_, size_);
    }

    ONIXS_CMEMDH_FORCEINLINE
    MessageSize bufferSize() const noexcept
    {
        return size_;
    }

    ONIXS_CMEMDH_FORCEINLINE
    void* body() noexcept
    {
        assert(valid());
 
        return advanceByBytes(header_, MessageHeader::Size);
    }

    ONIXS_CMEMDH_FORCEINLINE
    BlockLength blockLength() const noexcept
    {
        assert(valid());
 
        return header_->blockLength();
    }

    ONIXS_CMEMDH_FORCEINLINE
    const void* block() const noexcept
    {
        assert(valid());
 
        return advanceByBytes(header_, MessageHeader::Size);
    }

    ONIXS_CMEMDH_FORCEINLINE
    void* block() noexcept
    {
        assert(valid());
 
        return advanceByBytes(header_, MessageHeader::Size);
    }
 
protected:
    typedef SbeGroupList<MessageSize> GroupList;

    ONIXS_CMEMDH_FORCEINLINE
    SbeMessage& version(SchemaVersion version) noexcept
    {
        assert(valid());
 
        header_->setVersion(version);
 
        return *this;
    }

    ONIXS_CMEMDH_HOTPATH
    GroupList groups() noexcept
    {
        assert(header_);
 
        void* list = advanceByBytes<void>(body(), blockLength());
 
        const MessageSize listSize = size_ - MessageHeader::Size - header_->blockLength();
 
        return GroupList(list, listSize, header_->version());
    }

    ONIXS_CMEMDH_HOTPATH
    GroupList groups() const noexcept
    {
        assert(header_);
 
        const void* list = advanceByBytes(block(), blockLength());
 
        const MessageSize listSize = size_ - MessageHeader::Size - header_->blockLength();
 
        return GroupList(const_cast<void*>(list), listSize, header_->version());
    }

    template <typename Group>
    ONIXS_CMEMDH_HOTPATH void initGroup(Group& group, typename Group::EntrySize entrySize) noexcept
    {
        assert(group.valid());
        group.init(entrySize);
    }

    template <typename Group>
    ONIXS_CMEMDH_HOTPATH void setupGroup(Group& group, typename Group::Size entryCount, const void* messageTail)
    {
        assert(messageTail);
        assert(group.valid());
        group.setup(entryCount, messageTail, blockEnd());
    }

    template <typename Group>
    ONIXS_CMEMDH_HOTPATH void constructGroup(Group& group, typename Group::Size entryCount, const void* messageTail)
    {
        assert(messageTail);
        assert(group.valid());
        group.construct(entryCount, messageTail, blockEnd());
    }

    typedef SbeVariableLengthFieldList<MessageSize> VariableLengthFieldList;

    ONIXS_CMEMDH_HOTPATH
    VariableLengthFieldList variableLengthFields() noexcept
    {
        assert(header_);
 
        void* list = advanceByBytes<void>(body(), blockLength());
 
        const MessageSize listSize = size_ - MessageHeader::Size - header_->blockLength();
 
        return VariableLengthFieldList(list, listSize, header_->version());
    }

    ONIXS_CMEMDH_HOTPATH
    VariableLengthFieldList variableLengthFields() const noexcept
    {
        assert(header_);
 
        const void* list = advanceByBytes(block(), blockLength());
 
        const MessageSize listSize = size_ - MessageHeader::Size - header_->blockLength();
 
        return VariableLengthFieldList(const_cast<void*>(list), listSize, header_->version());
    }
 
    ONIXS_CMEMDH_HOTPATH
    void init(
        MessageHeader::TemplateId value,
        MessageHeader::BlockLength minimalBlockLength,
        MessageHeader::BlockLength blockLength,
        SchemaId id
    ) noexcept
    {
        assert(header_);
        assert(blockLength >= minimalBlockLength);
 
        header_->setTemplateId(value);
        header_->setBlockLength(blockLength);
        header_->setSchemaId(id);
 
        zeroPaddingBytes(minimalBlockLength);
    }
 
    ONIXS_CMEMDH_HOTPATH
    MessageSize calculateBinarySize(const void* tail) const noexcept
    {
        assert(tail);
 
        const ptrdiff_t distance = byteDistance(tail, binary());
 
        assert(distance > 0);
 
        assert(distance <= (std::numeric_limits<MessageSize>::max)());
 
        const MessageSize size = static_cast<MessageSize>(distance);
 
        assert(size <= size_);
 
        return size;
    }

    template <class Group, class Callable, class Owner>
    void resetGroup(Callable callable, Owner& owner) noexcept
    {
        const typename Group::EntrySize entrySize = Group::Entry::blockLength(version());
 
        Group grp = callable(owner);
 
        initGroup(grp, entrySize);
    }

    template <class Callable, class Owner>
    void setVariableLengthFieldToNull(Callable callable, SchemaVersion since, Owner& owner) noexcept
    {
        if ONIXS_CMEMDH_UNLIKELY (since > version())
        {
            return;
        }
 
        setVariableLengthFieldToNull(callable, owner);
    }

    template <class Group, class Callable, class Owner>
    void resetGroup(Callable callable, SchemaVersion since, Owner& owner)
    {
        if ONIXS_CMEMDH_UNLIKELY (since > version())
        {
            return;
        }
 
        resetGroup<Group>(callable, owner);
    }

    template <class Group, class Callable, class Owner>
    Group getGroup(Callable callable, Owner& owner) const noexcept
    {
        static_assert(noexcept(callable(owner)), "");
        return callable(owner);
    }

    template <class Group, class Callable, class Owner>
    Group getGroup(Callable callable, SchemaVersion since, Owner& owner) const noexcept
    {
        if ONIXS_CMEMDH_UNLIKELY (since > version())
        {
            return Group();
        }
 
        return getGroup<Group>(callable, owner);
    }

    template <class Group, class Callable, class Owner>
    Group constructGroup(Callable callable, typename Group::Size length, SchemaVersion since, Owner& owner)
    {
        if ONIXS_CMEMDH_UNLIKELY (since > version())
        {
            return Group();
        }
 
        return constructGroup<Group>(callable, length, owner);
    }

    template <class Group, class Callable, class Owner>
    Group constructGroup(Callable callable, typename Group::Size length, Owner& owner)
    {
        Group group = callable(owner);
 
        constructGroup(group, length, owner.tail());
 
        return group;
    }

    template <class Group, class Callable, class Owner>
    Group setupGroup(Callable callable, typename Group::Size length, SchemaVersion since, Owner& owner)
    {
        if ONIXS_CMEMDH_UNLIKELY (since > version())
        {
            return Group();
        }
 
        return setupGroup<Group>(callable, length, owner);
    }

    template <class Group, class Callable, class Owner>
    Group setupGroup(Callable callable, typename Group::Size length, Owner& owner)
    {
        Group group = callable(owner);
 
        setupGroup(group, length, owner.tail());
 
        return group;
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    ONIXS_CMEMDH_NODISCARD
    static constexpr MessageSize getMaxMessageSize() noexcept
    {
        return MaxMessageSize;
    }
 
private:
    MessageHeader* header_;
    MessageSize size_;
};

template <class Message>
ONIXS_CMEMDH_FORCEINLINE
ONIXS_CMEMDH_NODISCARD
const SbeMessage constructFromImmutableBlock(
    const void* data, MessageSize size,
    typename std::enable_if<std::is_same<typename std::remove_cv<Message>::type, SbeMessage>::value>::type* = nullptr)
{
    return SbeMessage(toMutable(data), size);
}

template <class Message>
ONIXS_CMEMDH_FORCEINLINE
ONIXS_CMEMDH_NODISCARD
const Message constructFromImmutableBlock(
    const void* data, MessageSize size,
    typename std::enable_if<std::is_base_of<SbeMessage, typename std::remove_cv<Message>::type>::value && !std::is_same<typename std::remove_cv<Message>::type, SbeMessage>::value>::type* = nullptr)
{
    return Message(toMutable(data), size, Messaging::SbeMessage::NoInit{});
}

template <class Message>
ONIXS_CMEMDH_FORCEINLINE
ONIXS_CMEMDH_NODISCARD
const SbeMessage constructFromImmutableBlock(
    const void* data, MessageSize size, SbeMessage::NoCheck noCheck,
    typename std::enable_if<std::is_same<typename std::remove_cv<Message>::type, SbeMessage>::value>::type* = nullptr) noexcept
{
    return SbeMessage(toMutable(data), size, noCheck);
}

template <class Message>
ONIXS_CMEMDH_FORCEINLINE
ONIXS_CMEMDH_NODISCARD
const Message constructFromImmutableBlock(
    const void* data, MessageSize size, SbeMessage::NoCheck noCheck,
    typename std::enable_if<std::is_base_of<SbeMessage, typename std::remove_cv<Message>::type>::value && !std::is_same<typename std::remove_cv<Message>::type, SbeMessage>::value>::type* = nullptr) noexcept
{
    return Message(toMutable(data), size, Messaging::SbeMessage::NoInit{}, noCheck);
}
 
ONIXS_CMEMDH_MESSAGING_NAMESPACE_END