SyncSuffixLayer.h

Go to the documentation of this file.

//
// Copyright 2025 - 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/cast.h"
#include "comms/CompileControl.h"
#include "comms/details/tag.h"
#include "comms/field/IntValue.h"
#include "comms/frame/details/SyncSuffixLayerBase.h"
#include "comms/frame/details/SyncSuffixLayerOptionsParser.h"
#include "comms/util/type_traits.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 SyncSuffixLayer : public comms::frame::details::SyncSuffixLayerBase<TField, TNextLayer, TOptions...>
{
    using BaseImpl = comms::frame::details::SyncSuffixLayerBase<TField, TNextLayer, TOptions...>;
    using ParsedOptionsInternal = details::SyncSuffixLayerOptionsParser<TOptions...>;
 
public:
    using Field = typename BaseImpl::Field;
 
    using EscField = typename ParsedOptionsInternal::EscField;
 
    SyncSuffixLayer() = default;
 
    SyncSuffixLayer(const SyncSuffixLayer&) = default;
 
    SyncSuffixLayer(SyncSuffixLayer&&) = default;
 
    ~SyncSuffixLayer() noexcept = default;
 
    SyncSuffixLayer& operator=(const SyncSuffixLayer&) = default;
 
    SyncSuffixLayer& operator=(SyncSuffixLayer&&) = default;
 
    static constexpr bool hasExtendingClass()
    {
        return ParsedOptionsInternal::HasExtendingClass;
    }
 
    static constexpr bool hasVerifyBeforeRead()
    {
        return ParsedOptionsInternal::HasVerifyBeforeRead;
    }
 
    static constexpr bool hasSeekField()
    {
        return ParsedOptionsInternal::HasSeekField;
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerReader, typename... TExtraValues>
    ErrorStatus doRead(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TNextLayerReader&& nextLayerReader,
        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");
 
        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>
    ErrorStatus doWrite(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TNextLayerWriter&& nextLayerWriter) const
    {
        using IterType = typename std::decay<decltype(iter)>::type;
        using Tag = typename std::iterator_traits<IterType>::iterator_category;
 
        return writeInternal(field, msg, iter, size, std::forward<TNextLayerWriter>(nextLayerWriter), Tag());
    }
 
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 VerifyBeforeReadTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using VerifyAfterReadTag = comms::details::tag::Tag4<>;
 
    template <typename... TParams>
    using EscapeSupportedTag = comms::details::tag::Tag5<>;
 
    template <typename... TParams>
    using NoEscapeTag = comms::details::tag::Tag6<>;
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus verifyRead(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        TExtraValues... extraValues)
    {
        auto fromIter = iter;
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        auto fieldLen = Field::minLength();
 
        static_assert(Field::minLength() == Field::maxLength(), "Cannot verify variable length suffix before reading rest of the message frame");
        auto& thisObj = BaseImpl::thisLayer();
        if (msgPtr != nullptr) {
            fieldLen = thisObj.doFieldLength(*msgPtr);
        }
        auto toIter = fromIter + (size - fieldLen);
 
        auto fieldEs = thisObj.doReadField(msgPtr, field, toIter, fieldLen);
        if (fieldEs != ErrorStatus::Success) {
            return fieldEs;
        }
 
        bool verified = thisObj.verifyFieldValue(field);
        if (!verified) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        auto es = nextLayerReader.read(msg, iter, size - fieldLen, extraValues...);
        if (es == ErrorStatus::Success) {
            iter = toIter;
        }
 
        return es;
    }
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus readVerify(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        TExtraValues... extraValues)
    {
        auto fromIter = iter;
 
        auto es = nextLayerReader.read(msg, iter, size, extraValues...);
        if ((es == ErrorStatus::NotEnoughData) ||
            (es == ErrorStatus::ProtocolError)) {
            return es;
        }
 
        auto len = static_cast<std::size_t>(std::distance(fromIter, iter));
        COMMS_ASSERT(len <= size);
        auto remSize = size - len;
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
        auto& thisObj = BaseImpl::thisLayer();
        auto fieldEs = thisObj.doReadField(msgPtr, field, iter, remSize);
        if (fieldEs == ErrorStatus::NotEnoughData) {
            BaseImpl::updateMissingSize(field, remSize, extraValues...);
        }
 
        if (fieldEs != ErrorStatus::Success) {
            BaseImpl::resetMsg(msg);
            return fieldEs;
        }
 
        bool verified = thisObj.verifyFieldValue(field);
        if (!verified) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        return es;
    }
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus seekFieldRead(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        TExtraValues... extraValues)
    {
        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;
        }
 
        // iter is already past the sync field
        return nextLayerReader.read(msg, fromIter, consumed, extraValues...);
    }
 
    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)
    {
        return
            seekFieldRead(
                field,
                msg,
                iter,
                size,
                std::forward<TReader>(nextLayerReader),
                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)
    {
        using VerifyTag =
            typename comms::util::LazyShallowConditional<
                ParsedOptionsInternal::HasVerifyBeforeRead
            >::template Type<
                VerifyBeforeReadTag,
                VerifyAfterReadTag
            >;
 
        return
            readInternal(
                field,
                msg,
                iter,
                size,
                std::forward<TReader>(nextLayerReader),
                VerifyTag(),
                extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus readInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        VerifyBeforeReadTag<>,
        TExtraValues... extraValues)
    {
        return
            verifyRead(
                field,
                msg,
                iter,
                size,
                std::forward<TReader>(nextLayerReader),
                extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename TReader, typename... TExtraValues>
    ErrorStatus readInternal(
        Field& field,
        TMsg& msg,
        TIter& iter,
        std::size_t size,
        TReader&& nextLayerReader,
        VerifyAfterReadTag<>,
        TExtraValues... extraValues)
    {
        return
            readVerify(
                field,
                msg,
                iter,
                size,
                std::forward<TReader>(nextLayerReader),
                extraValues...);
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternalRandomAccess(
        Field& field,
        const TMsg& msg,
        TIter& iter,
        std::size_t size,
        TWriter&& nextLayerWriter) const
    {
        auto fromIter = iter;
        auto es = nextLayerWriter.write(msg, iter, size);
        if ((es != comms::ErrorStatus::Success) &&
            (es != comms::ErrorStatus::UpdateRequired)) {
            return es;
        }
 
        COMMS_ASSERT(fromIter <= iter);
        auto len = static_cast<std::size_t>(std::distance(fromIter, iter));
        auto remSize = size - len;
        auto& thisObj = BaseImpl::thisLayer();
 
        thisObj.prepareFieldForWrite(field);
        auto esTmp = thisObj.doWriteField(&msg, field, iter, remSize);
        if (esTmp != comms::ErrorStatus::Success) {
            return esTmp;
        }
 
        return es;
    }
 
    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();
        auto fieldLen = thisObj.doFieldLength(msg);
        auto es = nextLayerWriter.write(msg, iter, size - fieldLen);
        if ((es != comms::ErrorStatus::Success) &&
            (es != comms::ErrorStatus::UpdateRequired)) {
            return es;
        }
 
        auto esTmp = thisObj.doWriteField(&msg, field, iter, fieldLen);
        static_cast<void>(esTmp);
        COMMS_ASSERT(esTmp == comms::ErrorStatus::Success);
        return comms::ErrorStatus::UpdateRequired;
    }
 
    template <typename TMsg, typename TIter, typename TWriter>
    ErrorStatus writeInternal(
        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 writeInternal(
        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>
    ErrorStatus fieldUpdateInternal(const TMsg* msgPtr, TIter from, TIter to, std::size_t size, Field& field) const
    {
        COMMS_ASSERT(from <= to);
        auto len = static_cast<std::size_t>(std::distance(from, to));
        auto& thisObj = BaseImpl::thisLayer();
        if (msgPtr != nullptr) {
            COMMS_ASSERT(len == (size - thisObj.doFieldLength(*msgPtr)));
        }
        else {
            COMMS_ASSERT(len == (size - Field::maxLength()));
        }
        auto remSize = size - len;
 
        bool checksumValid = false;
        auto checksum =
            thisObj.calculateSyncSuffix(
                msgPtr,
                from,
                len,
                checksumValid);
 
        if (!checksumValid) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        thisObj.prepareFieldForWrite(checksum, msgPtr, field);
        return thisObj.doWriteField(msgPtr, field, to, remSize);
    }
 
    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());
    }
 
    static_assert(!(hasVerifyBeforeRead() && hasSeekField()),
        "Usage of both comms::option::def::FrameLayerVerifyBeforeRead and comms::option::def::FrameLayerSeekField at the same time are not allowed");
};
 
namespace details
{
template <typename T>
struct SyncSuffixLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename TField, typename TNextLayer, typename... TOptions>
struct SyncSuffixLayerCheckHelper<SyncSuffixLayer<TField, TNextLayer, TOptions...> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isSyncSuffixLayer()
{
    return details::SyncSuffixLayerCheckHelper<T>::Value;
}
 
}  // namespace frame
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP