MessageHolder.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 <vector>
 
#include <OnixS/CME/iLink3/messaging/MaxMessageSize.h>
#include <OnixS/CME/iLink3/messaging/SbeMessage.h>
#include <OnixS/CME/iLink3/messaging/TagBased/Message.h>
#include <OnixS/CME/iLink3/messaging/NetworkMessage.h>
 
namespace OnixS
{
    namespace CME
    {
        namespace iLink3
        {
            ONIXS_ILINK3_EXPORTED_CLASS Session;
        }
    }
}
 
ONIXS_ILINK3_MESSAGING_NAMESPACE_BEGIN

ONIXS_ILINK3_EXPORTED
Messaging::SchemaVersion getMessagingVersion(const Session&) noexcept;

struct FieldsInitPolicy
{
    template <typename SbeMessageType>
    inline static SbeMessageType createMessage(
        void* data, MessageSize length, SchemaVersion version)
    {
        return SbeMessageType(data, length, version);
    }

    inline static const char* name() noexcept
    {
        return "FieldsInitPolicy";
    }
};

struct FieldsNoInitPolicy
{
    template <typename SbeMessageType>
    inline static SbeMessageType createMessage(
        void* data, MessageSize length, SchemaVersion version)
    {
        return SbeMessageType(
            data, length, SbeMessage::NoFieldsInit(), version);
    }

    inline static const char* name() noexcept
    {
        return "FieldsNoInitPolicy";
    }
};

template
<
    typename MessageType,
    bool isFix =
        IsBaseOf<TagBased::Message, MessageType>::value
>
struct HeldAdapter;
 
template <typename MessageType>
struct HeldAdapter<MessageType, true> final
    : public MessageType
{
    static_assert(IsBaseOf<TagBased::Message, MessageType>::value, "Not a message.");
 
    enum { isFix = true };
 
    typedef typename
    MessageType::Binary
        SbeType;
 
    typedef typename
    SbeType::EncodedLength
        EncodedLength;
 
    HeldAdapter() = default;
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SchemaVersion version)
        : MessageType(SbeType(data, length, version))
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoFieldsInit,
        SchemaVersion version)
        : MessageType(SbeType(data, length, version))
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoInit)
        : MessageType(SbeType(data, length))
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoInit,
        SbeMessage::NoCheck)
    noexcept
        : MessageType(
        SbeType(
            data,
            length,
            SbeMessage::NoInit(),
            SbeMessage::NoCheck()))
    {
    }
};
 
template <typename MessageType>
struct HeldAdapter<MessageType, false> final
    : public MessageType
{
    static_assert(IsBaseOf<SbeMessage, MessageType>::value, "Not a message.");
 
    enum { isFix = false };
 
    typedef MessageType SbeType;
 
    typedef typename
    SbeType::EncodedLength
        EncodedLength;
 
    HeldAdapter() = default;
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SchemaVersion version)
        : MessageType(data, length, version)
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoFieldsInit,
        SchemaVersion version)
        : MessageType(data, length, version)
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoInit)
        : MessageType(data, length)
    {
    }
 
    HeldAdapter(
        void* data,
        EncodedLength length,
        SbeMessage::NoInit,
        SbeMessage::NoCheck)
    noexcept
        : MessageType(
            data,
            length,
            SbeMessage::NoInit(),
            SbeMessage::NoCheck())
    {
    }
};

template <typename, size_t, typename>
class MessageHolder;
template <
    template <typename, size_t, typename> class HolderType,
    typename MsgType,
    size_t MaxMessageSize,
    typename MessageInitializer>
inline void toStr(
    std::string& str,
    const HolderType<MsgType, MaxMessageSize, MessageInitializer>& holder)
{
    str += "MessageHolder[";
 
    str += "BufferSize=";
    toStr(str, holder.BufferSize);
 
    str += ", MessageInitializer=";
    str += MessageInitializer::name();
 
    str += ", ";
    toStr(str, *holder.header());
 
    str += ", ";
    toStr(str, holder.message());
 
    str += "]";
}

constexpr char magicDebugValue = 0x5A;

constexpr UInt8 DefaultMaxGroupItems = 100;

template <
    typename MessageTypeT,
    size_t MaxMessageSize =
        GetMaxMessageSize<typename HeldAdapter<MessageTypeT>::SbeType, DefaultMaxGroupItems>::Size,
    typename MessageInitializer = FieldsInitPolicy>
class MessageHolder
{
    typedef typename HeldAdapter<MessageTypeT>::SbeType SbeType;
 
    static_assert(
        (MaxMessageSize >= sizeof(MessageHeader)),
        "MaxMessageSize template parameter is too small");
 
    static_assert(
        (MaxMessageSize >= GetMinMessageSize<SbeType>::Size),
        "The buffer can not fit the message");
 
