MsgSizeLayer.h

Go to the documentation of this file.

//
// Copyright 2014 - 2026 (C). Alex Robenko. All rights reserved.
//
// SPDX-License-Identifier: MPL-2.0
//
// 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 "comms/CompileControl.h"
#include "comms/details/tag.h"
#include "comms/field/IntValue.h"
#include "comms/frame/details/MsgSizeLayerBase.h"
#include "comms/frame/details/MsgSizeLayerConstNullPtrCastHelper.h"
#include "comms/frame/details/MsgSizeLayerOptionsParser.h"
#include "comms/MessageBase.h"
#include "comms/util/type_traits.h"
 
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <utility>
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4189) // Disable erroneous initialized but not referenced variable warning
 
namespace comms
{
 
namespace frame
{
 
template <typename TField, typename TNextLayer, typename... TOptions>
class MsgSizeLayer : public comms::frame::details::MsgSizeLayerBase<TField, TNextLayer, TOptions...>
{
    using BaseImpl = comms::frame::details::MsgSizeLayerBase<TField, TNextLayer, TOptions...>;
    using ParsedOptionsInternal = details::MsgSizeLayerOptionsParser<TOptions...>;
 
public:
    using Field = typename BaseImpl::Field;
 
    explicit MsgSizeLayer() = default;
 
    MsgSizeLayer(const MsgSizeLayer&) = default;
 
    MsgSizeLayer(MsgSizeLayer&&) = default;
 
    ~MsgSizeLayer() noexcept = default;
 
    MsgSizeLayer& operator=(const MsgSizeLayer&) = default;
 
    MsgSizeLayer& operator=(MsgSizeLayer&&) = default;
 
    static constexpr bool hasExtendingClass()
    {
        return ParsedOptionsInternal::HasExtendingClass;
    }
 
    static constexpr std::size_t doFieldLength()
    {
        return BaseImpl::doFieldLength();
    }
 
    template <typename TMsg>
    constexpr std::size_t doFieldLength(const TMsg& msg) const
    {
        return fieldLengthInternal(msg, LengthTag<>());
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerReader, typename... TExtraValues>
    comms::ErrorStatus doRead(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TNextLayerReader&& nextLayerReader,
        TExtraValues... extraValues)
    {
        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,
            "Current implementation of MsgSizeLayer requires iterator used for reading to be random-access one.");
 
        auto begIter = iter;
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        auto& thisObj = BaseImpl::thisLayer();
        auto es = thisObj.doReadField(msgPtr, field, iter, size);
        if (es == ErrorStatus::NotEnoughData) {
            BaseImpl::updateMissingSize(field, size, extraValues...);
        }
 
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        auto fromIter = iter;
        auto readFieldLength = static_cast<std::size_t>(std::distance(begIter, iter));
        std::size_t actualRemainingSize = (size - readFieldLength);
        std::size_t requiredRemainingSize = thisObj.getRemainingSizeFromField(field);
 
        if (actualRemainingSize < requiredRemainingSize) {
            BaseImpl::setMissingSize(requiredRemainingSize - actualRemainingSize, extraValues...);
            return ErrorStatus::NotEnoughData;
        }
 
        thisObj.beforeRead(field, msgPtr);
        es = nextLayerReader.read(msg, iter, requiredRemainingSize, extraValues...);
        if (es == ErrorStatus::NotEnoughData) {
            BaseImpl::resetMsg(msg);
            return ErrorStatus::ProtocolError;
        }
 
        if (es != ErrorStatus::ProtocolError) {
            iter = fromIter;
            std::advance(iter, requiredRemainingSize);
        }
 
        auto consumed =
            static_cast<std::size_t>(std::distance(fromIter, iter));
        if (consumed < requiredRemainingSize) {
            auto diff = requiredRemainingSize - consumed;
            std::advance(iter, diff);
        }
        return es;
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerWriter>
    ErrorStatus doWrite(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TNextLayerWriter&& nextLayerWriter) const
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        return writeInternal(field, msg, iter, size, std::forward<TNextLayerWriter>(nextLayerWriter), MsgLengthTag<MsgType>());
    }
 
    template <typename TIter, typename TNextLayerUpdater>
    comms::ErrorStatus doUpdate(
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater) const
    {
        using LocalMsgPtr = typename BaseImpl::MsgPtr;
        using ConstNullptrType =
            typename details::MsgSizeLayerConstNullPtrCastHelper<
                !std::is_void<LocalMsgPtr>::value
            >::template Type<LocalMsgPtr>;
        auto noMsgPtr = static_cast<ConstNullptrType>(nullptr);
        return doUpdateInternal(noMsgPtr, field, iter, size, std::forward<TNextLayerUpdater>(nextLayerUpdater), NoMsgTypeTag<>());
    }
 
    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 doUpdateInternal(&msg, field, iter, size, std::forward<TNextLayerUpdater>(nextLayerUpdater), ValidMsgTypeTag<>());
    }
 
protected:
    static std::size_t getRemainingSizeFromField(const Field& field)
    {
        return static_cast<std::size_t>(field.getValue());
    }
 
    template <typename TMsg>
    static void beforeRead(const Field& field, TMsg* msg)
    {
        static_cast<void>(field);
        static_cast<void>(msg);
    }
 
    template <typename TMsg>
    static void prepareFieldForWrite(std::size_t size, const TMsg* msg, Field& field)
    {
        static_cast<void>(msg);
        field.setValue(size);
    }
 
private:
    template <typename... TParams>
    using FixedLengthTag = typename BaseImpl::template FixedLengthTag<TParams...>;
 
    template <typename...TParams>
    using VarLengthTag = typename BaseImpl::template VarLengthTag<TParams...>;
 
    template <typename... TParams>
    using LengthTag = typename BaseImpl::template LengthTag<TParams...>;
 
    template <typename... TParams>
    using MsgHasLengthTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using MsgNoLengthTag = comms::details::tag::Tag4<>;
 
    template <typename... TParams>
    using ValidMsgTypeTag = comms::details::tag::Tag5<>;
 
    template <typename... TParams>
    using NoMsgTypeTag = comms::details::tag::Tag6<>;
 
