MessageBase.h

Go to the documentation of this file.

//
// Copyright 2014 - 2025 (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/details/detect.h"
#include "comms/details/field_alias.h"
#include "comms/details/fields_access.h"
#include "comms/details/macro_common.h"
#include "comms/details/MessageImplBuilder.h"
 
namespace comms
{
 
template <typename TMessage, typename... TOptions>
class MessageBase : public details::MessageImplBuilderT<TMessage, TOptions...>
{
    using BaseImpl = details::MessageImplBuilderT<TMessage, TOptions...>;
public:
    using ImplOptions = details::MessageImplOptionsParser<TOptions...>;
 
    using MsgType = typename ImplOptions::MsgType;
 
    static constexpr bool hasStaticMsgId()
    {
        return ImplOptions::HasStaticMsgId;
    }    
 
    static constexpr std::intmax_t staticMsgId()
    {
        return ImplOptions::MsgId;
    }
 
    static constexpr bool hasFields()
    {
        return ImplOptions::HasFieldsImpl;
    }
 
    static constexpr bool hasFailOnInvalid()
    {
        return ImplOptions::HasFailOnInvalid;
    }
 
    static constexpr bool hasMsgType()
    {
        return ImplOptions::HasMsgType;
    }
 
    static constexpr bool hasPolymorphicRead()
    {
        return BaseImpl::hasRead() && (!ImplOptions::HasNoReadImpl);
    }
 
    static constexpr bool hasPolymorphicWrite()
    {
        return BaseImpl::hasWrite() && (!ImplOptions::HasNoWriteImpl);
    }    
 
    static constexpr bool hasPolymorphicValid()
    {
        return BaseImpl::hasValid() && (!ImplOptions::HasNoValidImpl);
    }
 
    static constexpr bool hasPolymorphicLength()
    {
        return BaseImpl::hasLength() && (!ImplOptions::HasNoLengthImpl);
    }
 
    static constexpr bool hasPolymorphicDispatch()
    {
        return BaseImpl::hasDispatch() && (!ImplOptions::HasNoDispatchImpl);
    }
 
    static constexpr bool hasCustomRefresh()
    {
        return ImplOptions::HasCustomRefresh;
    }    
 
    static constexpr bool hasCustomName()
    {
        return ImplOptions::HasName;
    }  
    
    static constexpr bool hasDoGetId()
    {
        return ImplOptions::HasStaticMsgId || ImplOptions::HasDoGetId;
    }        
 
#ifdef FOR_DOXYGEN_DOC_ONLY
 
    using AllFields = FieldsProvidedWithOption;
 
    AllFields& fields();
 
    const AllFields& fields() const;
 
    static constexpr bool areFieldsVersionDependent();
 
    static constexpr MsgIdParamType doGetId();
 
    template <typename TIter>
    ErrorStatus doRead(TIter& iter, std::size_t size);
 
    template <typename TIter>
    ErrorStatus doWrite(TIter& iter, std::size_t size) const;
 
    bool doValid() const;
 
    bool doRefresh() const;
 
    std::size_t doLength() const;
 
    template <std::size_t TFromIdx>
    std::size_t doLengthFrom() const;
 
    template <std::size_t TUntilIdx>
    std::size_t doLengthUntil() const;
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    std::size_t doLengthFromUntil() const;
 
    static constexpr std::size_t doMinLength();
 
    template <std::size_t TFromIdx>
    static constexpr std::size_t doMinLengthFrom();
 
    template <std::size_t TUntilIdx>
    static constexpr std::size_t doMinLengthUntil();
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    std::size_t doMinLengthFromUntil() const;
 
    static constexpr std::size_t doMaxLength();
 
    template <std::size_t TFromIdx>
    static constexpr std::size_t doMaxLengthFrom();
 
    template <std::size_t TUntilIdx>
    static constexpr std::size_t doMaxLengthUntil();
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    std::size_t doMaxLengthFromUntil() const;
 
    bool doFieldsVersionUpdate();
 
#endif // #ifdef FOR_DOXYGEN_DOC_ONLY
 
protected:
    ~MessageBase() noexcept = default;
 
#ifdef FOR_DOXYGEN_DOC_ONLY
    virtual MsgIdParamType getIdImpl() const override;
 
    virtual DispatchRetType dispatchImpl(Handler& handler) override;
 
    virtual ErrorStatus readImpl(ReadIterator& iter, std::size_t size) override;
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doReadUntil(TIter& iter, std::size_t& len);
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doReadUntilAndUpdateLen(TIter& iter, std::size_t& len);
 
    template <std::size_t TIdx, typename TIter>
    void doReadNoStatusUntil(TIter& iter);
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doReadFrom(TIter& iter, std::size_t len);
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doReadFromAndUpdateLen(TIter& iter, std::size_t& len);
 
    template <std::size_t TIdx, typename TIter>
    void doReadNoStatusFrom(TIter& iter);
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus doReadFromUntil(TIter& iter, std::size_t len);
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus doReadFromUntilAndUpdateLen(TIter& iter, std::size_t& len);
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    void doReadNoStatusFromUntil(TIter& iter);
 
    virtual ErrorStatus writeImpl(WriteIterator& iter, std::size_t size) const override;
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doWriteUntil(TIter& iter, std::size_t len) const;
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doWriteUntilAndUpdateLen(TIter& iter, std::size_t& len) const;
 
    template <std::size_t TIdx, typename TIter>
    void doWriteNoStatusUntil(TIter& iter) const;
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doWriteFrom(TIter& iter, std::size_t len) const;
 
    template <std::size_t TIdx, typename TIter>
    ErrorStatus doWriteFromAndUpdateLen(TIter& iter, std::size_t& len) const;
 
    template <std::size_t TIdx, typename TIter>
    void doWriteNoStatusFrom(TIter& iter) const;
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus doWriteFromUntil(TIter& iter, std::size_t len) const;
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus doWriteFromUntilAndUpdateLen(TIter& iter, std::size_t& len) const;
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    void doWriteNoStatusFromUntil(TIter& iter) const;
 
    virtual bool validImpl() const override;
 
    virtual std::size_t lengthImpl() const override;
 
    virtual bool refreshImpl() override;
 
    virtual const char* nameImpl() const override;
 
#endif // #ifdef FOR_DOXYGEN_DOC_ONLY
};
 
template <typename TMessage1, typename TMessage2, typename... TOptions>
bool operator==(const MessageBase<TMessage1, TOptions...>& msg1, const MessageBase<TMessage2, TOptions...>& msg2) noexcept
{
    return msg1.fields() == msg2.fields();
}
 
template <typename TMessage1, typename TMessage2, typename... TOptions>
bool operator!=(const MessageBase<TMessage1, TOptions...>& msg1, const MessageBase<TMessage2, TOptions...>& msg2) noexcept
{
    return !(msg1 == msg2);
}
 
template <typename TMessage, typename... TOptions>
inline
MessageBase<TMessage, TOptions...>& toMessageBase(MessageBase<TMessage, TOptions...>& msg)
{
    return msg;
}
 
template <typename TMessage, typename... TOptions>
inline
const MessageBase<TMessage, TOptions...>& toMessageBase(
    const MessageBase<TMessage, TOptions...>& msg)
{
    return msg;
}
 
template <typename T>
constexpr bool isMessageBase()
{
    return details::hasImplOptions<T>();
}
 
}  // namespace comms
 
#define COMMS_MSG_FIELDS_ACCESS(...) \
    COMMS_EXPAND(COMMS_DEFINE_FIELD_ENUM(__VA_ARGS__)) \
    COMMS_MSG_FIELDS_ACCESS_FUNC { \
        auto& val = comms::toMessageBase(*this).fields(); \
        using AllFieldsTuple = typename std::decay<decltype(val)>::type; \
        static_assert(std::tuple_size<AllFieldsTuple>::value == FieldIdx_numOfValues, \
            "Invalid number of names for fields tuple"); \
        return val; \
    } \
    COMMS_MSG_FIELDS_ACCESS_CONST_FUNC { \
        auto& val = comms::toMessageBase(*this).fields(); \
        using AllFieldsTuple =  typename std::decay<decltype(val)>::type; \
        static_assert(std::tuple_size<AllFieldsTuple>::value == FieldIdx_numOfValues, \
            "Invalid number of names for fields tuple"); \
        return val; \
    } \
    COMMS_EXPAND(COMMS_DO_FIELD_ACC_FUNC(AllFields, fields(), __VA_ARGS__))
 
#define COMMS_MSG_FIELDS_NAMES(...) \
    COMMS_EXPAND(COMMS_MSG_FIELDS_ACCESS(__VA_ARGS__)) \
    COMMS_EXPAND(COMMS_DO_FIELD_TYPEDEF(typename Base::AllFields, Field_, FieldIdx_, __VA_ARGS__))
 
#define COMMS_MSG_FIELD_ALIAS_ACCESS(f_, ...) COMMS_DO_ALIAS(field_, f_, __VA_ARGS__)
 
#define COMMS_MSG_FIELD_ALIAS(f_, ...) \
    COMMS_EXPAND(COMMS_MSG_FIELD_ALIAS_ACCESS(f_, __VA_ARGS__)) \
    COMMS_EXPAND(COMMS_DO_ALIAS_TYPEDEF(Field_, f_, __VA_ARGS__))