ProtocolLayerBase.h

Go to the documentation of this file.

//
// Copyright 2014 - 2024 (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 <utility>
#include <algorithm>
#include <iterator>
 
#include "comms/CompileControl.h"
#include "comms/ErrorStatus.h"
#include "comms/util/Tuple.h"
#include "comms/util/type_traits.h"
#include "comms/Assert.h"
#include "comms/options.h"
 
#include "comms/protocol/details/ProtocolLayerBaseOptionsParser.h"
#include "comms/protocol/details/ProtocolLayerDetails.h"
#include "comms/details/protocol_layers_access.h"
#include "comms/details/detect.h"
#include "comms/details/tag.h"
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4100) // Disable warning about unreferenced parameters
 
namespace comms
{
 
namespace protocol
{
 
template <
    typename TField,
    typename TNextLayer,
    typename TDerived,
    typename...  TOptions>
class ProtocolLayerBase
{
public:
    using Field = TField;
 
    using NextLayer = TNextLayer;
 
    using ParsedOptions = details::ProtocolLayerBaseOptionsParser<TOptions...>;
 
    using AllFields = typename std::decay<
        decltype(
            std::tuple_cat(
                std::declval<std::tuple<Field> >(),
                std::declval<typename TNextLayer::AllFields>())
            )
        >::type;
 
    using AllMessages = typename NextLayer::AllMessages;
 
    using MsgFactory = typename NextLayer::MsgFactory;    
 
    using MsgPtr = typename details::ProtocolLayerMsgPtr<NextLayer>::Type;
 
    using ThisLayer = TDerived;
 
    static const std::size_t NumOfLayers = 1 + NextLayer::NumOfLayers;
 
    ProtocolLayerBase(const ProtocolLayerBase&) = default;
 
    ProtocolLayerBase(ProtocolLayerBase&&) = default;
 
    template <typename... TArgs>
    explicit ProtocolLayerBase(TArgs&&... args)
      : nextLayer_(std::forward<TArgs>(args)...)
    {
    }
 
    ~ProtocolLayerBase() noexcept = default;
 
    ProtocolLayerBase& operator=(const ProtocolLayerBase&) = default;
 
    NextLayer& nextLayer()
    {
        return nextLayer_;
    }
 
    const NextLayer& nextLayer() const
    {
        return nextLayer_;
    }
 
    ThisLayer& thisLayer()
    {
        return static_cast<ThisLayer&>(*this);
    }
 
    const ThisLayer& thisLayer() const
    {
        return static_cast<const ThisLayer&>(*this);
    }
 
