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 <cassert>
#include <cstddef>
#include <cstring>
#include <new>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/ABI.h>
#include <OnixS/CME/MDH/messaging/MaxMessageSize.h>
#include <OnixS/CME/MDH/messaging/SbeMessage.h>
#include <OnixS/CME/MDH/messaging/TagBased/Message.h>
#include <OnixS/CME/MDH/PacketTraits.h>
#include <OnixS/CME/MDH/testing/ByteSpan.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN
 
namespace details {

template <typename MessageType, bool isFix = std::is_base_of<Messaging::FIX::Message, MessageType>::value> struct HeldAdapter;
 
template <typename MessageType>
struct HeldAdapter<MessageType, true> final : public MessageType
{
    static_assert(std::is_base_of<Messaging::FIX::Message, MessageType>::value, "Not a message.");
 
    static constexpr bool isFix = true;
 
    using SbeType = typename MessageType::Binary;
 
    using EncodedLength = typename SbeType::EncodedLength;
 
    HeldAdapter() = default;
 
    HeldAdapter(void* data, EncodedLength length, Messaging::SchemaVersion version)
        : MessageType(SbeType(data, length, version))
    {
    }
 
    HeldAdapter(void* data, EncodedLength length, Messaging::SbeMessage::NoInit, Messaging::SbeMessage::NoCheck) noexcept
        : MessageType(SbeType(data, length, Messaging::SbeMessage::NoInit(), Messaging::SbeMessage::NoCheck()))
    {
    }
};
 
template <typename MessageType>
struct HeldAdapter<MessageType, false> final : public MessageType
{
    static_assert(std::is_base_of<Messaging::SbeMessage, MessageType>::value, "Not a message.");
 
    static constexpr bool isFix = false;
 
    using SbeType = MessageType;
 
    using EncodedLength = typename SbeType::EncodedLength;
 
    HeldAdapter() = default;
 
    HeldAdapter(void* data, EncodedLength length, Messaging::SchemaVersion version)
        : MessageType(data, length, version)
    {
    }
 
    HeldAdapter(void* data, EncodedLength length, Messaging::SbeMessage::NoInit, Messaging::SbeMessage::NoCheck) noexcept
        : MessageType(data, length, Messaging::SbeMessage::NoInit{}, Messaging::SbeMessage::NoCheck{})
    {
    }
};
 
} // namespace details
 
template <typename, size_t> class MessageHolder;

template <typename MessageType, size_t MaxMessageSize>
inline void toStr(std::string& str, const MessageHolder<MessageType, MaxMessageSize>& holder)
{
    using Messaging::FIX::toStr;
    using Messaging::toStr;
 
    str += "MessageHolder[";
 
    str += "BufferSize=";
    Messaging::toStr(str, holder.BufferSize);
 
    str += ", ";
    toStr(str, holder.header());
 
    str += ", ";
    toStr(str, holder.message());
 
    str += "]";
}

template
<
    typename MessageTypeT,
    size_t MaxMessageSize = Messaging::MaxMessageSize
>
class MessageHolder
{
    using SbeType = typename details::HeldAdapter<MessageTypeT>::SbeType;
 
public:
    using MessageHolderBase = MessageHolder<MessageTypeT, MaxMessageSize>;

    using MessageType = details::HeldAdapter<MessageTypeT>;

    enum : Messaging::MessageSize { BufferSize = MaxMessageSize + sizeof(MessagePrefix) };

    explicit MessageHolder(Messaging::SchemaVersion version = SbeType::Schema::Version)
    {
        Messaging::fromEmptyStorage<MessagePrefix>(buffer_);
 
        messageSize(0);
 
        message_ = MessageType(buffer_ + sizeof(MessagePrefix), MaxMessageSize, version);
    }

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

    ONIXS_CMEMDH_NODISCARD
    Messaging::MessageSize bufferSize() const noexcept
    {
        return header().messageSize();
    }

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

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

