MsgDataLayer.h

Go to the documentation of this file.

//
// Copyright 2014 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <tuple>
#include <iterator>
#include <type_traits>
#include "comms/Assert.h"
#include "comms/Field.h"
#include "comms/Message.h"
#include "comms/MessageBase.h"
#include "comms/details/detect.h"
#include "comms/details/tag.h"
#include "comms/field/IntValue.h"
#include "comms/protocol/details/MsgDataLayerOptionsParser.h"
#include "comms/util/Tuple.h"
#include "comms/util/type_traits.h"
#include "ProtocolLayerBase.h"
 
namespace comms
{
 
namespace protocol
{
 
template <typename... TOptions>
class MsgDataLayer
{
    using ParsedOptionsInternal =  details::MsgDataLayerOptionsParser<TOptions...>;
 
public:
    using ThisLayer = MsgDataLayer<TOptions...>;
 
    ThisLayer& thisLayer()
    {
        return *this;
    }
 
    const ThisLayer& thisLayer() const
    {
        return *this;
    }
 
    using Field = typename ParsedOptionsInternal::FieldType;
 
    using AllFields = std::tuple<Field>;
 
    using AllMessages = void;
 
    using MsgFactory = void;
 
    static const std::size_t NumOfLayers = 1;
 
    MsgDataLayer() = default;
 
    MsgDataLayer(const MsgDataLayer&) = default;
 
    MsgDataLayer(MsgDataLayer&&) = default;
 
    ~MsgDataLayer() noexcept = default;
 
    MsgDataLayer& operator=(const MsgDataLayer&) = default;
 
    MsgDataLayer& operator=(MsgDataLayer&&) = default;
 
    static constexpr bool canSplitRead()
    {
        return true;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus read(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        using Tag =
            typename comms::util::Conditional<
                comms::isMessageBase<MsgType>()
            >::template Type<
                DirectOpTag<>,
                typename comms::util::Conditional<
                    comms::isMessage<MsgType>()
                >::template Type<
                    InterfaceOpTag<>,
                    typename comms::util::LazyShallowConditional<
                        std::is_pointer<MsgType>::value
                    >::template Type<
                        PointerOpTag,
                        OtherOpTag
                    >
                >
            >;
 
        if (setPayloadRequiredInternal(extraValues...)) {
            auto fromIter = iter;
            auto es = readInternal(msg, iter, size, Tag(), extraValues...);
            setMsgPayloadInternal(fromIter, static_cast<std::size_t>(std::distance(fromIter, iter)), extraValues...);
            return es;
        }
 
        return readInternal(msg, iter, size, Tag(), extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readUntilData(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues...)
    {
        static_cast<void>(msg);
        static_cast<void>(iter);
        static_cast<void>(size);
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readFromData(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        return read(msg, iter, size, extraValues...);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readFieldsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
 
        static_assert(comms::util::IsTuple<TAllFields>::Value,
                                        "Expected TAllFields to be tuple.");
 
        using AllFieldsDecayed = typename std::decay<TAllFields>::type;
        static_assert(util::tupleIsTailOf<AllFields, AllFieldsDecayed>(), "Passed tuple is wrong.");
        static const std::size_t Idx =
            std::tuple_size<AllFieldsDecayed>::value -
                                std::tuple_size<AllFields>::value;
 
        static_assert((Idx + 1) == std::tuple_size<TAllFields>::value,
                    "All fields must be read when MsgDataLayer is reached");
 
        using IterType = typename std::decay<decltype(iter)>::type;
        using IterTag = typename std::iterator_traits<IterType>::iterator_category;
        static_assert(std::is_base_of<std::random_access_iterator_tag, IterTag>::value,
                "Caching read from non random access iterators are not supported at this moment.");
 
        auto& dataField = std::get<Idx>(allFields);
 
        using FieldType = typename std::decay<decltype(dataField)>::type;
        static_assert(
            std::is_same<Field, FieldType>::value,
            "Field has wrong type");
 
        auto dataIter = iter;
        auto es = read(msg, iter, size, extraValues...);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        auto dataSize = static_cast<std::size_t>(std::distance(dataIter, iter));
        setMsgPayloadInternal(dataIter, dataSize, extraValues...);
 
        auto dataEs = dataField.read(dataIter, dataSize);
        static_cast<void>(dataEs);
        COMMS_ASSERT(dataEs == comms::ErrorStatus::Success);
        return es;
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readUntilDataFieldsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues...)
    {
        static_cast<void>(allFields);
        static_cast<void>(msg);
        static_cast<void>(iter);
        static_cast<void>(size);
        return comms::ErrorStatus::Success;
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readFromDataFeildsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        return readFieldsCached(allFields, msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter>
    static ErrorStatus write(
        const TMsg& msg,
        TIter& iter,
        std::size_t size)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
 
        static_assert(
            comms::isMessage<MsgType>(),
            "The provided message object must inherit from comms::Message");
 
        using Tag =
            typename comms::util::Conditional<
                comms::isMessageBase<MsgType>()
            >::template Type<
                DirectOpTag<>,
                typename comms::util::Conditional<
                    comms::isMessage<MsgType>()
                >::template Type<
                    InterfaceOpTag<>,
                    typename comms::util::LazyShallowConditional<
                        std::is_pointer<MsgType>::value
                    >::template Type<
                        PointerOpTag,
                        OtherOpTag
                    >
                >
            >;
 
        return writeInternal(msg, iter, size, Tag());
    }
 
    template <typename TAllFields, typename TMsg, typename TIter>
    static ErrorStatus writeFieldsCached(
        TAllFields& allFields,
        const TMsg& msg,
        TIter& iter,
        std::size_t size)
    {
        static_assert(comms::util::IsTuple<TAllFields>::Value,
                                        "Expected TAllFields to be tuple.");
 
        using AllFieldsDecayed = typename std::decay<TAllFields>::type;
        static_assert(util::tupleIsTailOf<AllFields, AllFieldsDecayed>(), "Passed tuple is wrong.");
        static const std::size_t Idx =
            std::tuple_size<AllFieldsDecayed>::value -
                                std::tuple_size<AllFields>::value;
 
        static_assert((Idx + 1) == std::tuple_size<TAllFields>::value,
                    "All fields must be written when MsgDataLayer is reached");
 
        auto& dataField = std::get<Idx>(allFields);
        using FieldType = typename std::decay<decltype(dataField)>::type;
        static_assert(
            std::is_same<Field, FieldType>::value,
            "Field has wrong type");
 
        using IterType = typename std::decay<decltype(iter)>::type;
        using IterTag = typename std::iterator_traits<IterType>::iterator_category;
        return writeWithFieldCachedInternal(dataField, msg, iter, size, IterTag());
    }
 
    template <typename TIter>
    static comms::ErrorStatus update(TIter& iter, std::size_t size)
    {
        std::advance(iter, size);
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename TIter>
    static comms::ErrorStatus update(const TMsg& msg, TIter& iter, std::size_t size)
    {
        static_cast<void>(msg);
        return update(iter, size);
    }
 
    template <typename TAllFields, typename TIter>
    static ErrorStatus updateFieldsCached(
        TAllFields& allFields,
        TIter& iter,
        std::size_t size)
    {
        static_cast<void>(allFields);
        std::advance(iter, size);
        return comms::ErrorStatus::Success;
    }
 
    template <typename TAllFields, typename TMsg, typename TIter>
    static ErrorStatus updateFieldsCached(
        TAllFields& allFields,
        const TMsg& msg,
        TIter& iter,
        std::size_t size)
    {
        static_cast<void>(allFields);
        static_cast<void>(msg);
        std::advance(iter, size);
        return comms::ErrorStatus::Success;
    }
 
    static constexpr std::size_t length()
    {
        return 0U;
    }
 
    template <typename TMsg>
    static constexpr std::size_t length(const TMsg& msg)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
 
        static_assert(
            comms::isMessage<MsgType>(),
            "The provided message object must inherit from comms::Message");
 
        using Tag = 
            typename comms::util::LazyShallowConditional<
                details::ProtocolLayerHasFieldsImpl<MsgType>::Value
            >::template Type<
                MsgDirectLengthTag,
                MsgHasLengthTag
            >;
        return getMsgLength(msg, Tag());
    }
 
    template <typename TAllFields>
    static auto accessCachedField(TAllFields& allFields) ->
        decltype(std::get<std::tuple_size<typename std::decay<TAllFields>::type>::value - std::tuple_size<AllFields>::value>(allFields))
    {
        using AllFieldsDecayed = typename std::decay<TAllFields>::type;
        static_assert(util::tupleIsTailOf<AllFields, AllFieldsDecayed>(), "Passed tuple is wrong.");
        static const std::size_t Idx =
            std::tuple_size<AllFieldsDecayed>::value -
                                std::tuple_size<AllFields>::value;
 
        return std::get<Idx>(allFields);
    }
 
private:
    template <typename... TParams>
    using MsgHasLengthTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using MsgNoLengthTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using MsgDirectLengthTag = comms::details::tag::Tag3<>;    
 
    template <typename... TParams>
    using DirectOpTag = comms::details::tag::Tag4<>;     
 
    template <typename... TParams>
    using InterfaceOpTag = comms::details::tag::Tag5<>;    
 
    template <typename... TParams>
    using PointerOpTag = comms::details::tag::Tag6<>; 
 
    template <typename... TParams>
    using OtherOpTag = comms::details::tag::Tag7<>;              
 
    template <typename TMsg, typename TIter>
    static ErrorStatus writeWithFieldCachedInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        std::random_access_iterator_tag)
    {
        return writeWithFieldCachedRandomAccess(field, msg, iter, size);
    }
 
    template <typename TMsg, typename TIter>
    static ErrorStatus writeWithFieldCachedInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        std::output_iterator_tag)
    {
        return writeWithFieldCachedOutput(field, msg, iter, size);
    }
 
    template <typename TMsg, typename TIter>
    static ErrorStatus writeWithFieldCachedRandomAccess(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size)
    {
        auto dataReadIter = iter;
        auto es = write(msg, iter, size);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        auto writtenCount = static_cast<std::size_t>(std::distance(dataReadIter, iter));
        auto dataEs = field.read(dataReadIter, writtenCount);
        COMMS_ASSERT(dataEs == comms::ErrorStatus::Success);
        static_cast<void>(dataEs);
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename TCollection>
    static ErrorStatus writeWithFieldCachedOutput(
        Field& field,
        const TMsg& msg,
        std::back_insert_iterator<TCollection>& iter,
        std::size_t size)
    {
        auto es = write(msg, iter, size);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        TCollection col;
        auto dataWriteIter = std::back_inserter(col);
        auto dataWriteEs = write(msg, dataWriteIter, size);
        COMMS_ASSERT(dataWriteEs == comms::ErrorStatus::Success);
        static_cast<void>(dataWriteEs);
 
        auto dataReadIter = col.cbegin();
        auto dataReadEs = field.read(dataReadIter, col.size());
        COMMS_ASSERT(dataReadEs == comms::ErrorStatus::Success);
        static_cast<void>(dataReadEs);
 
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename... TParams>
    static std::size_t getMsgLength(const TMsg& msg, MsgHasLengthTag<TParams...>)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(MsgType::hasLength(), "Message interface must define length()");
        return msg.length();
    }
 
    template <typename TMsg, typename... TParams>
    static constexpr std::size_t getMsgLength(const TMsg& msg, MsgDirectLengthTag<TParams...>)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(MsgType::hasFields(), "FieldsImpl option hasn't been used");
        return msg.doLength();
    }
 
    template <typename TMsg, typename... TParams>
    static constexpr std::size_t getMsgLength(const TMsg&, MsgNoLengthTag<TParams...>)
    {
        return 0U;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternalPolymorphic(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
 
        static_assert(
            comms::isMessage<MsgType>(),
            "The provided message object must inherit from comms::Message");
 
        static_assert(MsgType::hasRead(),
            "Message interface must support polymorphic read operation");
 
        using IterType = typename std::decay<decltype(iter)>::type;
 
        static_assert(std::is_convertible<IterType, typename MsgType::ReadIterator>::value,
            "The provided iterator is not convertible to ReadIterator defined by Message class");
 
        using ReadIter = typename std::add_lvalue_reference<typename MsgType::ReadIterator>::type;
 
        auto result = msg.read(static_cast<ReadIter>(iter), size);
        if ((result == ErrorStatus::NotEnoughData) &&
            missingSizeRequiredInternal(extraValues...)) {
            using Tag = 
                typename comms::util::LazyShallowConditional<
                    MsgType::hasLength()
                >::template Type<
                    MsgHasLengthTag,
                    MsgNoLengthTag
                >;
 
            std::size_t missingSize = 1U;
            auto msgLen = getMsgLength(msg, Tag());
            if (size < msgLen) {
                missingSize = msgLen - size;
            }
            updateMissingSizeInternal(missingSize, extraValues...);
        }
        return result;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternalDirect(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
 
        static_assert(
            comms::isMessageBase<MsgType>(),
            "The provided message object must inherit from comms::MessageBase");
 
        static_assert(details::protocolLayerHasFieldsImpl<MsgType>(),
            "Message class must use FieldsImpl option");
 
        auto result = msg.doRead(iter, size);
        if ((result == ErrorStatus::NotEnoughData) &&
            (missingSizeRequiredInternal(extraValues...))) {
            std::size_t missingSize = 1U;
            auto msgLen = getMsgLength(msg, MsgDirectLengthTag<>());
            if (size < msgLen) {
                missingSize = msgLen - size;
            }
            updateMissingSizeInternal(missingSize, extraValues...);
        }
        return result;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternal(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        DirectOpTag<>,
        TExtraValues... extraValues)
    {
        return readInternalDirect(msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternal(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        InterfaceOpTag<>,
        TExtraValues... extraValues)
    {
        static_assert(comms::isMessage<TMsg>(), "Must be interface class");
        static_assert(TMsg::hasRead(),
            "Message interface must support polymorphic read operation");
 
        return readInternalPolymorphic(msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternal(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        PointerOpTag<>,
        TExtraValues... extraValues)
    {
        return read(*msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    static ErrorStatus readInternal(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        OtherOpTag<>,
        TExtraValues... extraValues)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(comms::details::hasElementType<MsgType>(),
            "Unsupported type of message object, expected to be either message itself, raw pointer or smart pointer");
        return read(*msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    static ErrorStatus writeInternal(
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        DirectOpTag<TParams...>)
    {
        return msg.doWrite(iter, size);
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    static ErrorStatus writeInternal(
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        InterfaceOpTag<TParams...>)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
 
        static_assert(MsgType::hasWrite(),
            "Message interface must support polymorphic write operation");
 
        using IterType = typename std::decay<decltype(iter)>::type;
 
        static_assert(std::is_convertible<IterType, typename MsgType::WriteIterator>::value,
            "The provided iterator is not convertible to WriteIterator defined by Message class");
 
        using WriteIter = typename std::add_lvalue_reference<typename MsgType::WriteIterator>::type;
 
        return msg.write(static_cast<WriteIter>(iter), size);
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    static ErrorStatus writeInternal(
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        PointerOpTag<TParams...>)
    {
        return write(*msg, iter, size);
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    static ErrorStatus writeInternal(
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        OtherOpTag<TParams...>)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(comms::details::hasElementType<MsgType>(),
            "Unsupported type of message object, expected to be either message itself, raw pointer or smart pointer");
 
        return write(*msg, iter, size);
    }
 
    static constexpr bool missingSizeRequiredInternal()
    {
        return false;
    }
 
    template <typename... TExtraValues>
    static bool missingSizeRequiredInternal(details::MissingSizeRetriever<>, TExtraValues...)
    {
        return true;
    }
 
    template <typename T, typename... TExtraValues>
    static bool missingSizeRequiredInternal(T, TExtraValues... extraValues)
    {
        static_assert(
            !details::isMissingSizeRetriever<T>(),
            "Mustn't be missing size retriever");
        return missingSizeRequiredInternal(extraValues...);
    }
 
    static void updateMissingSizeInternal(std::size_t val)
    {
        static_cast<void>(val);
    }
 
    template <typename... TExtraValues>
    static void updateMissingSizeInternal(
        std::size_t val,
        details::MissingSizeRetriever<> retriever,
        TExtraValues... extraValues)
    {
        retriever.setValue(val);
        updateMissingSizeInternal(val, extraValues...);
    }
 
    template <typename T, typename... TExtraValues>
    static void updateMissingSizeInternal(std::size_t val, T retriever, TExtraValues... extraValues)
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMissingSizeRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be missing size retriever");
        updateMissingSizeInternal(val, extraValues...);
    }
 
    static constexpr bool setPayloadRequiredInternal()
    {
        return false;
    }
 
    template <typename TIter, typename... TExtraValues>
    static bool setPayloadRequiredInternal(details::MsgPayloadRetriever<TIter>, TExtraValues...)
    {
        return true;
    }
 
    template <typename T, typename... TExtraValues>
    static bool setPayloadRequiredInternal(T, TExtraValues... extraValues)
    {
        static_assert(
            !details::isMsgPayloadRetriever<T>(),
            "Mustn't be message payload retriever");
        return setPayloadRequiredInternal(extraValues...);
    }
 
    template <typename TIter>
    static void setMsgPayloadInternal(TIter iter, std::size_t len)
    {
        static_cast<void>(iter);
        static_cast<void>(len);
    }
 
    template <typename TIter, typename TOtherIter, typename... TExtraValues>
    static void setMsgPayloadInternal(
        TIter iter,
        std::size_t len,
        details::MsgPayloadRetriever<TOtherIter> retriever,
        TExtraValues... extraValues)
    {
        retriever.setValue(iter, len);
        setMsgPayloadInternal(iter, len, extraValues...);
    }
 
    template <typename TIter, typename T, typename... TExtraValues>
    static void setMsgPayloadInternal(
        TIter iter,
        std::size_t len,
        T retriever,
        TExtraValues... extraValues)
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMsgPayloadRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be message payload retriever");
        setMsgPayloadInternal(iter, len, extraValues...);
    }
};
 
namespace details
{
template <typename T>
struct MsgDataLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename... TExtraOpts>
struct MsgDataLayerCheckHelper<MsgDataLayer<TExtraOpts...> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isMsgDataLayer()
{
    return details::MsgDataLayerCheckHelper<T>::Value;
}
 
template <typename... TExtraOpts>
constexpr
MsgDataLayer<TExtraOpts...>&
toProtocolLayerBase(MsgDataLayer<TExtraOpts...>& layer)
{
    return layer;
}
 
template <typename... TExtraOpts>
constexpr
const MsgDataLayer<TExtraOpts...>&
toProtocolLayerBase(const MsgDataLayer<TExtraOpts...>& layer)
{
    return layer;
}
 
}  // namespace protocol
 
}  // namespace comms