TransportValueLayer.h

Go to the documentation of this file.

//
// Copyright 2017 - 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/cast.h"
#include "comms/details/tag.h"
#include "comms/frame/details/TransportValueLayerOptionsParser.h"
#include "comms/frame/details/TransportValueLayerBase.h"
#include "comms/util/type_traits.h"
 
#include <cstddef>
#include <iterator>
#include <tuple>
#include <type_traits>
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4189) // Disable erroneous initialized but not referenced variable warning
 
namespace comms
{
 
namespace frame
{
 
template <typename TField, std::size_t TIdx, typename TNextLayer, typename... TOptions>
class TransportValueLayer : public comms::frame::details::TransportValueLayerBase<TField, TIdx, TNextLayer, TOptions...>
{
    using BaseImpl = comms::frame::details::TransportValueLayerBase<TField, TIdx, TNextLayer, TOptions...>;
    using ParsedOptionsInternal = comms::frame::details::TransportValueLayerOptionsParser<TOptions...>;
 
public:
    using Field = typename BaseImpl::Field;
 
    TransportValueLayer() = default;
 
    TransportValueLayer(const TransportValueLayer&) = default;
 
    TransportValueLayer(TransportValueLayer&&) = default;
 
    ~TransportValueLayer() noexcept = default;
 
    static constexpr bool hasExtendingClass()
    {
        return ParsedOptionsInternal::HasExtendingClass;
    }
 
    static constexpr bool hasPseudoValue()
    {
        return ParsedOptionsInternal::HasPseudoValue;
    }
 
    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)
    {
        auto es = readFieldInternal(field, msg, iter, size, ValueTag<>(), extraValues...);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        static constexpr bool ForcedReadUntilDataSplit =
            BaseImpl::ParsedOptions::HasForceReadUntilDataSplit;
 
        if (ForcedReadUntilDataSplit) {
            es = nextLayerReader.read(msg, iter, size, extraValues...);
 
            if (es != comms::ErrorStatus::Success) {
                return es;
            }
        }
 
        auto& thisObj = BaseImpl::thisLayer();
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        bool success = thisObj.reassignFieldValueToMsg(field, msgPtr);
        if (!success) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        if (!ForcedReadUntilDataSplit) {
            es = nextLayerReader.read(msg, iter, size, extraValues...);
        }
 
        return es;
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerWriter>
    comms::ErrorStatus doWrite(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TNextLayerWriter&& nextLayerWriter) const
    {
        auto& thisObj = BaseImpl::thisLayer();
        thisObj.prepareFieldForWrite(msg, field);
 
        auto es = writeFieldInternal(field, msg, iter, size, ValueTag<>());
        if (es != ErrorStatus::Success) {
            return es;
        }
 
        return nextLayerWriter.write(msg, iter, size);
    }
 
    static constexpr std::size_t doFieldLength()
    {
         return doFieldLengthInternal(ValueTag<>());
    }
 
    template <typename TMsg>
    static std::size_t doFieldLength(const TMsg&)
    {
        return doFieldLength();
    }
 
#ifdef FOR_DOXYGEN_DOC_ONLY
    Field& pseudoField();
 
    const Field& pseudoField() const;
#endif
 
protected:
    template <typename TMsg>
    static void reassignFieldValue(TMsg& msg, const Field& field)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(MsgType::hasTransportFields(),
            "Message interface class hasn't defined transport fields, "
            "use comms::option::def::ExtraTransportFields option.");
        static_assert(TIdx < std::tuple_size<typename MsgType::TransportFields>::value,
            "TIdx is too big, exceeds the amount of transport fields defined in interface class");
 
        auto& allTransportFields = msg.transportFields();
        auto& transportField = std::get<TIdx>(allTransportFields);
 
        using FieldType = typename std::decay<decltype(transportField)>::type;
        transportField = comms::field_cast<FieldType>(field);
    }
 
    template <typename TMsg>
    bool reassignFieldValueToMsg(const Field& field, TMsg* msgPtr)
    {
        if (msgPtr == nullptr) {
            return false;
        }
 
        auto& thisObj = BaseImpl::thisLayer();
        thisObj.reassignFieldValue(*msgPtr, field);
        return true;
    }
 
    template <typename TMsg>
    static void prepareFieldForWrite(const TMsg& msg, Field& field)
    {
        using MsgType = typename std::decay<decltype(msg)>::type;
        static_assert(MsgType::hasTransportFields(),
            "Message interface class hasn't defined transport fields, "
            "use comms::option::def::ExtraTransportFields option.");
        static_assert(TIdx < std::tuple_size<typename MsgType::TransportFields>::value,
            "TIdx is too big, exceeds the amount of transport fields defined in interface class");
 
        auto& transportField = std::get<TIdx>(msg.transportFields());
        field = comms::field_cast<Field>(transportField);
    }
 
private:
 
    template <typename... TParams>
    using PseudoValueTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using NormalValueTag = comms::details::tag::Tag2<>;
 
    template <typename...>
    using ValueTag =
        typename comms::util::LazyShallowConditional<
            ParsedOptionsInternal::HasPseudoValue
        >::template Type<
            PseudoValueTag,
            NormalValueTag
        >;
 
    template <typename... TParams>
    static constexpr std::size_t doFieldLengthInternal(PseudoValueTag<TParams...>)
    {
        return 0U;
    }
 
    template <typename... TParams>
    static constexpr std::size_t doFieldLengthInternal(NormalValueTag<TParams...>)
    {
        return BaseImpl::doFieldLength();
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readFieldInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t& len,
        PseudoValueTag<>,
        TExtraValues...)
    {
        static_cast<void>(msg);
        static_cast<void>(iter);
        static_cast<void>(len);
        field = BaseImpl::pseudoField();
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename TIter, typename... TExtraValues>
    comms::ErrorStatus readFieldInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t& len,
        NormalValueTag<>,
        TExtraValues... extraValues)
    {
        auto& thisObj = BaseImpl::thisLayer();
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        auto beforeReadIter = iter;
 
        auto es = thisObj.doReadField(msgPtr, field, iter, len);
        if (es == comms::ErrorStatus::NotEnoughData) {
            BaseImpl::updateMissingSize(field, len, extraValues...);
        }
        else {
            auto fieldLen = static_cast<std::size_t>(std::distance(beforeReadIter, iter));
            len -= fieldLen;
        }
        return es;
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    comms::ErrorStatus writeFieldInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t& len,
        PseudoValueTag<TParams...>) const
    {
        static_cast<void>(msg);
        static_cast<void>(iter);
        static_cast<void>(len);
        field = BaseImpl::pseudoField();
        return comms::ErrorStatus::Success;
    }
 
    template <typename TMsg, typename TIter, typename... TParams>
    comms::ErrorStatus writeFieldInternal(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t& len,
        NormalValueTag<TParams...>) const
    {
        auto& thisObj = BaseImpl::thisLayer();
        auto es = thisObj.doWriteField(&msg, field, iter, len);
        if (es == comms::ErrorStatus::Success) {
            COMMS_ASSERT(field.length() <= len);
            len -= field.length();
        }
        return es;
    }
};
 
namespace details
{
template <typename T>
struct TransportValueLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename TField, std::size_t TIdx, typename TNextLayer>
struct TransportValueLayerCheckHelper<TransportValueLayer<TField, TIdx, TNextLayer> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isTransportValueLayer()
{
    return details::TransportValueLayerCheckHelper<T>::Value;
}
 
}  // namespace frame
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP