signal.h

#pragma once
#include "gaia/config/config.h"
 
#include <tuple>
#include <typeinfo>
#include <utility>
 
#include "gaia/cnt/darray.h"
#include "gaia/core/func.h"
#include "gaia/core/utility.h"
 
namespace gaia {
  namespace util {
    namespace detail {
      template <typename Ret, typename... Args>
      auto func_ptr(Ret (*)(Args...)) -> Ret (*)(Args...);
 
      template <typename Ret, typename Type, typename... Args, typename Other>
      auto func_ptr(Ret (*)(Type, Args...), Other&&) -> Ret (*)(Args...);
 
      template <typename Class, typename Ret, typename... Args, typename... Other>
      auto func_ptr(Ret (Class::*)(Args...), Other&&...) -> Ret (*)(Args...);
 
      template <typename Class, typename Ret, typename... Args, typename... Other>
      auto func_ptr(Ret (Class::*)(Args...) const, Other&&...) -> Ret (*)(Args...);
 
      template <typename Class, typename Type, typename... Other>
      auto func_ptr(Type Class::*, Other&&...) -> Type (*)();
 
      template <typename... Type>
      using func_ptr_t = decltype(detail::func_ptr(std::declval<Type>()...));
 
      template <typename... Class, typename Ret, typename... Args>
      GAIA_NODISCARD constexpr auto index_sequence_for(Ret (*)(Args...)) {
        return std::index_sequence_for<Class..., Args...>{};
      }
 
      // Wraps a function or a member of a specified type
      template <auto>
      struct connect_arg_t {};
      // Function wrapper
      template <auto Func>
      inline constexpr connect_arg_t<Func> connect_arg{};
    } // namespace detail
 
    template <typename>
    class delegate;
    template <typename Function>
    class signal;
    template <typename Function>
    class sink;
 
    //------------------------------------------------------------------------------
    // delegate
    //------------------------------------------------------------------------------
 
    template <typename Ret, typename... Args>
    class delegate<Ret(Args...)> {
      using func_type = Ret(const void*, Args...);
      template <std::size_t I>
      using arg_t = std::tuple_element_t<I, std::tuple<Args...>>;
 
      func_type* m_fnc = nullptr;
      const void* m_ctx = nullptr;
 
    public:
      delegate() noexcept = default;
 
      template <auto FuncToBind>
      delegate(detail::connect_arg_t<FuncToBind>) noexcept {
        bind<FuncToBind>();
      }
 
      template <auto FuncToBind, typename Type>
      delegate(detail::connect_arg_t<FuncToBind>, Type&& value_or_instance) noexcept {
        bind<FuncToBind>(GAIA_FWD(value_or_instance));
      }
 
      delegate(func_type* func, const void* data = nullptr) noexcept {
        bind(func, data);
      }
 
      template <auto FuncToBind>
      void bind() noexcept {
        m_ctx = nullptr;
 
        if constexpr (std::is_invocable_r_v<Ret, decltype(FuncToBind), Args...>) {
          m_fnc = [](const void*, Args... args) {
            return Ret(invoke(FuncToBind, GAIA_FWD(args)...));
          };
        } else if constexpr (std::is_member_pointer_v<decltype(FuncToBind)>) {
          m_fnc = wrap<FuncToBind>(detail::index_sequence_for<std::tuple_element_t<0, std::tuple<Args...>>>(
              detail::func_ptr_t<decltype(FuncToBind)>{}));
        } else {
          m_fnc = wrap<FuncToBind>(detail::index_sequence_for(detail::func_ptr_t<decltype(FuncToBind)>{}));
        }
      }
 
      template <auto FuncToBind, typename Type>
      void bind(Type& value_or_instance) noexcept {
        m_ctx = &value_or_instance;
 
        if constexpr (std::is_invocable_r_v<Ret, decltype(FuncToBind), Type&, Args...>) {
          using const_or_not_type = std::conditional_t<std::is_const_v<Type>, const void*, void*>;
          m_fnc = [](const void* ctx, Args... args) {
            auto pType = static_cast<Type*>(const_cast<const_or_not_type>(ctx));
            return Ret(invoke(FuncToBind, *pType, GAIA_FWD(args)...));
          };
        } else {
          m_fnc = wrap<FuncToBind>(
              value_or_instance, detail::index_sequence_for(detail::func_ptr_t<decltype(FuncToBind), Type>{}));
        }
      }
 
