ChecksumPrefixLayer.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/field/IntValue.h"
#include "comms/frame/details/ChecksumLayerOptionsParser.h"
#include "comms/frame/details/ChecksumPrefixLayerBase.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 TCalc, typename TNextLayer, typename... TOptions>
class ChecksumPrefixLayer : public comms::frame::details::ChecksumPrefixLayerBase<TField, TCalc, TNextLayer, TOptions...>
{
    using BaseImpl = comms::frame::details::ChecksumPrefixLayerBase<TField, TCalc, TNextLayer, TOptions...>;
    using ParsedOptionsInternal = details::ChecksumLayerOptionsParser<TOptions...>;
 
public:
 
    using Field = typename BaseImpl::Field;
 
    using ChecksumCalc = TCalc;
 
    ChecksumPrefixLayer() = default;
 
    ChecksumPrefixLayer(const ChecksumPrefixLayer&) = default;
 
    ChecksumPrefixLayer(ChecksumPrefixLayer&&) = default;
 
    ~ChecksumPrefixLayer() noexcept = default;
 
    ChecksumPrefixLayer& operator=(const ChecksumPrefixLayer&) = default;
 
    ChecksumPrefixLayer& operator=(ChecksumPrefixLayer&&) = default;
 
    static constexpr bool hasExtendingClass()
    {
        return ParsedOptionsInternal::HasExtendingClass;
    }
 
    static constexpr bool hasVerifyBeforeRead()
    {
        return ParsedOptionsInternal::HasVerifyBeforeRead;
    }
 
    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;
        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* msgPtr = BaseImpl::toMsgPtr(msg);
        auto& thisObj = BaseImpl::thisLayer();
        auto beforeFieldReadIter = iter;
        auto checksumEs = thisObj.readField(msgPtr, field, iter, size);
        if (checksumEs == ErrorStatus::NotEnoughData) {
            BaseImpl::updateMissingSize(field, size, extraValues...);
        }
 
        if (checksumEs != ErrorStatus::Success) {
            return checksumEs;
        }
 
        using VerifyTag =
            typename comms::util::LazyShallowConditional<
                ParsedOptionsInternal::HasVerifyBeforeRead
            >::template Type<
                VerifyBeforeReadTag,
                VerifyAfterReadTag
            >;
 
        auto fieldLen = static_cast<std::size_t>(std::distance(beforeFieldReadIter, iter));
        return
            readInternal(
                field,
                msg,
                iter,
                size - fieldLen,
                std::forward<TNextLayerReader>(nextLayerReader),
                VerifyTag(),
                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
    {
        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());
    }
 
    template <typename TIter, typename TNextLayerUpdater>
    comms::ErrorStatus doUpdate(
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater) const
    {
        auto checksumIter = iter;
        std::advance(iter, Field::maxLength());
 
        auto fromIter = iter;
        auto es = nextLayerUpdater.update(iter, size - Field::maxLength());
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        using MsgPtr = typename BaseImpl::MsgPtr;
        static_assert(
            !std::is_void<MsgPtr>::value,
            "Please use update() overload that accepts message object as its first parameter");
 
        auto* msgPtr = static_cast<typename MsgPtr::element_type*>(nullptr);
        return fieldUpdateInternal(msgPtr, checksumIter, fromIter, iter, size, field);
    }
 
    template <typename TMsg, typename TIter, typename TNextLayerUpdater>
    comms::ErrorStatus doUpdate(
        const TMsg& msg,
        Field& field,
        TIter& iter,
        std::size_t size,
        TNextLayerUpdater&& nextLayerUpdater) const
    {
        auto& thisObj = BaseImpl::thisLayer();
        auto checksumIter = iter;
        auto fieldLen = thisObj.doFieldLength(msg);
        std::advance(iter, fieldLen);
 
        auto fromIter = iter;
        auto es = nextLayerUpdater.update(msg, iter, size - fieldLen);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        return fieldUpdateInternal(&msg, checksumIter, fromIter, iter, size, field);
    }
 
protected:
    template <typename TMsg, typename TIter>
    comms::ErrorStatus readField(const TMsg* msgPtr, Field& field, TIter& iter, std::size_t len)
    {
        return BaseImpl::thisLayer().doReadField(msgPtr, field, iter, len);
    }
 
    template <typename TMsg, typename TIter>
    comms::ErrorStatus writeField(const TMsg* msgPtr, const Field& field, TIter& iter, std::size_t len) const
    {
        return BaseImpl::thisLayer().doWriteField(msgPtr, field, iter, len);
    }
 
    template <typename TMsg, typename TIter>
    static auto calculateChecksum(const TMsg* msg, TIter& iter, std::size_t len, bool& checksumValid) -> decltype(TCalc()(iter, len))
    {
        static_cast<void>(msg);
        checksumValid = true;
        return TCalc()(iter, len);
    }
 
