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/MDH/Assertion.h>
 
#include <OnixS/CME/MDH/String.h>
#include <OnixS/CME/MDH/Memory.h>
 
#include <OnixS/CME/MDH/Composites.h>
#include <OnixS/CME/MDH/SchemaTraits.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

template <class Container, class BlockLength>
class BinaryBlock
{
protected:
    BinaryBlock() {}

    ~BinaryBlock() {}

    template <class Value>
    Value ordinary(BlockLength offset) const
    {
        const size_t sizeOfValue = sizeof(Value);
 
        assert((offset + sizeOfValue) <= container().blockLength());
 
        const void* const location = advanceByBytes(container().block(), offset);
 
        Value result;
 
        memcpy(&result, location, sizeOfValue);
 
        return result;
    }

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

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

    template <class Enumeration>
    typename Enumeration::Enum enumeration(BlockLength 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, BlockLength offset, const NullValue& null) const
    {
        typedef typename Enumeration::Base Base;
 
        typedef typename Enumeration::Enum Enum;
 
        const Base optional = ordinary<Base>(offset);
 
        if (null != optional)
        {
            value = static_cast<Enum>(optional);
 
            return true;
        }
 
        return false;
    }

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

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

    template <class NullValue>
    bool decimal(Decimal& value, BlockLength 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 NullValue>
    bool decimal(Decimal& value, BlockLength offset, const NullValue& null, SchemaVersion since) const
    {
        return (since <= container().version() && decimal(value, offset, null));
    }

    template <BlockLength Length>
    StrRef fixedStr(BlockLength offset) const
    {
        assert((offset + Length) <= container().blockLength());
 
        const Char* const text = reinterpret_cast<const Char*>(advanceByBytes(container().block(), offset));
 
        return StrRef(text, strnlen(text, Length));
    }

    template <BlockLength Length>
    StrRef fixedStr(BlockLength offset, SchemaVersion since) const
    {
        return (since <= container().version() ? fixedStr<Length>(offset) : StrRef());
    }
 
private:
    const Container& container() const
    {
        return *static_cast<const Container*>(this);
    }
 
};

ONIXS_CMEMDH_EXPORTED
void throwBadBinaryData(const Char* className);

template <class Length>
class BinaryGroupEntry : public BinaryBlock<BinaryGroupEntry<Length>, Length>
{
public:
    typedef Length EncodedLength;

    typedef Length BlockLength;

    BinaryGroupEntry()
        : encoded_(ONIXS_CMEMDH_NULLPTR)
        , length_(0)
        , version_(0)
    {
    }

    BinaryGroupEntry(const void* encoded, BlockLength length, SchemaVersion version)
        : encoded_(encoded)
        , length_(length)
        , version_(version)
    {
        assert(ONIXS_CMEMDH_NULLPTR != encoded);
 
        assert(version >= SchemaTraits::minimalVersion());
    }

    BinaryGroupEntry(const BinaryGroupEntry& other)
        : encoded_(other.encoded_)
        , length_(other.length_)
        , version_(other.version_)
    {
    }

    operator bool() const
    {
        return (ONIXS_CMEMDH_NULLPTR != encoded_);
    }

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

    EncodedLength encodedLength() const
    {
        return length_;
    }

    const void* block() const
    {
        return encoded_;
    }

    BlockLength blockLength() const
    {
        return length_;
    }

    SchemaVersion version() const
    {
        return version_;
    }

    BinaryGroupEntry& operator=(const BinaryGroupEntry& other)
    {
        encoded_ = other.encoded_;
        length_ = other.length_;
 
        version_ = other.version_;
 
        return *this;
    }
 
private:
    const void* encoded_;
    Length length_;
 
    SchemaVersion version_;
};

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

    typedef EntryType Entry;

    typedef NumInGroup Size;

    class Iterator
    {
    public:
        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()
            : encoded_(ONIXS_CMEMDH_NULLPTR)
            , length_(0)
            , version_(0)
        {
        }

        Iterator(const void* block, BlockLength length, SchemaVersion version)
            : encoded_(block)
            , length_(length)
            , version_(version)
        {
        }

        Iterator(const Iterator& other)
            : encoded_(other.encoded_)
            , length_(other.length_)
            , version_(other.version_)
        {
        }

        const Entry get() const
        {
            assert(ONIXS_CMEMDH_NULLPTR != encoded_);
 
            return Entry(encoded_, length_, version_);
        }

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

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

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

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

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

        Iterator& operator++()
        {
            encoded_ = advanceByBytes(encoded_, length_);
 
            return *this;
        }

        Iterator& operator--()
        {
            encoded_ = advanceBackByBytes(encoded_, length_);
 
            return *this;
        }

        Iterator operator+(difference_type distance) const
        {
            return Iterator(
                advanceByBytes(encoded_, distance * static_cast<difference_type>(length_)), length_, version_
            );
        }

        Iterator operator-(difference_type distance) const
        {
            return Iterator(
                advanceBackByBytes(encoded_, distance * static_cast<difference_type>(length_)), length_, version_
            );
        }

        Iterator& operator=(const Iterator& other)
        {
            encoded_ = other.encoded_;
            length_ = other.length_;
            version_ = other.version_;
 
            return *this;
        }
 
    private:
        const void* encoded_;
        BlockLength length_;
 
        SchemaVersion version_;
    };

    BinaryGroupEntries()
        : encoded_(ONIXS_CMEMDH_NULLPTR)
        , blockLength_(0)
        , size_(0)
        , version_(0)
    {
    }

    BinaryGroupEntries(const void* encoded, BlockLength blockLength, Size groupSize, SchemaVersion version)
        : encoded_(encoded)
        , blockLength_(blockLength)
        , size_(groupSize)
        , version_(version)
    {
    }

    template <class OtherEntry, class OtherBlockLength, class OtherNumInGroup, class OtherLength>
    BinaryGroupEntries(const BinaryGroupEntries<OtherEntry, OtherBlockLength, OtherNumInGroup, OtherLength>& other)
        : 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_);
    }

    operator bool() const
    {
        return (ONIXS_CMEMDH_NULLPTR != encoded_);
    }

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

    Size size() const
    {
        return size_;
    }

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

    Iterator end() const
    {
        return Iterator(
            advanceByBytes(encoded_, static_cast<ptrdiff_t>(blockLength_) * static_cast<ptrdiff_t>(size_)),
            blockLength_,
            version_
        );
    }

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

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

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

    template <class OtherEntry, class OtherBlockLength, class OtherNumInGroup, class OtherLength>
    BinaryGroupEntries&
    operator=(const BinaryGroupEntries<OtherEntry, OtherBlockLength, OtherNumInGroup, OtherLength>& other)
    {
        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 BinaryGroupEntries;
 
    // Actual parameters.
 
    const void* encoded_;
 
    BlockLength blockLength_;
    NumInGroup size_;
 
    SchemaVersion version_;
};

ONIXS_CMEMDH_EXPORTED
void throwBadBinaryGroup();

template <class EntryType, class DimensionType, class LengthType>
class BinaryGroup
{
public:
    typedef DimensionType Dimension;

    typedef BinaryGroupEntries<EntryType, typename Dimension::BlockLength, typename Dimension::NumInGroup, LengthType>
        Entries;

    typedef typename Entries::Iterator Iterator;

    typedef typename Entries::Entry Entry;

    typedef typename Entries::Size Size;

    typedef LengthType EncodedLength;

    BinaryGroup()
        : header_(ONIXS_CMEMDH_NULLPTR)
    {
    }

    BinaryGroup(const void* encoded, EncodedLength length, SchemaVersion version)
        : header_(static_cast<const Dimension*>(encoded))
    {
        if (length < Dimension::Size)
        {
            throwBadBinaryGroup();
        }
        else
        {
            entries_ = Entries(
                advanceByBytes(header_, Dimension::Size), header_->blockLength(), header_->numInGroup(), version
            );
 
            if (length < encodedLength())
            {
                throwBadBinaryGroup();
            }
        }
    }

    BinaryGroup(const BinaryGroup& other)
        : header_(other.header_)
        , entries_(other.entries_)
    {
    }

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

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

    Size size() const
    {
        return entries_.size();
    }

    Iterator begin() const
    {
        return entries_.begin();
    }

