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

template
<
    class Container,
    class BlockLength
>
class BinaryBlock
{
    const 
    Container& 
    container() const
    {
        return 
            *static_cast
            <const Container*>
            (this);
    }
 
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()
        );
    }
};

ONIXS_CONFLATEDUDP_EXPORTED
void
throwBadBinaryData(
    const Char* className);

template
<
    class Length
>
class 
BinaryGroupEntry
: public BinaryBlock
<
    BinaryGroupEntry
    <
        Length
    >,
    Length
>
{
    const void* encoded_;
    Length length_;
 
    SchemaVersion version_;
 
public:
    typedef Length EncodedLength;

    typedef Length BlockLength;

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

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

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

    operator bool() const
    {
        return (NULL != 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;
    }
};

template
<
    class EntryType,
    class BlockLength,
    class NumInGroup,
    class Length
>
class BinaryGroupEntries
{
    // 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_;
 
public:
    typedef Length EncodedLength;

    typedef EntryType Entry;

    typedef NumInGroup Size;

    class Iterator
    {
        const void* encoded_;
        BlockLength length_;
        
        SchemaVersion version_;
 
    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_(NULL)
          , 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(NULL != 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;
        }
    };

    BinaryGroupEntries()
      : encoded_(NULL)
      , 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 (NULL != 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;
    }
};

ONIXS_CONFLATEDUDP_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_(NULL)
    {
    }

    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 (NULL != 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
{
    const void* encoded_;
    
    Length length_;
    
    SchemaVersion version_;
 
public:
    typedef Length EncodedLength;

    BinaryGroups()
      : encoded_(NULL)
      , 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;
    }
};

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

ONIXS_CONFLATEDUDP_EXPORTED
void 
throwBadMessageVersion
(
    const Char*, 
    SchemaVersion, 
    SchemaVersion
);

ONIXS_CONFLATEDUDP_EXPORTED
void 
throwBadMessageVersion(
    SchemaVersion messageVersion);

typedef
MessageHeader::TemplateId
MessageTemplateId;

typedef UInt16 MessageSize;

ONIXS_CONFLATEDUDP_LTWT_CLASS 
BinaryMessage 
: public BinaryBlock
<
    BinaryMessage, 
    MessageSize
>
{
    typedef 
    BinaryBlock
    <
        BinaryMessage, 
        MessageSize
    >
    Base;
 
    const MessageHeader* header_;
    MessageSize length_;
 
public:
    typedef MessageSize EncodedLength;

    typedef MessageSize BlockLength;

    typedef 
    BinaryGroups<MessageSize>
    Groups;

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

    BinaryMessage(
        const void* encoded, 
        EncodedLength length)
        : header_(
            static_cast
            <const MessageHeader*>
            (encoded))
        , length_(length)
    {
        assert(NULL != encoded);
 
        if (length < 
            MessageHeader::Size 
            || 
            length < 
            (MessageHeader::Size + 
                header_->blockLength()))
        {
            throwBadBinaryMessage();
        }
        else
        {
            const 
            SchemaVersion 
            version = 
                this->version();
 
            if (version <
                SchemaTraits::
                    minimalVersion())
            {
                throwBadMessageVersion(version);
            }
        }
    }

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

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

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

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

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

    EncodedLength encodedLength() const
    {
        return length_;
    }

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

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

    Groups groups() const
    {
        assert(NULL != 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:
    class NoVersionCheck{};
 
    BinaryMessage(
        const void* encoded,
        EncodedLength length,
        NoVersionCheck)
        : header_(
        static_cast
            <const MessageHeader*>
        (encoded))
        , length_(length)
    {
        assert(NULL != encoded);
 
        if (length <
            MessageHeader::Size
            ||
            length <
            (MessageHeader::Size +
             header_->blockLength()))
        {
            throwBadBinaryMessage();
        }
    }
};
 
ONIXS_CONFLATEDUDP_NAMESPACE_END