    template <typename Callable>
    auto operator%(Callable&& callable) & -> decltype(
        std::forward<Callable>(callable)(std::declval<MessageType&>()), std::declval<MessageHolder&>())
    {
        std::forward<Callable>(callable)(message());
        return *this;
    }

    ONIXS_CMEMDH_NODISCARD
    Messaging::MessageSize messageSize() const noexcept
    {
        return bufferSize() - sizeof(MessagePrefix);
    }

    MessageType* operator->() noexcept
    {
        return &message();
    }

    const MessageType* operator->() const noexcept
    {
        return &message();
    }

    ONIXS_CMEMDH_NODISCARD
    const MessageType& operator* () const noexcept
    {
        return message();
    }

    ONIXS_CMEMDH_NODISCARD
    MessageType& operator* () noexcept
    {
        return message();
    }

    ONIXS_CMEMDH_NODISCARD
    const MessagePrefix& header() const noexcept
    {
        return *reinterpret_cast<const MessagePrefix*>(buffer_);
    }

    Messaging::MessageSize setHeader() noexcept
    {
        const auto calculatedMessageSize = message().calculateBinarySize();
 
        assert(calculatedMessageSize <= MaxMessageSize);
 
        messageSize(calculatedMessageSize);
        return calculatedMessageSize;
    }

    ONIXS_CMEMDH_NODISCARD
    ByteSpan toNetworkBytes() noexcept
    {
        setHeader();
        return asSpan();
    }

    ONIXS_CMEMDH_NODISCARD
    ByteSpan asSpan() const noexcept
    {
        return ByteSpan(buffer(), bufferSize());
    }

    ONIXS_CMEMDH_NODISCARD
    std::string toString() const
    {
        return toStr(*this);
    }
 
private:
    MessageHolder(const MessageHolder&) = delete;
    MessageHolder& operator=(const MessageHolder&) = delete;
    MessageHolder(MessageHolder&&) = delete;
    MessageHolder& operator=(MessageHolder&&) = delete;
 
    static_assert(std::is_nothrow_default_constructible<MessageType>::value, "MessageType must be nothrow default constructible.");
    static_assert(std::is_nothrow_move_assignable<MessageType>::value, "MessageType must be nothrow move assignable.");
    static_assert(MaxMessageSize >= sizeof(Messaging::MessageHeader), "MaxMessageSize template parameter is too small");
    static_assert(MaxMessageSize >= Messaging::GetMinMessageSize<SbeType>::Size, "The buffer can not fit the message");
    static_assert(MaxMessageSize <= Messaging::MaxMessageSize, "The buffer is too large.");
    static_assert(Messaging::IsTriviallyCopyable<MessagePrefix>::value, "MessagePrefix must be trivially copiable.");
    static_assert(std::is_nothrow_default_constructible<MessagePrefix>::value, "MessagePrefix must be nothrow default constructible.");
    static_assert(std::is_trivially_destructible<MessagePrefix>::value, "MessagePrefix must be trivially destructible.");
 
    MessagePrefix& mutableHeader() noexcept
    {
        return *reinterpret_cast<MessagePrefix*>(buffer_);
    }
 
    void messageSize(Messaging::MessageSize size) noexcept
    {
        mutableHeader().messageSize(size + sizeof(MessagePrefix));
    }
 
    MessageType message_;
    alignas(MessagePrefix) Messaging::Byte buffer_[BufferSize] = {};
};

template <typename MessageType, size_t MaxMessageSize>
inline ONIXS_CMEMDH_NODISCARD std::string toStr(const MessageHolder<MessageType, MaxMessageSize>& holder)
{
    std::string res;
    toStr(res, holder);
    return res;
}

template <typename MessageType, size_t MaxMessageSize>
std::ostream& operator<<(std::ostream& stream, const MessageHolder<MessageType, MaxMessageSize>& rhs)
{
    return stream << toStr(rhs);
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END