    Iterator end() const
    {
        return entries_.end();
    }

    Entry operator[](Size index) const
    {
        return entries_[index];
    }

    const Entries& entries() const
    {
        return entries_;
    }

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

    EncodedLength encodedLength() const
    {
        return (Dimension::Size + entries_.encodedLength());
    }

    BinaryGroup& operator=(const BinaryGroup& other)
    {
        header_ = other.header_;
        entries_ = other.entries_;
 
        return *this;
    }
 
private:
    const Dimension* header_;
    Entries entries_;
};

template <class Length>
class BinaryGroups
{
public:
    typedef Length EncodedLength;

    BinaryGroups()
        : encoded_(ONIXS_CMEMDH_NULLPTR)
        , length_(0)
        , version_(0)
    {
    }

    BinaryGroups(const void* encoded, EncodedLength length, SchemaVersion version)
        : encoded_(encoded)
        , length_(length)
        , version_(version)
    {
    }

    BinaryGroups(const BinaryGroups& other)
        : encoded_(other.encoded_)
        , length_(other.length_)
        , version_(other.version_)
    {
    }

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

    template <class Group>
    Group head() const
    {
        return Group(encoded_, length_, version_);
    }

    template <class Group>
    BinaryGroups tail() const
    {
        const EncodedLength headLength = head<Group>().encodedLength();
 
        assert(length_ >= headLength);
 
        return BinaryGroups(advanceByBytes(encoded_, headLength), length_ - headLength, version_);
    }

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

    EncodedLength encodedLength() const
    {
        return length_;
    }

    BinaryGroups& operator=(const BinaryGroups& other)
    {
        encoded_ = other.encoded_;
        length_ = other.length_;
 
        version_ = other.version_;
 
        return *this;
    }
 
private:
    const void* encoded_;
 
    Length length_;
 
    SchemaVersion version_;
};

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

ONIXS_CMEMDH_EXPORTED
void throwBadMessageVersion(SchemaVersion, SchemaVersion, const Char* = ONIXS_CMEMDH_NULLPTR);

typedef MessageHeader::TemplateId MessageTemplateId;

typedef UInt16 MessageSize;

class ONIXS_CMEMDH_LTWT BinaryMessage : public BinaryBlock<BinaryMessage, MessageSize>
{
public:
    typedef MessageSize EncodedLength;

    typedef MessageSize BlockLength;

    typedef BinaryGroups<MessageSize> Groups;

    BinaryMessage()
        : header_(ONIXS_CMEMDH_NULLPTR)
        , length_(0)
    {
    }

    BinaryMessage(const void* encoded, EncodedLength length)
        : header_(static_cast<const MessageHeader*>(encoded))
        , length_(length)
    {
        assert(ONIXS_CMEMDH_NULLPTR != encoded);
 
        if (length < MessageHeader::Size || length < (MessageHeader::Size + header_->blockLength()))
        {
            throwBadBinaryMessage();
        }
    }

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

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

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

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

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

    EncodedLength encodedLength() const
    {
        return length_;
    }

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

    BlockLength blockLength() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);
 
        return header_->blockLength();
    }

    Groups groups() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);
 
        return Groups(
            advanceByBytes(block(), blockLength()),
            length_ - MessageHeader::Size - header_->blockLength(),
            header_->version()
        );
    }

    BinaryMessage& operator=(const BinaryMessage& other)
    {
        header_ = other.header_;
        length_ = other.length_;
 
        return *this;
    }
 
protected:
    BinaryMessage(const void* encoded, EncodedLength length, SchemaVersion since)
        : header_(static_cast<const MessageHeader*>(encoded))
        , length_(length)
    {
        assert(ONIXS_CMEMDH_NULLPTR != encoded);
 
        if (length < MessageHeader::Size || length < (MessageHeader::Size + header_->blockLength()))
            throwBadBinaryMessage();
 
        const SchemaVersion current = version();
 
        if (current < since)
            throwBadMessageVersion(current, since);
    }
 
private:
    typedef BinaryBlock<BinaryMessage, MessageSize> Base;
 
    const MessageHeader* header_;
    MessageSize length_;
};
 
ONIXS_CMEMDH_NAMESPACE_END