MsgDispatcher.h

Go to the documentation of this file.

//
// Copyright 2019 - 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/details/MsgDispatcherOptionsParser.h"
#include "comms/dispatch.h"
#include "comms/Message.h"
#include "comms/traits.h"
#include "comms/util/type_traits.h"
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace comms
{
 
namespace details
{
 
template <class T, class R = void>
struct EnableIfHasMsgDispatcherTag { using Type = R; };
 
template <class T, class Enable = void>
struct HasMsgDispatcherTag
{
    static const bool Value = false;
};
 
template <class T>
struct HasMsgDispatcherTag<T, typename EnableIfHasMsgDispatcherTag<typename T::MsgDispatcherTag>::Type>
{
    static const bool Value = true;
};
 
template <class T>
constexpr bool hasMsgDispatcherTag()
{
    return HasMsgDispatcherTag<T>::Value;
}
 
} // namespace details
 
template <typename... TOptions>
class MsgDispatcher
{
    using NoForcingTag = comms::details::tag::Tag1<>;
 
    using ParsedOptionsInternal = details::MsgDispatcherOptionsParser<TOptions...>;
 
    using Tag =
        typename comms::util::Conditional<
            ParsedOptionsInternal::HasForcedDispatch
        >::template Type<
            typename ParsedOptionsInternal::ForcedDispatch,
            NoForcingTag
        >;
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, std::size_t idx, TMsg& msg, THandler& handler, NoForcingTag) ->
        decltype(comms::dispatchMsg<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler))
    {
        return comms::dispatchMsg<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, TMsg& msg, THandler& handler, NoForcingTag) ->
        decltype(comms::dispatchMsg<TAllMessages>(std::forward<TMsgId>(id), msg, handler))
    {
        return comms::dispatchMsg<TAllMessages>(std::forward<TMsgId>(id), msg, handler);
    }
 
    template <typename TAllMessages, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsg& msg, THandler& handler, NoForcingTag) ->
        decltype(comms::dispatchMsg<TAllMessages>(msg, handler))
    {
        return comms::dispatchMsg<TAllMessages>(msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, std::size_t idx, TMsg& msg, THandler& handler, comms::traits::dispatch::Polymorphic) ->
        decltype(comms::dispatchMsgPolymorphic<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler))
    {
        return comms::dispatchMsgPolymorphic<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, TMsg& msg, THandler& handler, comms::traits::dispatch::Polymorphic) ->
        decltype(comms::dispatchMsgPolymorphic<TAllMessages>(std::forward<TMsgId>(id), msg, handler))
    {
        return comms::dispatchMsgPolymorphic<TAllMessages>(std::forward<TMsgId>(id), msg, handler);
    }
 
    template <typename TAllMessages, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsg& msg, THandler& handler, comms::traits::dispatch::Polymorphic) ->
        decltype(comms::dispatchMsgPolymorphic<TAllMessages>(msg, handler))
    {
        return comms::dispatchMsgPolymorphic<TAllMessages>(msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, std::size_t idx, TMsg& msg, THandler& handler, comms::traits::dispatch::StaticBinSearch) ->
        decltype(comms::dispatchMsgStaticBinSearch<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler))
    {
        return comms::dispatchMsgStaticBinSearch<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, TMsg& msg, THandler& handler, comms::traits::dispatch::StaticBinSearch) ->
        decltype(comms::dispatchMsgStaticBinSearch<TAllMessages>(std::forward<TMsgId>(id), msg, handler))
    {
        return comms::dispatchMsgStaticBinSearch<TAllMessages>(std::forward<TMsgId>(id), msg, handler);
    }
 
    template <typename TAllMessages, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsg& msg, THandler& handler, comms::traits::dispatch::StaticBinSearch) ->
        decltype(comms::dispatchMsgStaticBinSearch<TAllMessages>(msg, handler))
    {
        return comms::dispatchMsgStaticBinSearch<TAllMessages>(msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, std::size_t idx, TMsg& msg, THandler& handler, comms::traits::dispatch::LinearSwitch) ->
        decltype(comms::dispatchMsgLinearSwitch<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler))
    {
        return comms::dispatchMsgLinearSwitch<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler);
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsgId&& id, TMsg& msg, THandler& handler, comms::traits::dispatch::LinearSwitch) ->
        decltype(comms::dispatchMsgLinearSwitch<TAllMessages>(std::forward<TMsgId>(id), msg, handler))
    {
        return comms::dispatchMsgLinearSwitch<TAllMessages>(std::forward<TMsgId>(id), msg, handler);
    }
 
    template <typename TAllMessages, typename TMsg, typename THandler>
    static auto dispatchInternal(TMsg& msg, THandler& handler, comms::traits::dispatch::LinearSwitch) ->
        decltype(comms::dispatchMsgLinearSwitch<TAllMessages>(msg, handler))
    {
        return comms::dispatchMsgLinearSwitch<TAllMessages>(msg, handler);
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchPolymorphicInternal(NoForcingTag)
    {
        return comms::dispatchMsgTypeIsPolymorphic<TAllMessages>();
    }
 
    template <typename TAllMessages, typename TTag>
    static constexpr bool isDispatchPolymorphicInternal(TTag)
    {
        static_assert(!std::is_same<TTag, NoForcingTag>::value, "Invalid tag dispatch");
        return std::is_same<TTag, comms::traits::dispatch::Polymorphic>::value;
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchStaticBinSearchInternal(NoForcingTag)
    {
        return comms::dispatchMsgTypeIsStaticBinSearch<TAllMessages>();
    }
 
    template <typename TAllMessages, typename TTag>
    static constexpr bool isDispatchStaticBinSearchInternal(TTag)
    {
        static_assert(!std::is_same<TTag, NoForcingTag>::value, "Invalid tag dispatch");
        return std::is_same<TTag, comms::traits::dispatch::StaticBinSearch>::value;
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchLinearSwitchInternal(NoForcingTag)
    {
        return false;
    }
 
    template <typename TAllMessages, typename TTag>
    static constexpr bool isDispatchLinearSwitchInternal(TTag)
    {
        static_assert(!std::is_same<TTag, NoForcingTag>::value, "Invalid tag dispatch");
        return std::is_same<TTag, comms::traits::dispatch::LinearSwitch>::value;
    }
 
public:
    using ParsedOptions = ParsedOptionsInternal;
 
    using MsgDispatcherTag = typename ParsedOptions::ForcedDispatch;
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatch(TMsgId&& id, std::size_t idx, TMsg& msg, THandler& handler) ->
        decltype(dispatchInternal<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler, Tag()))
    {
        return dispatchInternal<TAllMessages>(std::forward<TMsgId>(id), idx, msg, handler, Tag());
    }
 
    template <typename TAllMessages, typename TMsgId, typename TMsg, typename THandler>
    static auto dispatch(TMsgId&& id, TMsg&& msg, THandler&& handler) ->
        decltype(dispatchInternal<TAllMessages>(std::forward<TMsgId>(id), msg, handler, Tag()))
    {
        return dispatchInternal<TAllMessages>(std::forward<TMsgId>(id), msg, handler, Tag());
    }
 
    template <typename TAllMessages, typename TMsg, typename THandler>
    static auto dispatch(TMsg&& msg, THandler&& handler) ->
        decltype(dispatchInternal<TAllMessages>(msg, handler, Tag()))
    {
        return dispatchInternal<TAllMessages>(msg, handler, Tag());
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchPolymorphic()
    {
        return isDispatchPolymorphicInternal<TAllMessages>(Tag());
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchStaticBinSearch()
    {
        return isDispatchStaticBinSearchInternal<TAllMessages>(Tag());
    }
 
    template <typename TAllMessages>
    static constexpr bool isDispatchLinearSwitch()
    {
        return isDispatchLinearSwitchInternal<TAllMessages>(Tag());
    }
};
 
namespace details
{
 
template <typename T>
struct IsMsgDispatcher
{
    static constexpr bool Value = false;
};
 
template <typename... TOptions>
struct IsMsgDispatcher<MsgDispatcher<TOptions...> >
{
    static constexpr bool Value = true;
};
 
} // namespace details
 
template <typename T>
constexpr bool isMsgDispatcher()
{
    return
        details::IsMsgDispatcher<T>::Value ||
        details::hasMsgDispatcherTag<T>();
}
 
} // namespace comms