    static auto getChecksumFromField(const Field& field) -> decltype(field.getValue())
    {
        return field.getValue();
    }
 
    template <typename TChecksum, typename TMsg>
    static void prepareFieldForWrite(TChecksum checksum, const TMsg* msg, Field& field)
    {
        static_cast<void>(msg);
        field.setValue(checksum);
    }
 
private:
 
    template <typename... TParams>
    using VerifyBeforeReadTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using VerifyAfterReadTag = comms::details::tag::Tag2<>;
 
    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& thisObj = BaseImpl::thisLayer();
        auto* msgPtr = BaseImpl::toMsgPtr(msg);
 
        bool checksumValid = false;
        auto checksum =
            thisObj.calculateChecksum(
                msgPtr,
                fromIter,
                size,
                checksumValid);
 
        if (!checksumValid) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        auto expectedValue = thisObj.getChecksumFromField(field);
        if (expectedValue != static_cast<decltype(expectedValue)>(checksum)) {
            BaseImpl::resetMsg(msg);
            return ErrorStatus::ProtocolError;
        }
 
        return nextLayerReader.read(msg, iter, size, extraValues...);
    }
 
    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* msgPtr = BaseImpl::toMsgPtr(msg);
        auto& thisObj = BaseImpl::thisLayer();
        auto len = static_cast<std::size_t>(std::distance(fromIter, iter));
        bool checksumValid = false;
        auto checksum =
            thisObj.calculateChecksum(
                msgPtr,
                fromIter,
                len,
                checksumValid);
 
        if (!checksumValid) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        auto expectedValue = thisObj.getChecksumFromField(field);
        if (expectedValue != static_cast<decltype(expectedValue)>(checksum)) {
            BaseImpl::resetMsg(msg);
            return ErrorStatus::ProtocolError;
        }
 
        return es;
    }
 
    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& thisObj = BaseImpl::thisLayer();
        auto checksumIter = iter;
        thisObj.prepareFieldForWrite(0U, &msg, field);
        auto es = thisObj.writeField(&msg, field, iter, size);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        auto checksumLen =
            static_cast<std::size_t>(std::distance(checksumIter, iter));
 
        auto fromIter = iter;
        es = nextLayerWriter.write(msg, iter, size - checksumLen);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        COMMS_ASSERT(fromIter <= iter);
        auto len = static_cast<std::size_t>(std::distance(fromIter, iter));
 
        bool checksumValid = false;
        auto checksum =
            thisObj.calculateChecksum(
                &msg,
                fromIter,
                len,
                checksumValid);
 
        if (!checksumValid) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        thisObj.prepareFieldForWrite(checksum, &msg, field);
        auto checksumEs = thisObj.writeField(&msg, field, checksumIter, checksumLen);
        static_cast<void>(checksumEs);
        COMMS_ASSERT(checksumEs == comms::ErrorStatus::Success);
        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();
        thisObj.prepareFieldForWrite(0U, &msg, field);
        auto es = thisObj.writeField(&msg, field, iter, size);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        auto fieldLen = thisObj.doFieldLength(msg);
        es = nextLayerWriter.write(msg, iter, size - fieldLen);
        if (es != comms::ErrorStatus::Success) {
            return es;
        }
 
        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 checksumIter,
        TIter from,
        TIter to,
        std::size_t size,
        Field& field) const
    {
        static_cast<void>(size);
        COMMS_ASSERT(from <= to);
        auto& thisObj = BaseImpl::thisLayer();
        auto len = static_cast<std::size_t>(std::distance(from, to));
        auto fieldLen = Field::maxLength();
        if (msgPtr != nullptr) {
            fieldLen = thisObj.doFieldLength(*msgPtr);
        }
        COMMS_ASSERT(len == (size - fieldLen));
 
        bool checksumValid = false;
        auto checksum =
            thisObj.calculateChecksum(
                msgPtr,
                from,
                len,
                checksumValid);
 
        if (!checksumValid) {
            return comms::ErrorStatus::ProtocolError;
        }
 
        thisObj.prepareFieldForWrite(checksum, msgPtr, field);
        return thisObj.doWriteField(msgPtr, field, checksumIter, fieldLen);
    }
};
 
namespace details
{
template <typename T>
struct ChecksumPrefixLayerCheckHelper
{
    static const bool Value = false;
};
 
template <typename TField, typename TCalc, typename TNextLayer, typename... TOptions>
struct ChecksumPrefixLayerCheckHelper<ChecksumPrefixLayer<TField, TCalc, TNextLayer, TOptions...> >
{
    static const bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isChecksumPrefixLayer()
{
    return details::ChecksumPrefixLayerCheckHelper<T>::Value;
}
 
}  // namespace frame
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP