SyncPrefixLayer.h

Go to the documentation of this file.

//
// Copyright 2015 - 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/frame/details/SyncPrefixLayerBase.h"
#include "comms/frame/details/SyncPrefixLayerOptionsParser.h"
 
#include <algorithm>
#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 SyncPrefixLayer : public comms::frame::details::SyncPrefixLayerBase<TField, TNextLayer, TOptions...>
{
    using BaseImpl = comms::frame::details::SyncPrefixLayerBase<TField, TNextLayer, TOptions...>;
    using ParsedOptionsInternal = comms::frame::details::SyncPrefixLayerOptionsParser<TOptions...>;
 
public:
    using Field = typename BaseImpl::Field;
 
    using EscField = typename ParsedOptionsInternal::EscField;
 
    SyncPrefixLayer() = default;
 
    SyncPrefixLayer(const SyncPrefixLayer&) = default;
 
    SyncPrefixLayer(SyncPrefixLayer&&) = default;
 
    ~SyncPrefixLayer() noexcept = default;
 
    static constexpr bool hasExtendingClass()
    {
        return ParsedOptionsInternal::HasExtendingClass;
    }
 
    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 SeekTag =
            typename comms::util::LazyShallowConditional<
                ParsedOptionsInternal::HasSeekField
            >::template Type<
                SeekFieldTag,
                InstantOpTag
            >;
 
        return
            readInternal(
                field,
                msg,
                iter,
                size,
                std::forward<TNextLayerReader>(nextLayerReader),
                SeekTag(),
                extraValues...);
    }
 
    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(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());
    }
 
protected:
    static bool verifyFieldValue(const Field& field)
    {
        return field == Field();
    }
 
    template <typename TEscField>
    static bool verifyEscFieldValue(const TEscField& field)
    {
        return field == TEscField();
    }
 
    static void prepareFieldForWrite(Field& field)
    {
        static_cast<void>(field);
    }
 
private:
    template <typename... TParams>
    using SeekFieldTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using InstantOpTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using EscapeSupportedTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using NoEscapeTag = comms::details::tag::Tag4<>;
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus readInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        SeekFieldTag<>,
        TExtraValues... extraValues)
    {
        using IterType = typename std::decay<decltype(iter)>::type;
        static_assert(std::is_same<typename std::iterator_traits<IterType>::iterator_category, std::random_access_iterator_tag>::value,
            "The read operation is expected to use random access iterator");
 
        auto& thisObj = BaseImpl::thisLayer();
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
 
        auto fromIter = iter;
        std::size_t consumed = 0U;
        while (consumed < size) {
            auto iterTmp = iter;
            auto remSize = size - consumed;
 
            auto fieldEs = thisObj.doReadField(msgPtr, field, iterTmp, remSize);
            if (fieldEs == ErrorStatus::NotEnoughData) {
                BaseImpl::updateMissingSize(field, remSize, extraValues...);
                BaseImpl::resetMsg(msg);
                return fieldEs;
            }
 
            if ((fieldEs == ErrorStatus::Success) &&
                (!fieldEscapedInternal(fromIter, iter)) &&
                (thisObj.verifyFieldValue(field))) {
                // Set iter to point after field
                iter = iterTmp;
                break;
            }
 
            ++iter;
            ++consumed;
        }
 
        if (size <= consumed) {
            // Field hasn't been recognized
            return ErrorStatus::NotEnoughData;
        }
 
        auto remSize = size - static_cast<std::size_t>(std::distance(fromIter, iter));
        return nextLayerReader.read(msg, iter, remSize, extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus readInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        InstantOpTag<>,
        TExtraValues... extraValues)
    {
        auto& thisObj = BaseImpl::thisLayer();
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        auto beforeReadIter = iter;
 
        auto es = thisObj.doReadField(msgPtr, field, iter, size);
        if (es == comms::ErrorStatus::NotEnoughData) {
            BaseImpl::updateMissingSize(field, size, extraValues...);
        }
 
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        bool verified = thisObj.verifyFieldValue(field);
        if (!verified) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        auto fieldLen = static_cast<std::size_t>(std::distance(beforeReadIter, iter));
        return nextLayerReader.read(msg, iter, size - fieldLen, extraValues...);
    }
 
    template <typename TIter>
    bool fieldEscapedInternal(TIter from, TIter to, NoEscapeTag<>)
    {
        static_cast<void>(from);
        static_cast<void>(to);
        return false;
    }
 
    template <typename TIter>
    bool fieldEscapedInternal(TIter from, TIter to, EscapeSupportedTag<>)
    {
        unsigned escCount = 0U;
        auto& thisObj = BaseImpl::thisLayer();
 
        while (from != to) {
            auto dist = static_cast<std::size_t>(std::distance(from, to));
            dist = std::min(dist, EscField::maxLength());
            if (dist < EscField::minLength()) {
                break;
            }
 
            auto maxLenIter = to;
            std::advance(maxLenIter, -static_cast<int>(dist));
 
            auto iter = to;
            std::advance(iter, -static_cast<int>(EscField::minLength()));
            auto prevCount = escCount;
            while (true) {
                auto iterTmp = iter;
                EscField escField;
                auto len = static_cast<std::size_t>(std::distance(iterTmp, to));
                auto es = escField.read(iterTmp, len);
                if ((es == comms::ErrorStatus::Success) &&
                    (iterTmp == to) &&
                    (thisObj.verifyEscFieldValue(escField))) {
                    ++escCount;
                    break;
                }
 
                if (iter == maxLenIter) {
                    break;
                }
 
                std::advance(iter, -1);
            }
 
            if (prevCount == escCount) {
                // Failed to detect escField
                break;
            }
 
            // esc field was detected, trying again
            to = iter;
        }
 
        // Escaped only if odd number of esc field is detected
        return (escCount & 0x1) != 0U;
    }
 
    template <typename TIter>
    bool fieldEscapedInternal(TIter from, TIter to)
    {
        using EscTag =
            typename comms::util::LazyShallowConditional<
                std::is_same<EscField, void>::value
            >::template Type<
                NoEscapeTag,
                EscapeSupportedTag
            >;
 
        return fieldEscapedInternal(from, to, EscTag());
    }
};
 
namespace details
{
template <typename T>
struct SyncPrefixLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename TField, typename TNextLayer>
struct SyncPrefixLayerCheckHelper<SyncPrefixLayer<TField, TNextLayer> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isSyncPrefixLayer()
{
    return details::SyncPrefixLayerCheckHelper<T>::Value;
}
 
}  // namespace frame
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP