SyncPrefixLayer.h

Go to the documentation of this file.

//
// Copyright 2015 - 2024 (C). Alex Robenko. All rights reserved.
//
// 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/protocol/details/ProtocolLayerBase.h"
#include "comms/protocol/details/SyncPrefixLayerOptionsParser.h"
#include "comms/protocol/details/ProtocolLayerExtendingClassHelper.h"
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4189) // Disable erroneous initialized but not referenced variable warning
 
namespace comms
{
 
namespace protocol
{
 
template <typename TField, typename TNextLayer, typename... TOptions>
class SyncPrefixLayer : public
        details::ProtocolLayerBase<
            TField,
            TNextLayer,
            details::ProtocolLayerExtendingClassT<
                SyncPrefixLayer<TField, TNextLayer, TOptions...>,
                details::SyncPrefixLayerOptionsParser<TOptions...>
            >            
        >
{
    using BaseImpl =
        details::ProtocolLayerBase<
            TField,
            TNextLayer,
            details::ProtocolLayerExtendingClassT<
                SyncPrefixLayer<TField, TNextLayer, TOptions...>,
                details::SyncPrefixLayerOptionsParser<TOptions...>
            >            
        >;
 
    using ParsedOptionsInternal = details::SyncPrefixLayerOptionsParser<TOptions...>;
 
public:
    using Field = typename BaseImpl::Field;
 
    using ExtendingClass = typename ParsedOptionsInternal::ExtendingClass;
 
    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)
    {
        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 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();
    }    
 
    static void prepareFieldForWrite(Field& field)
    {
        static_cast<void>(field);
    }
};
 
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 protocol
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP