delegate.h

Go to the documentation of this file.

#ifndef NNGN_UTILS_DELEGATE_H
#define NNGN_UTILS_DELEGATE_H
 
#include <functional>
#include <tuple>
#include <utility>
 
#include "concepts/fundamental.h"
#include "utils.h"
 
namespace nngn {
 
template<function_pointer auto F>
class delegate_fn : std::integral_constant<decltype(F), F> {
    using value_type = decltype(F);
    using base = std::integral_constant<value_type, F>;
    template<typename ...Ts>
    static constexpr bool invocable = std::is_invocable_v<value_type, Ts...>;
public:
    using base::operator value_type;
    template<typename ...Ts>
    decltype(auto) operator()(Ts &&...ts) requires(invocable<Ts...>) {
        return std::invoke(F, FWD(ts)...);
    }
    decltype(auto) operator()(Ts &&...ts) requires(invocable<Ts...>) {…}
};
class delegate_fn : std::integral_constant<decltype(F), F> {…};
 
template<typename F, typename ...Args>
class delegate : private F {
    static constexpr bool has_args = sizeof...(Args);
    [[no_unique_address]] std::tuple<Args...> args = {};
public:
    NNGN_MOVE_ONLY(delegate)
    delegate(void) requires(has_args) = default;
    ~delegate(void) = default;
    explicit delegate(Args ...a) : F{}, args(std::move(a)...) {}
    explicit delegate(F f) requires(has_args) : F{std::move(f)} {}
    delegate(F f, Args ...a) : F{std::move(f)}, args(std::move(a)...) {}
    decltype(auto) operator()()
        { return std::apply(static_cast<F&>(*this), this->args); }
    decltype(auto) operator()() {…}
    template<size_t n>
    decltype(auto) arg() const { return std::get<n>(this->args); }
    template<size_t n>
    decltype(auto) arg() { return std::get<n>(this->args); }
};
class delegate : private F {…};
 
}
 
#endif