      template <auto FuncToBind, typename Type>
      void bind(Type* value_or_instance) noexcept {
        m_ctx = value_or_instance;
 
        if constexpr (std::is_invocable_r_v<Ret, decltype(FuncToBind), Type*, Args...>) {
          using const_or_not_type = std::conditional_t<std::is_const_v<Type>, const void*, void*>;
          m_fnc = [](const void* ctx, Args... args) {
            auto pType = static_cast<Type*>(const_cast<const_or_not_type>(ctx));
            return Ret(invoke(FuncToBind, pType, GAIA_FWD(args)...));
          };
        } else {
          m_fnc = wrap<FuncToBind>(
              value_or_instance, detail::index_sequence_for(detail::func_ptr_t<decltype(FuncToBind), Type>{}));
        }
      }
 
      void bind(func_type* function, const void* context = nullptr) noexcept {
        m_fnc = function;
        m_ctx = context;
      }
 
      void reset() noexcept {
        m_fnc = nullptr;
        m_ctx = nullptr;
      }
 
      GAIA_NODISCARD bool has_func() const noexcept {
        return m_fnc != nullptr;
      }
 
      GAIA_NODISCARD const void* instance() const noexcept {
        return m_ctx;
      }
 
      Ret operator()(Args... args) const {
        GAIA_ASSERT(m_fnc != nullptr && "Trying to call an unbound delegate!");
        return m_fnc(m_ctx, GAIA_FWD(args)...);
      }
 
      GAIA_NODISCARD explicit operator bool() const noexcept {
        // There's no way to set just m_ctx so it's enough to test m_fnc
        return m_fnc != nullptr;
      }
 
      GAIA_NODISCARD bool operator==(const delegate<Ret(Args...)>& other) const noexcept {
        return m_fnc == other.m_fnc && m_ctx == other.m_ctx;
      }
 
      GAIA_NODISCARD bool operator!=(const delegate<Ret(Args...)>& other) const noexcept {
        return !operator==(other);
      }
 
    private:
      template <auto FuncToBind, std::size_t... Index>
      GAIA_NODISCARD auto wrap(std::index_sequence<Index...>) noexcept {
        return [](const void*, Args... args) {
          [[maybe_unused]] const auto argsFwd = std::forward_as_tuple(GAIA_FWD(args)...);
          return Ret(invoke(FuncToBind, GAIA_FWD_AS(arg_t<Index>, std::get<Index>(argsFwd))...));
        };
      }
 
      template <auto FuncToBind, typename Type, std::size_t... Index>
      GAIA_NODISCARD auto wrap(Type&, std::index_sequence<Index...>) noexcept {
        using const_or_not_type = std::conditional_t<std::is_const_v<Type>, const void*, void*>;
        return [](const void* ctx, Args... args) {
          [[maybe_unused]] const auto argsFwd = std::forward_as_tuple(GAIA_FWD(args)...);
          auto pType = static_cast<Type*>(const_cast<const_or_not_type>(ctx));
          return Ret(invoke(FuncToBind, *pType, GAIA_FWD_AS(arg_t<Index>, std::get<Index>(argsFwd))...));
        };
      }
 
      template <auto FuncToBind, typename Type, std::size_t... Index>
      GAIA_NODISCARD auto wrap(Type*, std::index_sequence<Index...>) noexcept {
        using const_or_not_type = std::conditional_t<std::is_const_v<Type>, const void*, void*>;
        return [](const void* ctx, Args... args) {
          [[maybe_unused]] const auto argsFwd = std::forward_as_tuple(GAIA_FWD(args)...);
          auto pType = static_cast<Type*>(const_cast<const_or_not_type>(ctx));
          return Ret(invoke(FuncToBind, pType, GAIA_FWD_AS(arg_t<Index>, std::get<Index>(argsFwd))...));
        };
      }
    };
 
    template <typename Ret, typename... Args>
    GAIA_NODISCARD bool operator==(const delegate<Ret(Args...)>& lhs, const delegate<Ret(Args...)>& rhs) noexcept {
      return lhs == rhs;
    }
 
    template <typename Ret, typename... Args>
    GAIA_NODISCARD bool operator!=(const delegate<Ret(Args...)>& lhs, const delegate<Ret(Args...)>& rhs) noexcept {
      return lhs != rhs;
    }
 
    template <auto Func>
    delegate(detail::connect_arg_t<Func> tag) noexcept
        -> delegate<std::remove_pointer_t<detail::func_ptr_t<decltype(Func)>>>;
 
