based

Opinionated utility library

git clone git://git.dimitrijedobrota.com/based.git

commit	32dbe6106d0a67a6fea16db955e6b99b3dc587d2
parent	46ecfeefdd364d5bc73cdcfca5daf588c1d6e654
author	Dimitrije Dobrota < mail@dimitrijedobrota.com >
date	Wed, 16 Apr 2025 21:48:00 +0200

All different signature combinations

Diffstat:

M	include/based/template.hpp	\|	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ---

1 files changed, 186 insertions(+), 5 deletions(-)

diff --git a/ include/based/template.hpp b/ include/based/template.hpp

@@ -1,6 +1,5 @@

#pragma once

#include <array>

#include <cstddef>

#include <functional>

#include <type_traits>

@@ -17,18 +16,200 @@ template<typename Ret, typename... Args>

struct signature<Ret(Args...)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

};

template<typename Ret, typename Obj, typename... Args>

struct signature<Ret (Obj::*)(Args...)>

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::false_type;

using lvalref_val = std::false_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) & noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::false_type;

using lvalref_val = std::true_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) && noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::false_type;

using lvalref_val = std::false_type;

using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::false_type;

using lvalref_val = std::false_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const & noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::false_type;

using lvalref_val = std::true_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const && noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::false_type;

using lvalref_val = std::false_type;

using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, typename... Args>

struct signature<Ret (Obj::*)(Args...) const>

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) volatile noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::true_type;

using lvalref_val = std::false_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) volatile & noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::true_type;

using lvalref_val = std::true_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) volatile && noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::false_type;

using volatile_val = std::true_type;

using lvalref_val = std::false_type;

using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const volatile noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::true_type;

using lvalref_val = std::false_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const volatile & noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::true_type;

using lvalref_val = std::true_type;

using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

template<typename Ret, typename Obj, bool Ne, typename... Args>

struct signature<Ret (Obj::*)(Args...) const volatile && noexcept(Ne)>

{

using sig_type = Ret(Args...);

using arg_type = std::tuple<Args...>;

using ret_type = Ret;

using const_val = std::true_type;

using volatile_val = std::true_type;

using lvalref_val = std::false_type;

using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, Ne>;

};

/* ----- Overload Lambdas ----- */