callback.hpp

Go to the documentation of this file.

 
#ifndef MRS_LIB_UTILITY_CALLBACK_HPP_
#define MRS_LIB_UTILITY_CALLBACK_HPP_
 
#include <atomic>
#include <concepts>
#include <functional>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <type_traits>
#include <utility>
#include <variant>
 
#include "mrs_lib/coro/task.hpp"
#include "mrs_lib/utility/meta.hpp"
#include "mrs_lib/utility/scope_cleanup.hpp"
 
namespace mrs_lib
{

  namespace coro_callback_tags
  {
    class Reentrant
    {
    public:
      explicit Reentrant() = default;
    };

    template <typename CallbackRetType = void>
    class CancelNew
    {
    public:
      explicit CancelNew(std::function<CallbackRetType()> default_factory) : default_factory_(std::move(default_factory))
      {
      }

      CallbackRetType create_value() const
      {
        return default_factory_();
      }
 
    private:
      std::function<CallbackRetType()> default_factory_;
    };

    template <>
    class CancelNew<void>
    {
    public:
      explicit CancelNew() = default;

      void create_value() const
      {
      }
    };

    template <typename F>
    CancelNew(F) -> CancelNew<std::invoke_result_t<F>>;

    class CancelNewDefault
    {
    public:
      explicit CancelNewDefault() = default;

      operator CancelNew<void>()
      {
        return CancelNew<>{};
      }

      template <typename T>
        requires std::default_initializable<T>
      operator CancelNew<T>()
      {
        return CancelNew<T>([] { return T{}; });
      }
    };
 
  } // namespace coro_callback_tags

  template <typename CallbackRetType>
  using CoroReentrantPolicyVariant = std::variant<coro_callback_tags::Reentrant, coro_callback_tags::CancelNew<CallbackRetType>>;

  template <typename...>
  class CoroCallback
  {
    static_assert(false, "Base template selected for CoroCallback");
  };
 

  template <typename CallbackRetType, typename... CallbackArgs>
  class CoroCallback<CallbackRetType(CallbackArgs...)>
  {
  private:
    using FunctionSignature = coro::Task<CallbackRetType>(CallbackArgs...);
 
  public:
    template <typename F, typename... BoundArgs>
      requires((std::is_member_function_pointer_v<F> || (std::is_pointer_v<F> && std::is_function_v<std::remove_pointer_t<F>>))
               && std::invocable<F, const std::decay_t<BoundArgs>&..., CallbackArgs...>
               && std::same_as<coro::Task<CallbackRetType>, std::invoke_result_t<F, const std::decay_t<BoundArgs>&..., CallbackArgs...>>)
    explicit CoroCallback(CoroReentrantPolicyVariant<CallbackRetType> reentrant_policy, F callback_ptr, BoundArgs&&... args)
        : func_(bind_callback(std::move(reentrant_policy), callback_ptr, std::forward<BoundArgs>(args)...))
    {
    }

    coro::Task<CallbackRetType> operator()(CallbackArgs... args) const
    {
      co_return co_await std::invoke(func_, std::forward<CallbackArgs>(args)...);
    }
 
  private:
    template <typename F>
    static std::function<FunctionSignature> wrap_callback(coro_callback_tags::Reentrant, F&& func)
    {
      return std::forward<F>(func);
    }

    template <typename F>
    static std::function<FunctionSignature> wrap_callback(coro_callback_tags::CancelNew<CallbackRetType> cancel_new_policy, F&& func)
    {
      return [running = std::make_shared<std::atomic_bool>(false), cancel_new_policy = std::move(cancel_new_policy),
              func = std::forward<F>(func)](CallbackArgs... args) -> coro::Task<CallbackRetType> {
        bool was_running = running->exchange(true);
        // !was_running <=> we set the state to running => we should start the callback
        if (!was_running)
        {
          ScopeCleanup cleanup([&] { running->store(false); });
          co_return co_await func(std::forward<CallbackArgs>(args)...);
        } else
        {
          co_return cancel_new_policy.create_value();
        }
      };
    }

    template <typename F, typename... BoundArgs>
    static std::function<FunctionSignature> bind_callback(CoroReentrantPolicyVariant<CallbackRetType> reentrant_policy, F callback_ptr, BoundArgs&&... args)
    {
      if (callback_ptr == nullptr)
      {
        throw std::logic_error("Cannot construct CoroCallback from nullptr.");
      }
 
      auto bound_callback = [callback = std::move(callback_ptr),
                             ... pre_args = std::forward<BoundArgs>(args)](CallbackArgs... args) -> coro::Task<CallbackRetType> {
        co_return co_await std::invoke(callback, pre_args..., std::forward<CallbackArgs>(args)...);
      };
 
      return std::visit(
          [&](auto&& reentrant_policy) -> std::function<FunctionSignature> {
            return wrap_callback(std::forward<decltype(reentrant_policy)>(reentrant_policy), std::move(bound_callback));
          },
          reentrant_policy);
    }
 
    std::function<FunctionSignature> func_;
  };
 
  namespace internal
  {

    template <typename...>
    struct CallbackSignature;

    template <typename Ret, typename... Params, typename... Args>
    struct CallbackSignature<Ret, meta::TypeList<Params...>, meta::TypeList<Args...>>
    {
    private:
      template <typename... InnerParams>
      using FuncSignature = Ret(InnerParams...);
 
    public:
      using type = meta::ApplyT<FuncSignature, meta::DropT<meta::TypeList<Params...>, sizeof...(Args)>>;
    };

    template <typename Ret, typename Params, typename Args>
    using CallbackSignatureT = CallbackSignature<Ret, Params, Args>::type;
 
  } // namespace internal

  template <typename R, typename... Params, typename... Args, bool Noexcept>
  CoroCallback(auto, mrs_lib::Task<R> (*)(Params...) noexcept(Noexcept), Args&&...) //
      -> CoroCallback<internal::CallbackSignatureT<R, meta::TypeList<Params...>, meta::TypeList<Args...>>>;

  template <typename C1, typename C2, typename R, typename... Params, typename... Args, bool Noexcept>
  CoroCallback(auto, mrs_lib::Task<R> (C1::*)(Params...) noexcept(Noexcept), C2, Args&&...) //
      -> CoroCallback<internal::CallbackSignatureT<R, meta::TypeList<Params...>, meta::TypeList<Args...>>>;

  template <typename C1, typename C2, typename R, typename... Params, typename... Args, bool Noexcept>
  CoroCallback(auto, mrs_lib::Task<R> (C1::*)(Params...) const noexcept(Noexcept), C2, Args&&...) //
      -> CoroCallback<internal::CallbackSignatureT<R, meta::TypeList<Params...>, meta::TypeList<Args...>>>;
 
} // namespace mrs_lib
 
#endif // MRS_LIB_UTILITY_CALLBACK_HPP_