    template <auto Func, typename Type>
    delegate(detail::connect_arg_t<Func> tag, Type&& value_or_instance) noexcept
        -> delegate<std::remove_pointer_t<detail::func_ptr_t<decltype(Func), Type>>>;
 
    template <typename Ret, typename... Args>
    delegate(Ret (*func)(const void*, Args...), const void* data = nullptr) noexcept -> delegate<Ret(Args...)>;
 
    //------------------------------------------------------------------------------
    // signal
    //------------------------------------------------------------------------------
 
    template <typename Ret, typename... Args>
    class signal<Ret(Args...)>;
 
    namespace detail {
      template <typename Ret, typename... Args>
      using container = cnt::darray<delegate<Ret(Args...)>>;
    } // namespace detail
 
    template <typename Ret, typename... Args>
    class signal<Ret(Args...)> {
      friend class sink<Ret(Args...)>;
 
    private:
      detail::container<Ret, Args...> m_listeners;
 
    public:
      using size_type = typename detail::container<Ret, Args...>::size_type;
      using sink_type = sink<Ret(Args...)>;
 
      GAIA_NODISCARD size_type size() const noexcept {
        return m_listeners.size();
      }
 
      GAIA_NODISCARD bool empty() const noexcept {
        return m_listeners.empty();
      }
 
      void emit(Args... args) {
        for (auto&& call: std::as_const(m_listeners))
          call(args...);
      }
    };
 
    //------------------------------------------------------------------------------
    // Sink
    //------------------------------------------------------------------------------
 
    template <typename Ret, typename... Args>
    class sink<Ret(Args...)> {
      using signal_type = signal<Ret(Args...)>;
      using func_type = Ret(const void*, Args...);
 
      signal_type* m_s;
 
    public:
      sink(signal<Ret(Args...)>& ref) noexcept: m_s{&ref} {}
 
      void move_from(sink& other) {
        m_s->m_listeners.reserve(m_s->m_listeners.size() + other.m_s->m_listeners.size());
        for (auto&& listener: other.m_s->m_listeners)
          m_s->m_listeners.push_back(GAIA_MOV(listener));
 
        other.reset();
      }
 
      template <auto FuncToBind>
      void bind() {
        delegate<Ret(Args...)> call{};
        call.template bind<FuncToBind>();
        bind_internal(call);
      }
 
      template <auto FuncToBind, typename Type>
      void bind(Type& value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template bind<FuncToBind>(value_or_instance);
        bind_internal(call);
      }
 
      void bind(func_type* func, const void* data = nullptr) {
        if (func == nullptr && data == nullptr)
          return;
 
        delegate<Ret(Args...)> call{};
        call.bind(func, data);
        bind_internal(call);
      }
 
      template <auto FuncToUnbind>
      void unbind() {
        delegate<Ret(Args...)> call{};
        call.template bind<FuncToUnbind>();
 
        m_s->m_listeners.retain([&](const auto& l) {
          return l != call;
        });
      }
 
      template <auto FuncToUnbind, typename Type>
      void unbind(Type& value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template bind<FuncToUnbind>(value_or_instance);
 
        auto& listeners = m_s->m_listeners;
        for (uint32_t i = 0; i < listeners.size();) {
          if (listeners[i] != call) {
            ++i;
            continue;
          }
 
          core::swap_erase_unsafe(listeners, i);
        }
      }
 
      template <typename Type>
      void unbind(Type* value_or_instance) {
        if (!value_or_instance)
          return;
 
        auto& listeners = m_s->m_listeners;
        for (uint32_t i = 0; i < listeners.size();) {
          if (listeners[i].instance() != value_or_instance) {
            ++i;
            continue;
          }
 
          core::swap_erase_unsafe(listeners, i);
        }
      }
 
      template <typename Type>
      void unbind(Type& value_or_instance) {
        unbind(&value_or_instance);
      }
 
      void reset() {
        m_s->m_listeners.clear();
      }
 
    private:
      void bind_internal(const delegate<Ret(Args...)>& call) {
        if (!core::has(m_s->m_listeners, call))
          m_s->m_listeners.push_back(GAIA_MOV(call));
      }
    };
 
    template <typename Ret, typename... Args>
    sink(signal<Ret(Args...)>& ref) noexcept -> sink<Ret(Args...)>;
  } // namespace util
} // namespace gaia