    static_assert(
        (MaxMessageSize <= MaxILink3MessageSize),
        "The buffer is too large.");
 
public:
    typedef HeldAdapter<MessageTypeT> MessageType;

    enum
    {
        BufferSize = MaxMessageSize + sizeof(SimpleOpenFramingHeader)
    };
 
    explicit MessageHolder(SchemaVersion version = SbeType::Schema::Version)
    {
        init(version);
    }
 
    explicit MessageHolder(const Session& session)
    {
        init(getMessagingVersion(session));
    }
 
    MessageHolder(const MessageHolder& r)
    {
        copyFrom(r);
    }
 
    MessageHolder& operator=(const MessageHolder& r)
    {
        copyFrom(r);
        return *this;
    }

    const unsigned char* buffer() const noexcept
    {
        return buffer_;
    }

    UInt16 bufferSize() const noexcept
    {
        return header()->size();
    }

    MessageType& message() noexcept
    {
        return message_;
    }

    const MessageType& message() const noexcept
    {
        return message_;
    }

    UInt16 messageSize() const noexcept
    {
        return bufferSize() - sizeof(SimpleOpenFramingHeader);
    }
 
    MessageType* operator->() noexcept
    {
        return &message();
    }
 
    const MessageType* operator->() const noexcept
    {
        return &message();
    }
 
    const MessageType& operator* () const noexcept
    {
        return message();
    }
 
    MessageType& operator* () noexcept
    {
        return message();
    }

    const SimpleOpenFramingHeader* header() const noexcept
    {
        return reinterpret_cast<const SimpleOpenFramingHeader*>(buffer_);
    }

    SimpleOpenFramingHeader* header() noexcept
    {
        return reinterpret_cast<SimpleOpenFramingHeader*>(buffer_);
    }

    MessageSize setHeader() noexcept
    {
        const MessageSize calculatedMessageSize =
            message().calculateBinarySize();
 
        assert(calculatedMessageSize <= MaxMessageSize);
 
        assert(
            calculatedMessageSize >=
            SbeType::blockLength(message().version()) +
            MessageHeaderBuilder::Size +
            SbeType::getMinimalVariableFieldsSize(message().version()));
 
        messageSize(calculatedMessageSize);
        return calculatedMessageSize;
    }

    NetworkMessage toNetworkMessage() noexcept
    {
        setHeader();
 
#ifndef NDEBUG
        NetworkMessage(buffer_, BufferSize);
#endif
        return NetworkMessage(buffer_, BufferSize, SbeMessage::NoCheck());
    }

    ONIXS_ILINK3_NODISCARD
    std::string toString() const
    {
        return toStr(*this);
    }
 
private:
    void init(SchemaVersion version)
    {
#ifdef ONIXS_ILINK3_MEMCHECK_DEBUG
        std::memset(buffer_, magicDebugValue, BufferSize);
#endif
        messageSize(0);
 
        message_ = MessageInitializer::template createMessage<MessageType>(
            buffer_ + sizeof(SimpleOpenFramingHeader), MaxMessageSize, version);
    }
 
    void messageSize(UInt16 size) noexcept
    {
        header()->setup(
            size + sizeof(SimpleOpenFramingHeader));
    }
 
    void copyFrom(const MessageHolder& r)
    {
#ifdef ONIXS_ILINK3_MEMCHECK_DEBUG
        std::memset(buffer_, magicDebugValue, BufferSize);
#endif
 
        const size_t sizeToCopy = r.message_.MessageType::calculateBinarySize() + sizeof(SimpleOpenFramingHeader);
 
        assert(r.message_.calculateBinarySize() <= MaxMessageSize);
 
        std::memcpy(
            buffer_,
            r.buffer_,
            sizeToCopy);
 
        message_ =
            MessageType(
                buffer_ + sizeof(SimpleOpenFramingHeader),
                MaxMessageSize,
                SbeMessage::NoInit(),
                SbeMessage::NoCheck());
    }
 
private:
    MessageType message_;
    unsigned char buffer_[BufferSize];
};
 
template <
    template <typename, size_t, typename> class HolderType,
    typename MsgType,
    size_t MaxMessageSize,
    typename MessageInitializer>
inline std::string toStr(
    const HolderType<MsgType, MaxMessageSize, MessageInitializer>& holder)
{
    std::string res;
    toStr(res, holder);
    return res;
}
 
template <
    template <typename, size_t, typename> class HolderType,
    typename MsgType,
    size_t MaxMessageSize,
    typename MessageInitializer>
std::ostream& operator<<(
    std::ostream& stream,
    const HolderType<MsgType, MaxMessageSize, MessageInitializer>& rhs)
{
    return stream << toStr(rhs);
}
 
ONIXS_ILINK3_MESSAGING_NAMESPACE_END