    static constexpr bool canSplitRead()
    {
        return (!ParsedOptions::HasDisallowReadUntilDataSplit) && NextLayer::canSplitRead();
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus read(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        using Tag =
            typename comms::util::LazyShallowConditional<
                ParsedOptions::HasForceReadUntilDataSplit
            >::template Type<
                SplitReadTag,
                NormalReadTag
            >;
 
        static_assert(std::is_same<Tag, NormalReadTag<> >::value || canSplitRead(),
            "Read split is disallowed by at least one of the inner layers");
        return readInternal(msg, iter, size, Tag(), extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readUntilData(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
 
        Field field;
        auto& derivedObj = static_cast<TDerived&>(*this);
        auto reader = createNextLayerUntilDataReader();
        return
            derivedObj.doRead(
                field,
                msg,
                iter,
                size,
                reader,
                extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readFromData(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        return nextLayer().readFromData(msg, iter, size, extraValues...);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readFieldsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        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;
        auto& field = getField<Idx>(allFields);
        auto& derivedObj = static_cast<TDerived&>(*this);
        auto reader = createNextLayerCachedFieldsReader(allFields);
        return
            derivedObj.doRead(
                field,
                msg,
                iter,
                size,
                reader,
                extraValues...);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readUntilDataFieldsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        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;
 
        auto& field = getField<Idx>(allFields);
        auto& derivedObj = static_cast<TDerived&>(*this);
        auto reader = createNextLayerCachedFieldsUntilDataReader(allFields);
        return
            derivedObj.doRead(
                field,
                msg,
                iter,
                size,
                reader,
                extraValues...);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readFromDataFieldsCached(
        TAllFields& allFields,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TExtraValues... extraValues)
    {
        return nextLayer().readFromDataFieldsCached(allFields, msg, iter, size, extraValues...);
    }
 
    template <typename TMsg, typename TIter>
    comms::ErrorStatus write(
        const TMsg& msg,
        TIter& iter,
        std::size_t size) const
    {
        Field field;
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto writer = createNextLayerWriter();
        return derivedObj.doWrite(field, msg, iter, size, writer);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter>
    comms::ErrorStatus writeFieldsCached(
        TAllFields& allFields,
        const TMsg& msg,
        TIter& iter,
        std::size_t size) const
    {
        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;
 
        auto& field = getField<Idx>(allFields);
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto writer = createNextLayerCachedFieldsWriter(allFields);
        return derivedObj.doWrite(field, msg, iter, size, writer);
    }
 
    constexpr std::size_t length() const
    {
        return thisLayer().doFieldLength() + nextLayer_.length();
    }
 
    template <typename TMsg>
    constexpr std::size_t length(const TMsg& msg) const
    {
        return thisLayer().doFieldLength(msg) + nextLayer_.length(msg);
    }
 
    template <typename TIter>
    comms::ErrorStatus update(TIter& iter, std::size_t size) const
    {
        Field field;
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto updater = createNextLayerUpdater();
        return derivedObj.doUpdate(field, iter, size, updater);
    }
 
    template <typename TMsg, typename TIter>
    comms::ErrorStatus update(const TMsg& msg, TIter& iter, std::size_t size) const
    {
        Field field;
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto updater = createNextLayerUpdater();
        return derivedObj.doUpdate(msg, field, iter, size, updater);
    }
 
    template <typename TAllFields, typename TIter>
    ErrorStatus updateFieldsCached(
        TAllFields& allFields,
        TIter& iter,
        std::size_t size) const
    {
        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;
 
        auto& field = getField<Idx>(allFields);
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto updater = createNextLayerCachedFieldsUpdater(allFields);
        return derivedObj.doUpdate(field, iter, size, updater);
    }
 
    template <typename TAllFields, typename TMsg, typename TIter>
    ErrorStatus updateFieldsCached(
        TAllFields& allFields,
        const TMsg& msg,
        TIter& iter,
        std::size_t size) const
    {
        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;
 
        auto& field = getField<Idx>(allFields);
        auto& derivedObj = static_cast<const TDerived&>(*this);
        auto updater = createNextLayerCachedFieldsUpdater(allFields);
        return derivedObj.doUpdate(msg, field, iter, size, updater);
    }
 
    template <typename TIter, typename TNextLayerUpdater>
    comms::ErrorStatus doUpdate(
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater) const
    {
        return updateInternal(field, iter, size, std::forward<TNextLayerUpdater>(nextLayerUpdater), LengthTag<>());
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater>
    comms::ErrorStatus doUpdate(
        const TMsg& msg,
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater) const
    {
        return updateInternal(msg, field, iter, size, std::forward<TNextLayerUpdater>(nextLayerUpdater), LengthTag<>());
    }
 
    static constexpr std::size_t doFieldLength()
    {
        return Field::minLength();
    }
 
    template <typename TMsg>
    static constexpr std::size_t doFieldLength(const TMsg&)
    {
        return doFieldLength();
    }
 
    template <typename TId>
    MsgPtr createMsg(TId&& id, unsigned idx = 0)
    {
        return nextLayer().createMsg(std::forward<TId>(id), idx);
    }
 
    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);
    }
 
protected:
    template <typename TMsg, typename TIter>
    static comms::ErrorStatus doReadField(const TMsg* msgPtr, Field& field, TIter& iter, std::size_t len)
    {
        static_cast<void>(msgPtr);
        return field.read(iter, len);
    }
 
    template <typename TMsg, typename TIter>
    static comms::ErrorStatus doWriteField(const TMsg* msgPtr, const Field& field, TIter& iter, std::size_t len)
    {
        static_cast<void>(msgPtr);
        return field.write(iter, len);
    }
 
    template <typename T>
    static constexpr bool isMessageObjRef()
    {
        return comms::details::hasImplOptions<T>();
    }
 
    template <typename TMsg>
    static void resetMsg(TMsg& msg)
    {
        resetMsgInternal(msg, MsgTypeTag<typename std::decay<decltype(msg)>::type>());
    }
 
private:
    template <typename... TParams>
    using MessageObjTag = comms::details::tag::Tag5<>;  
 
    template <typename... TParams>
    using SmartPtrTag = comms::details::tag::Tag6<>;     
 
    template <typename TMsg>
    using MsgTypeTag =
        typename comms::util::LazyShallowConditional<
            comms::details::hasImplOptions<TMsg>()
        >::template Type<
            MessageObjTag,
            SmartPtrTag
        >;  
 
    template <typename TMsg, typename... TParams>
    static auto toMsgPtrInternal(TMsg& msg, MessageObjTag<TParams...>) -> decltype(&msg)
    {
        return &msg;
    }
 
    template <typename TMsg, typename... TParams>
    static auto toMsgPtrInternal(TMsg& msg, SmartPtrTag<TParams...>) -> decltype(msg.get())
    {
        return msg.get();
    }      
 
protected:
    template <typename TMsg>
    static auto toMsgPtr(TMsg& msg) -> decltype(toMsgPtrInternal(msg, MsgTypeTag<typename std::decay<decltype(msg)>::type>()))
    {
        return toMsgPtrInternal(msg, MsgTypeTag<typename std::decay<decltype(msg)>::type>());
    }    
 
    template <typename... TExtraValues>
    void updateMissingSize(std::size_t size, TExtraValues... extraValues) const
    {
        return updateMissingSizeInternal(size, extraValues...);
    }
 
    template <typename... TExtraValues>
    void updateMissingSize(
        const Field& field,
        std::size_t size,
        TExtraValues... extraValues) const
    {
        return updateMissingSizeInternal(field, size, extraValues...);
    }
 
    template <typename... TExtraValues>
    void setMissingSize(
        std::size_t val,
        TExtraValues... extraValues) const
    {
        return setMissingSizeInternal(val, extraValues...);
    }
 
    template <typename TId, typename... TExtraValues>
    void setMsgId(
        TId val,
        TExtraValues... extraValues) const
    {
        return setMsgIdInternal(val, extraValues...);
    }
 
    template <typename... TExtraValues>
    void setMsgIndex(
        std::size_t val,
        TExtraValues... extraValues) const
    {
        return setMsgIndexInternal(val, extraValues...);
    }
 
    template <std::size_t TIdx, typename TAllFields>
    static Field& getField(TAllFields& allFields)
    {
        static_assert(comms::util::IsTuple<TAllFields>::Value,
                                        "Expected TAllFields to be a tuple");
        static_assert(TIdx < std::tuple_size<TAllFields>::value,
                                        "Invalid tuple access index");
 
        auto& field = std::get<TIdx>(allFields);
 
        using FieldType = typename std::decay<decltype(field)>::type;
        static_assert(
            std::is_same<Field, FieldType>::value,
            "Field has wrong type");
 
        return field;
    }
 
    template <typename... TParams>
    using FixedLengthTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using VarLengthTag = comms::details::tag::Tag2<>;
 
    static constexpr std::size_t MinFieldLength = Field::minLength();
    static constexpr std::size_t MaxFieldLength = Field::maxLength();
 
    template <typename...>
    using LengthTag = 
        typename comms::util::LazyShallowConditional<
            (MinFieldLength == MaxFieldLength)
        >::template Type<
            FixedLengthTag,
            VarLengthTag
        >;
 
    class NextLayerReader
    {
    public:
        explicit NextLayerReader(NextLayer& nextLayer)
          : nextLayer_(nextLayer)
        {
        }
 
        template <typename TMsgPtr, typename TIter, typename... TExtraValues>
        ErrorStatus read(
            TMsgPtr& msg,
            TIter& iter,
            std::size_t size,
            TExtraValues... extraValues)
        {
            return nextLayer_.read(msg, iter, size, extraValues...);
        }
    private:
        NextLayer& nextLayer_;
    };
 
    class NextLayerUntilDataReader
    {
    public:
        explicit NextLayerUntilDataReader(NextLayer& nextLayer)
          : nextLayer_(nextLayer)
        {
        }
 
        template <typename TMsgPtr, typename TIter, typename... TExtraValues>
        ErrorStatus read(
            TMsgPtr& msg,
            TIter& iter,
            std::size_t size,
            TExtraValues... extraValues)
        {
            return nextLayer_.readUntilData(msg, iter, size, extraValues...);
        }
    private:
        NextLayer& nextLayer_;
    };
 
    template <typename TAllFields>
    class NextLayerCachedFieldsReader
    {
    public:
        NextLayerCachedFieldsReader(
            NextLayer& nextLayer,
            TAllFields& allFields)
          : nextLayer_(nextLayer),
            allFields_(allFields)
        {
        }
 
        template<typename TMsgPtr, typename TIter, typename... TExtraValues>
        ErrorStatus read(
            TMsgPtr& msg,
            TIter& iter,
            std::size_t size,
            TExtraValues... extraValues)
        {
            return nextLayer_.readFieldsCached(allFields_, msg, iter, size, extraValues...);
        }
 
    private:
        NextLayer& nextLayer_;
        TAllFields& allFields_;
    };
 
    template <typename TAllFields>
    class NextLayerCachedFieldsUntilDataReader
    {
    public:
        NextLayerCachedFieldsUntilDataReader(
            NextLayer& nextLayer,
            TAllFields& allFields)
          : nextLayer_(nextLayer),
            allFields_(allFields)
        {
        }
 
        template<typename TMsgPtr, typename TIter, typename... TExtraValues>
        ErrorStatus read(
            TMsgPtr& msg,
            TIter& iter,
            std::size_t size,
            TExtraValues... extraValues)
        {
            return nextLayer_.readUntilDataFieldsCache(allFields_, msg, iter, size, extraValues...);
        }
 
    private:
        NextLayer& nextLayer_;
        TAllFields& allFields_;
    };
 
    class NextLayerWriter
    {
    public:
 
        explicit NextLayerWriter(const NextLayer& nextLayer)
          : nextLayer_(nextLayer)
        {
        }
 
        template <typename TMsg, typename TIter>
        ErrorStatus write(const TMsg& msg, TIter& iter, std::size_t size) const
        {
            return nextLayer_.write(msg, iter, size);
        }
 
    private:
        const NextLayer& nextLayer_;
    };
 
    template <typename TAllFields>
    class NextLayerCachedFieldsWriter
    {
    public:
        NextLayerCachedFieldsWriter(
            const NextLayer& nextLayer,
            TAllFields& allFields)
          : nextLayer_(nextLayer),
            allFields_(allFields)
        {
        }
 
        template <typename TMsg, typename TIter>
        ErrorStatus write(const TMsg& msg, TIter& iter, std::size_t size) const
        {
            return nextLayer_.writeFieldsCached(allFields_, msg, iter, size);
        }
 
    private:
        const NextLayer& nextLayer_;
        TAllFields& allFields_;
    };
 
    class NextLayerUpdater
    {
    public:
 
        explicit NextLayerUpdater(const NextLayer& nextLayer)
          : nextLayer_(nextLayer)
        {
        }
 
        template <typename TIter>
        ErrorStatus update(TIter& iter, std::size_t size) const
        {
            return nextLayer_.update(iter, size);
        }
 
        template <typename TMsg, typename TIter>
        ErrorStatus update(const TMsg& msg, TIter& iter, std::size_t size) const
        {
            return nextLayer_.update(msg, iter, size);
        }
 
    private:
        const NextLayer& nextLayer_;
    };
 
    template <typename TAllFields>
    class NextLayerCachedFieldsUpdater
    {
    public:
        NextLayerCachedFieldsUpdater(
            const NextLayer& nextLayer,
            TAllFields& allFields)
          : nextLayer_(nextLayer),
            allFields_(allFields)
        {
        }
 
        template <typename TIter>
        ErrorStatus update(TIter& iter, std::size_t size) const
        {
            return nextLayer_.updateFieldsCached(allFields_, iter, size);
        }
 
        template <typename TMsg, typename TIter>
        ErrorStatus update(const TMsg& msg, TIter& iter, std::size_t size) const
        {
            return nextLayer_.updateFieldsCached(allFields_, msg, iter, size);
        }
 
    private:
        const NextLayer& nextLayer_;
        TAllFields& allFields_;
    };
 
    NextLayerReader createNextLayerReader()
    {
        return NextLayerReader(nextLayer_);
    }
 
    NextLayerUntilDataReader createNextLayerUntilDataReader()
    {
        return NextLayerUntilDataReader(nextLayer_);
    }
 
    template <typename TAllFields>
    NextLayerCachedFieldsReader<TAllFields>
    createNextLayerCachedFieldsReader(TAllFields& fields)
    {
        return NextLayerCachedFieldsReader<TAllFields>(nextLayer_, fields);
    }
 
    template <typename TAllFields>
    NextLayerCachedFieldsUntilDataReader<TAllFields>
    createNextLayerCachedFieldsUntilDataReader(TAllFields& fields)
    {
        return NextLayerCachedFieldsUntilDataReader<TAllFields>(nextLayer_, fields);
    }
 
    NextLayerWriter createNextLayerWriter() const
    {
        return NextLayerWriter(nextLayer_);
    }
 
    template <typename TAllFields>
    NextLayerCachedFieldsWriter<TAllFields>
    createNextLayerCachedFieldsWriter(TAllFields& fields) const
    {
        return NextLayerCachedFieldsWriter<TAllFields>(nextLayer_, fields);
    }
 
    NextLayerUpdater createNextLayerUpdater() const
    {
        return NextLayerUpdater(nextLayer_);
    }
 
    template <typename TAllFields>
    NextLayerCachedFieldsUpdater<TAllFields>
    createNextLayerCachedFieldsUpdater(TAllFields& fields) const
    {
        return NextLayerCachedFieldsUpdater<TAllFields>(nextLayer_, fields);
    }
 
private:
 
    template <typename... TParams>
    using NormalReadTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using SplitReadTag = comms::details::tag::Tag4<>;
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readInternal(
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        NormalReadTag<>,
        TExtraValues... extraValues)
    {
        Field field;
        auto& derivedObj = static_cast<TDerived&>(*this);
        auto reader = createNextLayerReader();
        return derivedObj.doRead(field, msg, iter, size, reader, extraValues...);
    }
 
    template <typename TMsgPtr, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readInternal(
        TMsgPtr& msgPtr,
        TIter& iter,
        std::size_t size,
        SplitReadTag<>,
        TExtraValues... extraValues)
    {
        auto fromIter = iter;
        auto es = readUntilData(msgPtr, iter, size, extraValues...);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        auto consumed = static_cast<std::size_t>(std::distance(fromIter, iter));
        COMMS_ASSERT(consumed <= size);
        return readFromData(msgPtr, iter, size - consumed, extraValues...);
    }
 
    template <typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus updateInternal(
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        FixedLengthTag<TParams...>) const
    {
        auto len = field.length();
        COMMS_ASSERT(len <= size);
        std::advance(iter, len);
        return nextLayerUpdater.update(iter, size - len);
    }
 
    template <typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus updateInternal(
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        VarLengthTag<TParams...>) const
    {
        auto iterTmp = iter;
        auto es = field.read(iter, size);
        if (es == comms::ErrorStatus::Success) {
            auto diff = static_cast<std::size_t>(std::distance(iterTmp, iter));
            es = nextLayerUpdater.update(iter, size - diff);
        }
        return es;
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus updateInternal(
        const TMsg& msg,
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        FixedLengthTag<TParams...>) const
    {
        auto len = field.length();
        COMMS_ASSERT(len <= size);
        std::advance(iter, len);
        return nextLayerUpdater.update(msg, iter, size - len);
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus updateInternal(
        const TMsg& msg,
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        VarLengthTag<TParams...>) const
    {
        auto iterTmp = iter;
        auto es = field.read(iter, size);
        if (es == comms::ErrorStatus::Success) {
            auto diff = static_cast<std::size_t>(std::distance(iterTmp, iter));
            es = nextLayerUpdater.update(msg, iter, size - diff);
        }
        return es;
    }
 
    template <typename TMsg, typename... TParams>
    static void resetMsgInternal(TMsg&, MessageObjTag<TParams...>)
    {
        // Do nothing
    }
 
    template <typename TMsg, typename... TParams>
    static void resetMsgInternal(TMsg& msg, SmartPtrTag<TParams...>)
    {
        msg.reset();
    }
 
    static void updateMissingSizeInternal(std::size_t size)
    {
        static_cast<void>(size);
    }
 
    static void updateMissingSizeInternal(const Field& field, std::size_t size)
    {
        static_cast<void>(field);
        static_cast<void>(size);
    }
 
    template <typename... TExtraValues>
    void updateMissingSizeInternal(
        std::size_t size,
        details::MissingSizeRetriever<> retriever,
        TExtraValues... extraValues) const
    {
        COMMS_ASSERT(size <= length());
        retriever.setValue(std::max(std::size_t(1U), length() - size));
        updateMissingSizeInternal(size, extraValues...);
    }
 
    template <typename... TExtraValues>
    void updateMissingSizeInternal(
        const Field& field,
        std::size_t size,
        details::MissingSizeRetriever<> retriever,
        TExtraValues... extraValues) const
    {
        static_assert(
            details::isMissingSizeRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Must be missing size retriever");
        auto totalLen = field.length() + nextLayer_.length();
        COMMS_ASSERT(size <= totalLen);
        retriever.setValue(std::max(std::size_t(1U), totalLen - size));
        updateMissingSizeInternal(size, extraValues...);
    }
 
    template <typename T, typename... TExtraValues>
    void updateMissingSizeInternal(
        std::size_t size,
        T retriever,
        TExtraValues... extraValues) const
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMissingSizeRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be missing size retriever");
        updateMissingSizeInternal(size, extraValues...);
    }
 
    template <typename T, typename... TExtraValues>
    void updateMissingSizeInternal(
        const Field& field,
        std::size_t size,
        T retriever,
        TExtraValues... extraValues) const
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMissingSizeRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be missing size retriever");
        updateMissingSizeInternal(field, size, extraValues...);
    }
 
    static void setMissingSizeInternal(std::size_t val)
    {
        static_cast<void>(val);
    }
 
    template <typename... TExtraValues>
    static void setMissingSizeInternal(
        std::size_t val,
        details::MissingSizeRetriever<> retriever,
        TExtraValues... extraValues)
    {
        retriever.setValue(val);
        setMissingSizeInternal(val, extraValues...);
    }
 
    template <typename T, typename... TExtraValues>
    static void setMissingSizeInternal(
        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");
        setMissingSizeInternal(val, extraValues...);
    }
 
    template <typename TId>
    static void setMsgIdInternal(TId val)
    {
        static_cast<void>(val);
    }
 
    template <typename TId, typename U, typename... TExtraValues>
    static void setMsgIdInternal(
        TId val,
        details::MsgIdRetriever<U> retriever,
        TExtraValues... extraValues)
    {
        retriever.setValue(val);
        setMsgIdInternal(val, extraValues...);
    }
 
    template <typename TId, typename T, typename... TExtraValues>
    static void setMsgIdInternal(
        TId val,
        T retriever,
        TExtraValues... extraValues)
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMsgIdRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be message id retriever");
        setMsgIdInternal(val, extraValues...);
    }
 
    static void setMsgIndexInternal(std::size_t val)
    {
        static_cast<void>(val);
    }
 
    template <typename... TExtraValues>
    static void setMsgIndexInternal(
        std::size_t val,
        details::MsgIndexRetriever retriever,
        TExtraValues... extraValues)
    {
        retriever.setValue(val);
        setMsgIndexInternal(val, extraValues...);
    }
 
    template <typename T, typename... TExtraValues>
    static void setMsgIndexInternal(
        std::size_t val,
        T retriever,
        TExtraValues... extraValues)
    {
        static_cast<void>(retriever);
        static_assert(
            !details::isMsgIndexRetriever<typename std::decay<decltype(retriever)>::type>(),
            "Mustn't be missing size retriever");
        setMsgIndexInternal(val, extraValues...);
    }
 
    static_assert (comms::util::IsTuple<AllFields>::Value, "Must be tuple");
    NextLayer nextLayer_;
};
 
template <
    typename TField,
    typename TNextLayer,
    typename TDerived,
    typename...  TOptions>
ProtocolLayerBase<TField, TNextLayer, TDerived, TOptions...>&
toProtocolLayerBase(ProtocolLayerBase<TField, TNextLayer, TDerived, TOptions...>& layer)
{
    return layer;
}
 
template <
    typename TField,
    typename TNextLayer,
    typename TDerived,
    typename...  TOptions>
constexpr
const ProtocolLayerBase<TField, TNextLayer, TDerived, TOptions...>&
toProtocolLayerBase(const ProtocolLayerBase<TField, TNextLayer, TDerived, TOptions...>& layer)
{
    return layer;
}
 
inline
details::MissingSizeRetriever<> missingSize(std::size_t& val)
{
    return details::MissingSizeRetriever<>(val);
}
 
template <typename TId>
details::MsgIdRetriever<TId> msgId(TId& val)
{
    return details::MsgIdRetriever<TId>(val);
}
 
inline
details::MsgIndexRetriever msgIndex(std::size_t& val)
{
    return details::MsgIndexRetriever(val);
}
 
template <typename TIter>
details::MsgPayloadRetriever<TIter> msgPayload(TIter& iter, std::size_t& len)
{
    return details::MsgPayloadRetriever<TIter>(iter, len);
}
 
}  // namespace protocol
 
}  // namespace comms
 
#define COMMS_PROTOCOL_LAYERS_ACCESS(...) \
    COMMS_DO_ACCESS_LAYER_ACC_FUNC(__VA_ARGS__)
 
#define COMMS_PROTOCOL_LAYERS_NAMES(...) \
    COMMS_DO_LAYER_TYPE_ALIAS(Base, __VA_ARGS__) \
    COMMS_DO_ACCESS_LAYER_ACC_FUNC(__VA_ARGS__)
 
 
#define COMMS_PROTOCOL_LAYERS_ACCESS_INNER(...) \
    COMMS_PROTOCOL_LAYERS_ACCESS(__VA_ARGS__)
 
#define COMMS_PROTOCOL_LAYERS_NAMES_INNER(...) \
    COMMS_PROTOCOL_LAYERS_NAMES(__VA_ARGS__)    
 
#define COMMS_PROTOCOL_LAYERS_ACCESS_OUTER(...) \
    COMMS_PROTOCOL_LAYERS_ACCESS(COMMS_EXPAND(COMMS_REVERSE_MACRO_ARGS(__VA_ARGS__)))
 
#define COMMS_PROTOCOL_LAYERS_NAMES_OUTER(...) \
    COMMS_PROTOCOL_LAYERS_NAMES(COMMS_EXPAND(COMMS_REVERSE_MACRO_ARGS(__VA_ARGS__)))
 
COMMS_MSVC_WARNING_POP