BinaryMessage.h

Go to the documentation of this file.

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

template
<
    class Block,
    class BlockSize
>
class BinaryFields
{
    const Block& block() const
    {
        return *static_cast<const Block*>(this);
    }
 
protected:
    BinaryFields()
    {
    }

    ~BinaryFields()
    {
    }

    template
    <
        class FieldValue
    >
    const 
    FieldValue&
    ordinary(
        BlockSize offset) const
    {
        assert(
            block().bodySize() >=
            (offset + sizeof(FieldValue)));
 
        const void* 
        const fieldValue = 
            advanceByBytes(
                block().body(),
                offset);
 
        return 
            *static_cast
             <const FieldValue*>
             (fieldValue);
    }

    template
    <
        class FieldValue,
        class NullValue
    >
    bool 
    ordinary(
        FieldValue& value,
        BlockSize offset,
        const NullValue& null) const
    {
        const FieldValue& fieldValue = 
            ordinary<FieldValue>(offset);
 
        if (null != fieldValue)
        {
            value = fieldValue;
 
            return true;
        }
 
        return false;
    }

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

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

    template
    <
        class FieldValue,
        class NullValue
    >
    bool 
    ordinary(
        FieldValue& value,
        BlockSize offset,
        const NullValue& null,
        SchemaVersion since) const
    {
        return (
            since <= block().version() 
            && 
            ordinary(value, offset, null)
        );
    }
 

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

    template
    <
        class Enumeration,
        class NullValue
    >
    bool 
    enumeration(
        typename 
        Enumeration::Enum& value, 
        BlockSize offset,
        const NullValue& null) const
    {
        typedef 
        typename 
        Enumeration::Base
        Base;
 
        typedef 
        typename 
        Enumeration::Enum
        Enum;
 
        const Base& fieldValue = 
            ordinary<Base>(offset);
 
        if (null != fieldValue)
        {
            value = static_cast<Enum>(fieldValue);
 
            return true;
        }
 
        return false;
    }

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

    template
    <
        BlockSize Size
    >
    StrRef
    fixedStr(
        BlockSize offset) const
    {
        typedef Char Str[Size];
 
        const Str& str = 
            ordinary<Str>(offset);
 
        return 
            StrRef
            (
                str, 
                strnlen(str, Size)
            );
    }

    template
    <
        BlockSize Size
    >
    StrRef
    fixedStr(
        BlockSize offset,
        SchemaVersion since) const
    {
        return (
            since >= 
            block().version()
            
            ? fixedStr<Size>(offset)
            : StrRef()
        );
    }

    template
        <
        BlockSize Size
        >
        bool
        fixedStr(
            StrRef& value,
            BlockSize offset) const
    {
        typedef Char Str[Size];
 
        const Str& str =
            ordinary<Str>(offset);
 
        if (str[0])
        {
            value = fixedStr<Size>(offset);
            return true;
        }
        else
        {
            return false;
        }
    }
};

ONIXS_CMESTREAMLINEDMDH_EXPORTED
void
throwBadBinaryData(
    const Char* className);

ONIXS_CMESTREAMLINEDMDH_EXPORTED 
void 
throwBadBinaryGroup();

template
<
    class EntryType,
    class DimensionType,
    class GroupSizeType
>
class BinaryGroup
{
public:
    typedef EntryType Entry;

    typedef DimensionType Dimension;

    typedef GroupSizeType BinarySize;

    typedef
    typename 
    DimensionType::BlockLength 
    EntrySize;
 

    typedef 
    typename
    Dimension::NumInGroup
    Size;

    class Iterator
    {
        const void* entry_;
        EntrySize size_;
        
        SchemaVersion version_;
 
    public:
        typedef EntryType Entry;

        typedef const Entry value_type;

        typedef const Entry* pointer;

        typedef const Entry& reference;
        
        typedef ptrdiff_t difference_type;
        
        typedef 
        std::random_access_iterator_tag 
        iterator_category;

        Iterator()
          : entry_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
          , size_(0)
          , version_(0)
        {
        }

        Iterator(
            const void* entry,
            EntrySize size,
            SchemaVersion version)
            : entry_(entry)
            , size_(size)
            , version_(version)
        {
        }

        Iterator(
            const Iterator& other)
            : entry_(
                other.entry_)
            , size_(
                other.size_)
            , version_(
                other.version_)
        {
        }

        const Entry get() const
        {
            assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != entry_);
 
            return 
                Entry(
                    entry_, 
                    size_,
                    version_);
        }

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

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

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

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

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

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

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

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