    template<typename TMsg>
    using MsgLengthTag =
        typename comms::util::LazyShallowConditional<
            details::FrameLayerHasFieldsImpl<TMsg>::Value || TMsg::hasLength()
        >::template Type<
            MsgHasLengthTag,
            MsgNoLengthTag
        >;
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalHasLength(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter) const
    {
        std::size_t lenValue = BaseImpl::nextLayer().length(msg);
        auto& thisObj = BaseImpl::thisLayer();
 
        thisObj.prepareFieldForWrite(lenValue, &msg, field);
        auto es = thisObj.doWriteField(&msg, field, iter, size);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        COMMS_ASSERT(field.length() <= size);
        return nextLayerWriter.write(msg, iter, size - field.length());
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalRandomAccess(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter) const
    {
        auto valueIter = iter;
        auto& thisObj = BaseImpl::thisLayer();
        thisObj.prepareFieldForWrite(0U, &msg, field);
        auto es = thisObj.doWriteField(&msg, field, iter, size);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        auto dataIter = iter;
 
        auto sizeLen = field.length();
        es = nextLayerWriter.write(msg, iter, size - sizeLen);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        auto dist = static_cast<std::size_t>(std::distance(dataIter, iter));
        thisObj.prepareFieldForWrite(dist, &msg, field);
        COMMS_ASSERT(field.length() == sizeLen);
        return thisObj.doWriteField(&msg, field, valueIter, sizeLen);
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalOutput(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter) const
    {
        auto& thisObj = BaseImpl::thisLayer();
        thisObj.prepareFieldForWrite(0U, &msg, field);
        auto es = thisObj.doWriteField(&msg, field, iter, size);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        es = nextLayerWriter.write(msg, iter, size - field.length());
        if ((es != ErrorStatus::Success) &&
            (es != ErrorStatus::UpdateRequired)) {
            return es;
        }
 
        return ErrorStatus::UpdateRequired;
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalNoLengthTagged(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter,
        std::random_access_iterator_tag) const
    {
        return writeInternalRandomAccess(field, msg, iter, size, std::forward<TWriter>(nextLayerWriter));
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalNoLengthTagged(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter,
        std::output_iterator_tag) const
    {
        return writeInternalOutput(field, msg, iter, size, std::forward<TWriter>(nextLayerWriter));
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalNoLength(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter) const
    {
        static_assert(
            (BaseImpl::MinFieldLength == BaseImpl::MaxFieldLength) ||
            (comms::isMessageBase<typename std::decay<decltype(msg)>::type>()),
                "Unable to perform write with size field having variable length and "
                "no polymorphic length calculation available.");
        using IterType = typename std::decay<decltype(iter)>::type;
        using Tag = typename std::iterator_traits<IterType>::iterator_category;
        return writeInternalNoLengthTagged(field, msg, iter, size, std::forward<TWriter>(nextLayerWriter), Tag());
    }
 
    template <typename TMsg, typename TIter, typename TWriter, typename... TParams>
    ErrorStatus writeInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter,
        MsgHasLengthTag<TParams...>) const
    {
        return writeInternalHasLength(field, msg, iter, size, std::forward<TWriter>(nextLayerWriter));
    }
 
    template <typename TMsg, typename TIter, typename TWriter, typename... TParams>
    ErrorStatus writeInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter,
        MsgNoLengthTag<TParams...>) const
    {
        return writeInternalNoLength(field, msg, iter, size, std::forward<TWriter>(nextLayerWriter));
    }
 
    template <typename TMsg, typename... TParams>
    constexpr std::size_t fieldLengthInternal(const TMsg& msg, FixedLengthTag<TParams...>) const
    {
        return BaseImpl::doFieldLength(msg);
    }
 
    template <typename TMsg, typename... TParams>
    std::size_t fieldLengthInternal(const TMsg& msg, VarLengthTag<TParams...>) const
    {
        auto& thisObj = BaseImpl::thisLayer();
        auto remSize = BaseImpl::nextLayer().length(msg);
        Field fieldTmp;
        thisObj.prepareFieldForWrite(remSize, &msg, fieldTmp);
        return fieldTmp.length();
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater, typename TForwardTag>
    comms::ErrorStatus doUpdateInternal(
        const TMsg* msg,
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        TForwardTag&& tag) const
    {
        std::size_t lenValue = size - Field::maxLength();
        auto& thisObj = BaseImpl::thisLayer();
        thisObj.prepareFieldForWrite(lenValue, msg, field);
 
        if (field.length() != Field::maxLength()) {
            lenValue = size - field.length();
            thisObj.prepareFieldForWrite(lenValue, msg, field);
        }
 
        auto es = thisObj.doWriteField(msg, field, iter, size);
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        return doUpdateForward(msg, iter, size - field.length(), std::forward<TNextLayerUpdater>(nextLayerUpdater), tag);
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus doUpdateForward(
        const TMsg* msg,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        NoMsgTypeTag<TParams...>) const
    {
        static_cast<void>(msg);
        return nextLayerUpdater.update(iter, size);
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater, typename... TParams>
    comms::ErrorStatus doUpdateForward(
        const TMsg* msg,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater,
        ValidMsgTypeTag<TParams...>) const
    {
        COMMS_ASSERT(msg != nullptr);
        return nextLayerUpdater.update(*msg, iter, size);
    }
};
 
namespace details
{
template <typename T>
struct MsgSizeLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename TField, typename TNextLayer>
struct MsgSizeLayerCheckHelper<MsgSizeLayer<TField, TNextLayer> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isMsgSizeLayer()
{
    return details::MsgSizeLayerCheckHelper<T>::Value;
}
 
}  // namespace frame
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP