PacketHolder.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 <array>
#include <cstddef>
#include <ostream>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/testing/ByteSpan.h>
#include <OnixS/CME/MDH/testing/MessageHolder.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

template <typename FirstMessageType = Messaging::AdminHeartbeat12, typename... RemainingMessageTypes>
class PacketHolder
{
    template <typename MessageType>
    struct Element
    {
        using Type = MessageHolder<MessageType>;
    };
 
    template <typename MessageType, std::size_t MaxMessageSize>
    struct Element<MessageHolder<MessageType, MaxMessageSize>>
    {
        using Type = MessageHolder<MessageType, MaxMessageSize>;
    };
 
    template <typename>
    static Messaging::SchemaVersion schemaVersion(Messaging::SchemaVersion version) noexcept
    {
        return version;
    }
 
    std::tuple<typename Element<FirstMessageType>::Type, typename Element<RemainingMessageTypes>::Type...> messages_;
 
public:
    enum : std::size_t { MessageCount = 1 + sizeof...(RemainingMessageTypes) };

    using MessageSpans = std::array<ByteSpan, MessageCount>;

    PacketHolder() = default;

    explicit PacketHolder(Messaging::SchemaVersion version)
        : messages_(schemaVersion<FirstMessageType>(version), schemaVersion<RemainingMessageTypes>(version)...)
    {
    }

    template <std::size_t Index>
    auto message() noexcept -> decltype(std::get<Index>(messages_))
    {
        return std::get<Index>(messages_);
    }

    template <std::size_t Index>
    auto message() const noexcept -> decltype(std::get<Index>(messages_))
    {
        return std::get<Index>(messages_);
    }

    template <std::size_t Index>
    auto get() noexcept -> decltype(std::get<Index>(messages_))
    {
        return message<Index>();
    }

    template <std::size_t Index>
    auto get() const noexcept -> decltype(std::get<Index>(messages_))
    {
        return message<Index>();
    }

    MessageSpans toNetworkMessageSpans() noexcept
    {
        MessageSpans result{};
        fillMessageSpans<0>(result);
        return result;
    }
 
private:
    PacketHolder(const PacketHolder&) = delete;
    PacketHolder& operator=(const PacketHolder&) = delete;
    PacketHolder(PacketHolder&&) = delete;
    PacketHolder& operator=(PacketHolder&&) = delete;
 
    template <std::size_t Index>
    typename std::enable_if<Index == MessageCount>::type fillMessageSpans(MessageSpans&) noexcept
    {
    }
 
    template <std::size_t Index>
    typename std::enable_if<(Index < MessageCount)>::type fillMessageSpans(MessageSpans& result) noexcept
    {
        result[Index] = std::get<Index>(messages_).toNetworkBytes();
        fillMessageSpans<Index + 1>(result);
    }
};

template <std::size_t Index, typename... MessageTypes>
inline auto get(PacketHolder<MessageTypes...>& holder) noexcept -> decltype(holder.template get<Index>())
{
    return holder.template get<Index>();
}

template <std::size_t Index, typename... MessageTypes>
inline auto get(const PacketHolder<MessageTypes...>& holder) noexcept -> decltype(holder.template get<Index>())
{
    return holder.template get<Index>();
}
 
namespace details {

template <std::size_t Index, typename... MessageTypes>
typename std::enable_if<Index == PacketHolder<MessageTypes...>::MessageCount>::type appendPacketHolderMessages(
    std::string&, const PacketHolder<MessageTypes...>&)
{
}

template <std::size_t Index, typename... MessageTypes>
typename std::enable_if<(Index < PacketHolder<MessageTypes...>::MessageCount)>::type appendPacketHolderMessages(
    std::string& str, const PacketHolder<MessageTypes...>& holder)
{
    if (Index != 0)
        str += ", ";
 
    toStr(str, holder.template message<Index>());
    appendPacketHolderMessages<Index + 1>(str, holder);
}
 
} // namespace details

template <typename... MessageTypes>
inline void toStr(std::string& str, const PacketHolder<MessageTypes...>& holder)
{
    str += "PacketHolder[Messages=[";
    details::appendPacketHolderMessages<0>(str, holder);
    str += "]]";
}

template <typename... MessageTypes>
inline ONIXS_CMEMDH_NODISCARD std::string toStr(const PacketHolder<MessageTypes...>& holder)
{
    std::string result;
    toStr(result, holder);
    return result;
}

template <typename... MessageTypes>
inline std::ostream& operator<<(std::ostream& stream, const PacketHolder<MessageTypes...>& holder)
{
    return stream << toStr(holder);
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END
 
namespace std {

template <typename... MessageTypes>
struct tuple_size<ONIXS_CME_MDH_TESTING_NAMESPACE::PacketHolder<MessageTypes...>>
    : integral_constant<size_t, ONIXS_CME_MDH_TESTING_NAMESPACE::PacketHolder<MessageTypes...>::MessageCount>
{
};

template <size_t Index, typename... MessageTypes>
struct tuple_element<Index, ONIXS_CME_MDH_TESTING_NAMESPACE::PacketHolder<MessageTypes...>>
{
    using type = typename remove_reference<decltype(
        declval<ONIXS_CME_MDH_TESTING_NAMESPACE::PacketHolder<MessageTypes...>&>().template get<Index>())>::type;
};
 
} // namespace std