        Iterator 
        operator -(
            difference_type distance) const
        {
            return 
                Iterator(
                    advanceBackByBytes(
                        entry_, 
                        distance * size_),
                    size_,
                    version_);
        }

        Iterator&
        operator =(
            const Iterator& other) 
        {
            entry_ = other.entry_;
            size_ = other.size_;
 
            version_ = other.version_;
 
            return *this;
        }
    };

    BinaryGroup()
      : entries_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
      , entrySize_(0)
      , entryCount_(0)
      , version_(0)
      , size_(0)
    {
    }

    BinaryGroup(
        const void* data, 
        BinarySize size,
        SchemaVersion version)
        : entries_(
            advanceByBytes(
                data, 
                Dimension::Size))
        , entrySize_(0)
        , entryCount_(0)
        , version_(version)
        , size_(Dimension::Size)
    {
        if (size < size_)
            throwBadBinaryGroup();
 
        const 
        Dimension* 
        group = 
            static_cast
            <const Dimension*>
            (data);
 
        entrySize_ = 
            group->blockLength();
 
        entryCount_ = 
            group->numInGroup();
 
        size_ += 
            (
                static_cast
                <BinarySize>
                (entrySize_) * 
                static_cast
                <BinarySize>
                (entryCount_)
            );
 
        if (size < size_)
            throwBadBinaryGroup();
    }

    BinaryGroup(
        const BinaryGroup& other)
        : entries_(
            other.entries_)
        , entrySize_(
            other.entrySize_)
        , entryCount_(
            other.entryCount_)
        , version_(
            other.version_)
        , size_(
            other.size_)
    {
    }

    operator bool() const
    {
        return (ONIXS_CMESTREAMLINEDMDH_NULLPTR != entries_);
    }

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

    Size size() const
    {
        return entryCount_;
    }

    Iterator begin() const
    {
        return 
            Iterator(
                entries_,
                entrySize_,
                version_);
    }

    Iterator end() const
    {
        return 
            Iterator(
                advanceByBytes(
                    binary(), 
                    binarySize()),
                entrySize_,
                version_);
    }

    Entry operator [](Size index) const
    {
        assert(index < size());
 
        return 
            Entry(
                advanceByBytes(
                    entries(),
                    index * entrySize_), 
                entrySize_,
                version_);
    }

    const void* binary() const
    {
        return 
            entries_ 
            ? advanceBackByBytes(
                entries_, Dimension::Size) 
            : ONIXS_CMESTREAMLINEDMDH_NULLPTR;
    }

    BinarySize binarySize() const
    {
        return size_;
    }

    const void* entries() const
    {
        return entries_;
    }

    EntrySize entrySize() const
    {
        return entrySize_;
    }

    BinaryGroup&
    operator =(
        const BinaryGroup& other)
    {
        entries_ = other.entries_;
 
        entrySize_ = other.entrySize_;
        entryCount_ = other.entryCount_;
 
        version_ = other.version_;
        size_ = other.size_;
 
        return *this;
    }
 
private:
    const void* entries_;
 
    EntrySize entrySize_;
    Size entryCount_;
 
    SchemaVersion version_;
    BinarySize size_;
};

template
<
    class EntryType,
    class DimensionType,
    class GroupSizeType
>
class BinaryGroupWithNested
{
public:
    typedef EntryType Entry;

    typedef DimensionType Dimension;

    typedef GroupSizeType BinarySize;

    typedef
        typename
        DimensionType::BlockLength
        EntrySize;
 

    typedef
        typename
        Dimension::NumInGroup
        Size;

    class Iterator
    {
        const void* entry_;
        EntrySize size_;
 
        SchemaVersion version_;
 
    public:
        typedef EntryType Entry;

        typedef const Entry value_type;

        typedef const Entry* pointer;

        typedef const Entry& reference;

        typedef ptrdiff_t difference_type;

        typedef
            std::forward_iterator_tag
            iterator_category;

        Iterator()
            : entry_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
            , size_(0)
            , version_(0)
        {
        }

        Iterator(
            const void* entry,
            EntrySize size,
            SchemaVersion version)
            : entry_(entry)
            , size_(size)
            , version_(version)
        {
        }

        Iterator(
            const Iterator& other)
            : entry_(
                other.entry_)
            , size_(
                other.size_)
            , version_(
                other.version_)
        {
        }

        const Entry get() const
        {
            assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != entry_);
 
            return
                Entry(
                    entry_,
                    size_,
                    version_);
        }

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

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

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

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

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

        Iterator&
            operator ++()
        {
            advance(1);
            return *this;
        }

        Iterator
            operator +(
                difference_type distance) const
        {
            Iterator result(*this);
            result.advance(distance);
            return result;
        }

        Iterator&
            operator =(
                const Iterator& other)
        {
            entry_ = other.entry_;
            size_ = other.size_;
 
            version_ = other.version_;
 
            return *this;
        }
    private:
        void advance(difference_type count)
        {
            const void* rawEntry = entry_;
            for (difference_type i = 0; i < count; ++i)
            {
                // Query the last position of last repeating group at the entry.
                // Here we need to has EntryType::next() method.
                Entry e(rawEntry, size_, version_);
                // Move entry over nested groups
                rawEntry = e.next(version_).body();
            }
            entry_ = rawEntry;
        }
    };

    BinaryGroupWithNested()
        : entries_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
        , entrySize_(0)
        , entryCount_(0)
        , version_(0)
        , size_(0)
    {
    }

    BinaryGroupWithNested(
        const void* data,
        BinarySize size,
        SchemaVersion version)
        : entries_(
            advanceByBytes(
                data,
                Dimension::Size))
        , entrySize_(0)
        , entryCount_(0)
        , version_(version)
        , size_(Dimension::Size)
    {
        if (size < size_)
            throwBadBinaryGroup();
 
        const
            Dimension*
            group =
            static_cast
            <const Dimension*>
            (data);
 
        entrySize_ =
            group->blockLength();
 
        entryCount_ =
            group->numInGroup();
 
        size_ += (static_cast<BinarySize>(entrySize_) * static_cast<BinarySize>(entryCount_));
 
        if (size < size_)
            throwBadBinaryGroup();
    }

    BinaryGroupWithNested(
        const BinaryGroupWithNested& other)
        : entries_(
            other.entries_)
        , entrySize_(
            other.entrySize_)
        , entryCount_(
            other.entryCount_)
        , version_(
            other.version_)
        , size_(
            other.size_)
    {
    }

    operator bool() const
    {
        return (ONIXS_CMESTREAMLINEDMDH_NULLPTR != entries_);
    }

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

    Size size() const
    {
        return entryCount_;
    }

    Iterator begin() const
    {
        return
            Iterator(
                entries_,
                entrySize_,
                version_);
    }

    Iterator end() const
    {
        return begin() + size();
    }

    const void* binary() const
    {
        return
            entries_
            ? advanceBackByBytes(
                entries_, Dimension::Size)
            : ONIXS_CMESTREAMLINEDMDH_NULLPTR;
    }

    BinarySize binarySize() const
    {
        return size_;
    }

    const void* entries() const
    {
        return entries_;
    }

    EntrySize entrySize() const
    {
        return entrySize_;
    }

    BinaryGroupWithNested&
        operator =(
            const BinaryGroupWithNested& other)
    {
        entries_ = other.entries_;
 
        entrySize_ = other.entrySize_;
        entryCount_ = other.entryCount_;
 
        version_ = other.version_;
        size_ = other.size_;
 
        return *this;
    }
 
private:
    const void* entries_;
 
    EntrySize entrySize_;
    Size entryCount_;
 
    SchemaVersion version_;
    BinarySize size_;
};

template
<
    class BinarySize
>
class BinaryGroupList
{
    const void* binary_;
    BinarySize size_;
    SchemaVersion version_;
 
public:
    BinaryGroupList()
      : binary_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
      , size_(0)
      , version_(0)
    {
    }

    BinaryGroupList(
        const void* binary, 
        BinarySize size,
        SchemaVersion version)
        : binary_(binary)
        , size_(size)
        , version_(version)
    {
    }

    BinaryGroupList(
        const BinaryGroupList& other)
        : binary_(
            other.binary_)
        , size_(
            other.size_)
        , version_(
            other.version_)
    {
    }

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

    template
    <
        class Group
    >
    Group head() const
    {
        return 
            Group(
                binary_, 
                size_,
                version_);
    }

    template
    <
        class Group
    >
    BinaryGroupList tail() const
    {
        const 
        BinarySize 
        headSize = 
            head<Group>().
                binarySize();
 
        assert(headSize <= size_);
 
        // TODO: Move the calculation to the group itslef,
        // to support nested groups.
        return 
            BinaryGroupList(
                advanceByBytes(
                    binary_, headSize), 
                size_ - headSize,
                version_);
    }

    const void* binary() const
    {
        return binary_;
    }

    BinarySize binarySize() const
    {
        return size_;
    }

    BinaryGroupList&
    operator =(
        const BinaryGroupList& other)
    {
        binary_ = other.binary_;
        size_ = other.size_;
 
        version_ = other.version_;
 
        return *this;
    }
};
 
 
 

inline
void
throwBadBinaryMessage()
{
    throw std::runtime_error(
        "Cannot construct message instance. Memory "
        "block is too small to access SBE message header. ");
}

typedef UInt16 MessageSize;

typedef MessageSize EncodedLength;

typedef MessageSize BlockLength;

template
<
    class BodySizeType
>
class
    BinaryGroupEntry
    : public BinaryFields
    <
    BinaryGroupEntry
    <
    BodySizeType
    >,
    BodySizeType
    >
{
    const void* body_;
    BodySizeType size_;
 
    SchemaVersion version_;
 
protected:
    typedef
        BinaryGroupList<MessageSize>
        GroupList;

    GroupList groups() const
    {
        const void*
            const list =
            advanceByBytes(
                body(), bodySize());
 
        //const
        //    MessageSize
        //    listSize =
        //    size_ - entrySize;
 
        return
            GroupList(
                list,
                10000,
                version_);
    }
 
public:
    typedef
        BodySizeType
        BodySize;

    BinaryGroupEntry()
        : body_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
        , size_(0)
        , version_(0)
    {
    }

    BinaryGroupEntry(
        const void* body,
        BodySize size,
        SchemaVersion version)
        : body_(body)
        , size_(size)
        , version_(version)
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != body);
 
        assert(
            version >=
            SchemaTraits::
            minimalVersion());
    }

    BinaryGroupEntry(
        const BinaryGroupEntry& other)
        : body_(
            other.body_)
        , size_(
            other.size_)
        , version_(
            other.version_)
    {
    }

    operator bool() const
    {
        return (ONIXS_CMESTREAMLINEDMDH_NULLPTR != body_);
    }

    const void* body() const
    {
        return body_;
    }

    BodySize bodySize() const
    {
        return size_;
    }

    SchemaVersion version() const
    {
        return version_;
    }

    BinaryGroupEntry&
        operator =(
            const BinaryGroupEntry& other)
    {
        body_ = other.body_;
        size_ = other.size_;
 
        version_ = other.version_;
 
        return *this;
    }
};
 

ONIXS_CMESTREAMLINEDMDH_EXPORTED
void 
throwBadMessageVersion(
    SchemaVersion messageVersion);

typedef
MessageHeader::TemplateId
MessageTemplateId;

ONIXS_CMESTREAMLINEDMDH_LTWT_CLASS 
BinaryMessage 
: public BinaryFields
<
    BinaryMessage,
    MessageSize
>
{
    const MessageHeader* header_;
    MessageSize size_;
 
protected:
    typedef 
    BinaryGroupList<MessageSize>
    GroupList;

    GroupList groups() const
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
 
        const void* 
        const list = 
            advanceByBytes(
                body(), bodySize());
 
        const 
        MessageSize 
        listSize = 
            size_ - 
            MessageHeader::Size - 
            header_->blockLength();
 
        return 
            GroupList(
                list, 
                listSize, 
                header_->version());
    }
 
public:
    typedef MessageSize BinarySize;

    typedef 
    MessageHeader::BlockLength 
    BodySize;

    BinaryMessage()
      : header_(ONIXS_CMESTREAMLINEDMDH_NULLPTR)
      , size_(0)
    {
    }

    BinaryMessage(
        const void* data, 
        MessageSize size)
        : header_(
            static_cast
            <const MessageHeader*>
            (data))
        , size_(size)
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != data);
 
        if (size < 
            MessageHeader::Size 
            || 
            size < 
            (MessageHeader::Size + 
                header_->blockLength()))
        {
            throwBadBinaryMessage();
        }
 
        const 
        SchemaVersion 
        version = this->version();
 
        if (version <
            SchemaTraits::minimalVersion())
        {
            throwBadMessageVersion(version);
        }
    }

    BinaryMessage(
        const BinaryMessage& other)
        : header_(other.header_)
        , size_(other.size_)
    {
    }

    operator bool() const
    {
        return (ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
    }

    MessageTemplateId templateId() const
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
 
        return header_->templateId();
    }

    SchemaVersion version() const
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
 
        return header_->version();
    }

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

    MessageSize binarySize() const
    {
        return size_;
    }

    const void* body() const
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
 
        return 
            advanceByBytes(
                header_, 
                MessageHeader::Size);
    }

    BodySize bodySize() const
    {
        assert(ONIXS_CMESTREAMLINEDMDH_NULLPTR != header_);
 
        return header_->blockLength();
    }

    BinaryMessage& 
    operator =(
        const BinaryMessage& other)
    {
        header_ = other.header_;
        size_ = other.size_;
 
        return *this;
    }
};
 
ONIXS_CMESTREAMLINEDMDH_NAMESPACE_END