 |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++Headers +
+ The simplest way to use CallableTraits is to include the
+ main header file:
+
+ #include<callable_traits/callable_traits.hpp>
+
+ CallableTraits interface is also broken down by trait into
+ individual header files. To use only the traits you need, include one or more
+ of the following headers, listed alphabetically:
+
+ #include<callable_traits/add_const_qualifier.hpp>
+ #include<callable_traits/add_cv_qualifiers.hpp>
+ #include<callable_traits/add_lvalue_qualifier.hpp>
+ #include<callable_traits/add_rvalue_qualifier.hpp>
+ #include<callable_traits/add_varargs.hpp>
+ #include<callable_traits/add_volatile_qualifier.hpp>
+ #include<callable_traits/apply_member_pointer.hpp>
+ #include<callable_traits/apply_return.hpp>
+ #include<callable_traits/arg_at.hpp>
+ #include<callable_traits/args.hpp>
+ #include<callable_traits/arity.hpp>
+ #include<callable_traits/bind.hpp>
+ #include<callable_traits/can_invoke.hpp>
+ #include<callable_traits/can_invoke_constexpr.hpp>
+ #include<callable_traits/function_type.hpp>
+ #include<callable_traits/has_varargs.hpp>
+ #include<callable_traits/has_void_return.hpp>
+ #include<callable_traits/is_const_qualified.hpp>
+ #include<callable_traits/is_constexpr.hpp>
+ #include<callable_traits/is_lvalue_qualified.hpp>
+ #include<callable_traits/is_reference_qualified.hpp>
+ #include<callable_traits/is_rvalue_qualified.hpp>
+ #include<callable_traits/is_unqualified.hpp>
+ #include<callable_traits/is_volatile_qualified.hpp>
+ #include<callable_traits/max_arity.hpp>
+ #include<callable_traits/min_arity.hpp>
+ #include<callable_traits/qualified_function_type.hpp>
+ #include<callable_traits/remove_const_qualifier.hpp>
+ #include<callable_traits/remove_cv_qualifiers.hpp>
+ #include<callable_traits/remove_member_pointer.hpp>
+ #include<callable_traits/remove_reference_qualifier.hpp>
+ #include<callable_traits/remove_varargs.hpp>
+ #include<callable_traits/remove_volatile_qualifier.hpp>
+ #include<callable_traits/result_of.hpp>
+
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_const_qualifier.html b/doc/html/callable_traits/ref_add_const_qualifier.html
new file mode 100644
index 0000000..1df3743
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_const_qualifier.html
@@ -0,0 +1,94 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/add_const_qualifier.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <callable_traits/add_const_qualifier.hpp> + +namespace ct = callable_traits; + +struct foo {}; + +int main() { + + { + using pmf = void(foo::*)(); + using expect = void(foo::*)() const; + using test = ct::add_const_qualifier<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_const_qualifier doesn't change anything when + // the function type is already const. + using pmf = void(foo::*)() const &&; + using expect = void(foo::*)() const &&; + using test = ct::add_const_qualifier<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + using pmf = void(foo::*)() volatile &; + using expect = void(foo::*)() const volatile &; + using test = ct::add_const_qualifier<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_const_qualifier can also be used to create "abominable" + // function types. + using f = void(); + using expect = void() const; + using test = ct::add_const_qualifier<f>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_const_qualifier has no affect on function pointers, + // function references, function objects, or member data pointers. + using f = void(*)(); + using expect = void(*)(); + using test = ct::add_const_qualifier<f>; + static_assert(std::is_same<test, expect>::value, ""); + } +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_cv_qualifiers.html b/doc/html/callable_traits/ref_add_cv_qualifiers.html
new file mode 100644
index 0000000..bfe00af
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_cv_qualifiers.html
@@ -0,0 +1,94 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/add_cv_qualifiers.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <callable_traits/add_cv_qualifiers.hpp> + +namespace ct = callable_traits; + +struct foo {}; + +int main() { + + { + using pmf = void(foo::*)(); + using expect = void(foo::*)() const volatile; + using test = ct::add_cv_qualifiers<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_cv_qualifiers doesn't change anything when + // the function type is already cv-qualified. + using pmf = void(foo::*)() const volatile &&; + using expect = void(foo::*)() const volatile &&; + using test = ct::add_cv_qualifiers<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + using pmf = void(foo::*)() volatile &; + using expect = void(foo::*)() const volatile &; + using test = ct::add_cv_qualifiers<pmf>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_cv_qualifiers can also be used to create "abominable" + // function types. + using f = void(); + using expect = void() const volatile; + using test = ct::add_cv_qualifiers<f>; + static_assert(std::is_same<test, expect>::value, ""); + } { + // add_cv_qualifiers has no affect on function pointers, + // function references, function objects, or member data pointers. + using f = void(&)(); + using expect = void(&)(); + using test = ct::add_cv_qualifiers<f>; + static_assert(std::is_same<test, expect>::value, ""); + } +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_lvalue_qualifier.html b/doc/html/callable_traits/ref_add_lvalue_qualifier.html
new file mode 100644
index 0000000..aac1ca2
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_lvalue_qualifier.html
@@ -0,0 +1,47 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/add_lvalue_qualifier.hpp>
+ TODO
+
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_rvalue_qualifier.html b/doc/html/callable_traits/ref_add_rvalue_qualifier.html
new file mode 100644
index 0000000..6d3f416
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_rvalue_qualifier.html
@@ -0,0 +1,47 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/add_rvalue_qualifier.hpp>
+ TODO
+
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_varargs.html b/doc/html/callable_traits/ref_add_varargs.html
new file mode 100644
index 0000000..588fed0
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_varargs.html
@@ -0,0 +1,47 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++add_varargs +
+ #include<callable_traits/add_varargs.hpp>
+ TODO
+
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_add_volatile_qualifier.html b/doc/html/callable_traits/ref_add_volatile_qualifier.html
new file mode 100644
index 0000000..612b9a8
--- /dev/null
+++ b/doc/html/callable_traits/ref_add_volatile_qualifier.html
@@ -0,0 +1,47 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/add_volatile_qualifier.hpp>
+ TODO
+
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_apply_member_pointer.html b/doc/html/callable_traits/ref_apply_member_pointer.html
new file mode 100644
index 0000000..07a64c7
--- /dev/null
+++ b/doc/html/callable_traits/ref_apply_member_pointer.html
@@ -0,0 +1,77 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/apply_member_pointer.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <callable_traits/apply_member_pointer.hpp> + +namespace ct = callable_traits; + +struct foo; +struct bar; + +using expect = int(foo::*)(int); + +template<typename T> +void test() { + using U = ct::apply_member_pointer<T, foo>; + static_assert(std::is_same<expect, U>{}, ""); +} + +int main() { + test<int(int)>(); + test<int(*)(int)>(); + test<int(*&)(int)>(); + test<int(* const)(int)>(); + test<int(&)(int)>(); + test<int(foo::*)(int)>(); + test<int(bar::*)(int)>(); +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_apply_return.html b/doc/html/callable_traits/ref_apply_return.html
new file mode 100644
index 0000000..bef6091
--- /dev/null
+++ b/doc/html/callable_traits/ref_apply_return.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++apply_return +
+ #include<callable_traits/apply_return.hpp>
+ TODO
+
+ + Example +
++ [apply_return] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_arg_at.html b/doc/html/callable_traits/ref_arg_at.html
new file mode 100644
index 0000000..9754235
--- /dev/null
+++ b/doc/html/callable_traits/ref_arg_at.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_args.html b/doc/html/callable_traits/ref_args.html
new file mode 100644
index 0000000..6e22017
--- /dev/null
+++ b/doc/html/callable_traits/ref_args.html
@@ -0,0 +1,102 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++args +
+ #include<callable_traits/args.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <memory> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +// all callable types in this example use these parameter types +using expect = std::tuple<int, float&, const char*>; + +template<typename T> +void test(){ + // this example shows how callable_traits::args + // bevaves consistently for many different types + using args = ct::args<T>; + static_assert(std::is_same<expect, args>{}, ""); +} + +int main() { + + + auto lamda = [](int, float&, const char*){}; + using lam = decltype(lamda); + test<lam>(); + test<lam*>(); + test<lam&>(); + test<lam&&>(); + test<lam const &>(); + + struct foo; + using pmf = void(foo::*)(int, float&, const char*); + test<pmf>(); + test<pmf&>(); + test<pmf&&>(); + test<pmf const &>(); + + using function_ptr = void(*)(int, float&, const char*); + test<function_ptr>(); + test<function_ptr&>(); + test<function_ptr&&>(); + test<function_ptr const &>(); + + using function_ref = void(&)(int, float&, const char*); + test<function_ref>(); + + using function = void(int, float&, const char*); + test<function>(); + + using abominable = void(int, float&, const char*) const; + test<abominable>(); +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_arity.html b/doc/html/callable_traits/ref_arity.html
new file mode 100644
index 0000000..c519166
--- /dev/null
+++ b/doc/html/callable_traits/ref_arity.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_bind.html b/doc/html/callable_traits/ref_bind.html
new file mode 100644
index 0000000..771247c
--- /dev/null
+++ b/doc/html/callable_traits/ref_bind.html
@@ -0,0 +1,177 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++bind +
+ #include<callable_traits/bind.hpp>
+ TODO
+
+ + Example + 1 +
+/* In this example, the last _1 placeholder in the bind +expression forces all other _1 slots to accept ScaryMonster, +because ScaryMonster is the narrowest of all _1 parameters. */ + +#include <cassert> +#include <type_traits> +#include <functional> +#include <tuple> +#include <callable_traits/callable_traits.hpp> + +struct Vampire {}; +struct Robot {}; +struct Animal {}; +struct Dog : Animal {}; +struct Poodle : Dog {}; +struct ScaryMonster : Vampire, Robot, Poodle {}; + +auto vampire_to_robot(Vampire) { + return Robot{}; +} + +auto robot_to_dog = [](Robot){ + return Dog{}; +}; + +struct converter { + auto dog_to_vampire(Dog) { + return Vampire{}; + } +}; + +int take_all(Vampire, Robot, Animal, Dog, Poodle, ScaryMonster) { + return 0; +} + +using namespace std::placeholders; +namespace ct = callable_traits; + +int main() { + + auto b = + ct::bind(&take_all, + ct::bind(&converter::dog_to_vampire, + converter{}, + ct::bind(robot_to_dog, + ct::bind(&vampire_to_robot, _1) + ) + ), + ct::bind(&vampire_to_robot, _3), + Animal{}, + _1, + _2, + _1 + ); + + { + using args = ct::args<decltype(b)>; + using expect = std::tuple<ScaryMonster, Poodle, Vampire>; + static_assert(std::is_same<args, expect>::value, ""); + } { + using type = ct::function_type<decltype(b)>; + using expect = int(ScaryMonster, Poodle, Vampire); + static_assert(std::is_same<type, expect>::value, ""); + } + + assert(b(ScaryMonster{}, Poodle{}, Vampire{}) == 0); + + return 0; +} ++
+ + Example + 2 +
+#include <cassert> +#include <type_traits> +#include <functional> +#include <tuple> +#include <callable_traits/callable_traits.hpp> + +struct Vampire {}; +struct Robot {}; +struct Animal {}; +struct Dog : Animal {}; +struct Poodle : Dog {}; +struct ScaryMonster : Poodle, Robot, Vampire {}; + +auto take_vampire(const Vampire&) { return 0; } +auto take_robot(const Robot&) { return 0; } +auto take_dog(const Dog&) { return 0; } +auto take_scary_monster(const ScaryMonster&) { return 0; } + +int f(int, int, int, int) { return 0; } + +using namespace std::placeholders; +namespace ct = callable_traits; + +int main() { + + ScaryMonster monster{}; + + auto b = ct::bind( + &f, + ct::bind(&take_vampire, _1), + ct::bind(&take_robot, _1), + ct::bind(&take_dog, _1), + ct::bind(&take_scary_monster, _1) + ); + + { + using args = ct::args<decltype(b)>; + using expect = std::tuple<const ScaryMonster&>; + static_assert(std::is_same<args, expect>::value, ""); + } { + using type = ct::function_type<decltype(b)>; + using expect = int(const ScaryMonster&); + static_assert(std::is_same<type, expect>::value, ""); + } + + assert(b(monster) == 0); + + return 0; +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_can_invoke.html b/doc/html/callable_traits/ref_can_invoke.html
new file mode 100644
index 0000000..befe495
--- /dev/null
+++ b/doc/html/callable_traits/ref_can_invoke.html
@@ -0,0 +1,194 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++can_invoke +
+ #include<callable_traits/can_invoke.hpp>
+ TODO
+
+ + Example - + Function Object +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +// For the purpose of this example, 'Bad' represents +// any non-arithmetic type +struct Bad {}; +Bad bad{}; + +// non-generic callables, such as `subtract` below, +// don't have any "gotchas" when passed to +// callable_traits::can_invoke. +auto subtract = [](int x, int y) { + return x + y; +}; + +static_assert(!ct::can_invoke(subtract), ""); +static_assert(!ct::can_invoke(subtract, 1), ""); +static_assert(ct::can_invoke(subtract, 1, 2), ""); // <-- success +static_assert(!ct::can_invoke(subtract, 1, 2, 3), ""); +static_assert(!ct::can_invoke(subtract, bad, bad), ""); + +// Generic function objects (such as `add` and `multiply` below) +// must be SFINAE-friendly in order for failing can_invoke calls +// to actually compile. This applies to both generic lambdas and +// templated function objects. Note: MSVC does not compile this +// source code file because of the trailing return type below (MSVC +// is non-conforming in this respect) + +auto add = [](auto x, auto y) -> decltype(x + y) { + return x + y; // ^^^^^^^^^^^^^^^^^^ explicit return type allows SFINAE +}; + +template<int I> +using int_c = std::integral_constant<int, I>; + +static_assert(!ct::can_invoke(add), ""); +static_assert(!ct::can_invoke(add, 1), ""); +static_assert(ct::can_invoke(add, 1, 2), ""); // <-- success +static_assert(!ct::can_invoke(add, 1, 2, 3), ""); +static_assert(!ct::can_invoke(add, bad, bad), ""); + +// 'multiply' isn't SFINAE-safe, because the return type depends +// on an expression in the body. However, it still works if we +// only try to call can_invoke with arguments where x * y is +// a valid expression. +auto multiply = [](auto x, auto y) { + return x * y; +}; + + +static_assert(!ct::can_invoke(multiply), ""); +static_assert(!ct::can_invoke(multiply, 1), ""); +static_assert(ct::can_invoke(multiply, 1, 2), ""); // <-- success +static_assert(!ct::can_invoke(multiply, 1, 2, 3), ""); +//static_assert(!ct::can_invoke(multiply, bad, bad), ""); + +// The last, commented static_assert above would fail compile, +// because the call cannot be SFINAE'd away. Error message in Clang: +// "invalid operands to binary expression ('Bad' and 'Bad')" + +int main() {} ++
+ + Example + - Member Function Pointer +
+#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +struct foo { + int bar(int) const { + return 1; + } +}; + +// can_invoke returns std::true_type here because the +// arguments are valid to INVOKE +static_assert(ct::can_invoke(&foo::bar, foo{}, 0), ""); + +// can_invoke returns std::false_type here because the +// arguments are NOT valid to INVOKE - foo::bar can't be +// invoked like a void member function. +static_assert(!ct::can_invoke(&foo::bar, foo{}), ""); + +int main() {} ++
+ + Example - + Function Pointer +
+#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +int foo(int&& i) { + return i; +} + +// can_invoke returns std::true_type here because the +// arguments are valid to INVOKE +static_assert(ct::can_invoke(&foo, 0), ""); + +int i = 0; + +// can_invoke returns std::false_type here because the +// arguments are NOT valid to INVOKE - foo expects an +// rvalue reference, not an lvalue reference. +static_assert(!ct::can_invoke(&foo, i), ""); + +int main() {} ++
+ + Example + - Function Reference +
+#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +int foo(int&& i) { + return i; +} + +// can_invoke returns std::true_type here because the +// arguments are valid to INVOKE +static_assert(ct::can_invoke(foo, 0), ""); + +int i = 0; + +// can_invoke returns std::false_type here because the +// arguments are NOT valid to INVOKE - foo expects an +// rvalue reference, not an lvalue reference. +static_assert(!ct::can_invoke(foo, i), ""); + +int main() {} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_can_invoke_constexpr.html b/doc/html/callable_traits/ref_can_invoke_constexpr.html
new file mode 100644
index 0000000..3d06066
--- /dev/null
+++ b/doc/html/callable_traits/ref_can_invoke_constexpr.html
@@ -0,0 +1,186 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/can_invoke_constexpr.hpp>
+ TODO
+
+ + Example + - Function Object +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +// NOTE: Due to non-compliance in MSVC, can_invoke_constexpr +// always return std::false_type on that compiler, which causes +// the static asserts below to fail. + +namespace ct = callable_traits; + +using T1 = std::integral_constant<int, 3>; +using T2 = std::integral_constant<int, 7>; + +//'subtract' is a constexpr function object that +// subtracts std::integral_constant types. +struct subtract { + + // To compile failing cases of can_invoke_constexpr, the function object + // must have a SFINAE-safe signature. In this case, 'subtract' is made + // SFINAE-safe with an explicit, trailing return type. + template<typename T1, typename T2> + constexpr auto operator()(T1, T2) const -> decltype(T1::value - T2::value) { + return T1::value - T2::value; + } +}; + +// can_invoke_constexpr returns std::true_type in the first case, because +// INVOKE(subtract{}, T1{}, T2{}) is a valid expression, AND 'subtract{}' is +// a constexpr function object. +static_assert(ct::can_invoke_constexpr(subtract{}, T1{}, T2{}), ""); +static_assert(!ct::can_invoke_constexpr(subtract{}, 3, 7), ""); +static_assert(!ct::can_invoke_constexpr(subtract{}, T1{}), ""); + +//this is a function object, but is NOT constexpr +struct add { + template<typename T1, typename T2> + auto operator()(T1, T2) const -> decltype(T1::value + T2::value) { + return T1::value + T2::value; + } +}; + +// Even though INVOKE(add{}, T1{}, T2{}) is valid, the respective +// can_invoke_constexpr call returns std::false_type because 'add{}' +// is not a constexpr function object. +static_assert(!ct::can_invoke_constexpr(add{}, T1{}, T2{}), ""); +static_assert(!ct::can_invoke_constexpr(add{}, 3, 7), ""); + + +// This last section demonstrates that can_invoke_constexpr will always +// return std::false_type when any of the arguments do not decay to literal +// types. (see http://en.cppreference.com/w/cpp/concept/LiteralType). +// Even though 'S' below is a constexpr function object, it is incompatible +// with can_invoke_constexpr because 'S' isn't a literal type. Additionally, +// all arguments must be default constructible. + +struct S { + S() = delete; + S(int){}; + constexpr int operator()() const { return 0; } +}; + +S s{0}; +static_assert(!ct::can_invoke_constexpr(s), ""); + + +int main() {} ++
+ + Example + - Member Function Pointer +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +// NOTE: Due to non-compliance in MSVC, can_invoke_constexpr +// always returns std::false_type on that compiler, which +// causes a static assert below to fail. + +namespace ct = callable_traits; + +struct foo { + constexpr int bar(int) const { + return 1; + } +}; + +using pmf_constant = std::integral_constant<decltype(&foo::bar), &foo::bar>; + +// can_invoke_constexpr returns true here because foo::bar +// is constexpr, and the arguments are valid to INVOKE +static_assert(ct::can_invoke_constexpr(pmf_constant{}, foo{}, 0), ""); + +// can_invoke_constexpr returns false here because even though +// foo::bar is constexpr, the arguments do not obey INVOKE rules +static_assert(!ct::can_invoke_constexpr(pmf_constant{}, foo{}), ""); + +int main() {} ++
+ + Example + - Function Pointer +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +constexpr int seven(int) { + return 7; +} + +using seven_c = std::integral_constant<decltype(&seven), &seven>; + +// The first call to can_invoke_constexpr returns std::true_type +// because `seven` is a constexpr function, and valid INVOKE arguments +// are passed. The second call to can_invoke_constexpr returns +// std::false_type, because the arguments are not valid to INVOKE +static_assert(ct::can_invoke_constexpr(seven_c{}, 0), ""); +static_assert(!ct::can_invoke_constexpr(seven_c{}, nullptr), ""); + +int eight(int) { + return 7; +} + +using eight_c = std::integral_constant<decltype(&eight), &eight>; + +// `eight` is NOT a constexpr function, so can_invoke_constexpr +// returns `std::false_type` even for valid INVOKE arguments. +static_assert(!ct::can_invoke_constexpr(eight_c{}, 0), ""); +static_assert(!ct::can_invoke_constexpr(eight_c{}, nullptr), ""); + +int main() {} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_function_type.html b/doc/html/callable_traits/ref_function_type.html
new file mode 100644
index 0000000..77e4abf
--- /dev/null
+++ b/doc/html/callable_traits/ref_function_type.html
@@ -0,0 +1,92 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/function_type.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +template<typename T> +void test(){ + + // this example shows how callable_traits::function_type + // bevaves consistently for many different types + using type = ct::function_type<T>; + using expect = void(int, float&, const char*); + static_assert(std::is_same<expect, type>{}, ""); +} + +int main() { + + auto lamda = [](int, float&, const char*){}; + using lam = decltype(lamda); + test<lam>(); + test<lam*>(); + test<lam&>(); + test<lam&&>(); + test<lam const &>(); + + using function_ptr = void(*)(int, float&, const char*); + test<function_ptr>(); + test<function_ptr&>(); + test<function_ptr&&>(); + test<function_ptr const &>(); + + using function_ref = void(&)(int, float&, const char*); + test<function_ref>(); + + using function = void(int, float&, const char*); + test<function>(); + + using abominable = void(int, float&, const char*) const; + test<abominable>(); +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_has_varargs.html b/doc/html/callable_traits/ref_has_varargs.html
new file mode 100644
index 0000000..2151faf
--- /dev/null
+++ b/doc/html/callable_traits/ref_has_varargs.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++has_varargs +
+ #include<callable_traits/has_varargs.hpp>
+ TODO
+
+ + Example +
++ [has_varargs] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_has_void_return.html b/doc/html/callable_traits/ref_has_void_return.html
new file mode 100644
index 0000000..76f6621
--- /dev/null
+++ b/doc/html/callable_traits/ref_has_void_return.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/has_void_return.hpp>
+ TODO
+
+ + Example +
++ [has_void_return] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_const_qualified.html b/doc/html/callable_traits/ref_is_const_qualified.html
new file mode 100644
index 0000000..415fa1b
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_const_qualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_const_qualified.hpp>
+ TODO
+
+ + Example +
++ [is_const_qualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_constexpr.html b/doc/html/callable_traits/ref_is_constexpr.html
new file mode 100644
index 0000000..557f02e
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_constexpr.html
@@ -0,0 +1,174 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+
++is_constexpr +
+ #include<callable_traits/is_constexpr.hpp>
+ TODO
+
+ + Example + - Function Object +
+![[Warning]](../../../../../doc/src/images/warning.png) |
+Warning | +
|---|---|
+ When compiling in MSVC, |
#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +//this is a constexpr function object (non-templated) +struct zero { + + constexpr auto operator()() const { + return 0; + } +}; + +static_assert(ct::is_constexpr<zero>(), ""); +static_assert(ct::is_constexpr(zero{}), ""); + + + +//this is a constexpr function object (templated) +struct subtract { + + // For callable_traits::is_constexpr, generic function objects + // only need to be SFINAE-friendly if the body of the operator() + // function accesses member names besides "type" and "value". + // Unary/binary operators and constructor calls are okay to use. + template<typename T1, typename T2> + constexpr auto operator()(T1, T2) const { + return T1{} - T2{}; + } +}; + +static_assert(ct::is_constexpr<subtract>(), ""); +static_assert(ct::is_constexpr(subtract{}), ""); + + + +//this is NOT a constexpr function object +struct add { + template<typename T1, typename T2> + auto operator()(T1, T2) const { + return T1{} + T2{}; + } +}; + +static_assert(!ct::is_constexpr<add>(), ""); +static_assert(!ct::is_constexpr(add{}), ""); + +auto multiply = [](auto t1, auto t2) -> decltype(t1.value * t2.value) { + return t1.value * t2.value; +}; + +static_assert(!ct::is_constexpr<decltype(multiply)>(), ""); +static_assert(!ct::is_constexpr(multiply), ""); + + +// is_constexpr will always return std::false_type when the argument +// is either not a literal type, or is not default constructible. Below, +// divide is not default constructible, so is_constexpr returns +// std::false_type. For literal types that are default constructible, a +// constexpr default constructor is assumed. + +struct divide { + + divide() = delete; + constexpr divide(int){}; + + template<typename T1, typename T2> + constexpr auto operator()(T1, T2) const { + return T1{} / T2{}; + } +}; + +static_assert(!ct::is_constexpr<divide>(), ""); +static_assert(!ct::is_constexpr(divide{0}), ""); + +int main() {} ++
+ + Example + - Function Pointer +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +// NOTE: Due to non-compliance in MSVC, is_constexpr always +// returns std::false_type on that compiler, which causes +// the static asserts below to fail. + +namespace ct = callable_traits; + +constexpr int foo(const int&) { + return 1; +} + +int bar(const int&) { + return 1; +} + +// for is_constexpr calls, function pointers must +// be passed as std::integral_constants +using F = std::integral_constant<decltype(&foo), &foo>; +using B = std::integral_constant<decltype(&bar), &bar>; + +static_assert(ct::is_constexpr(F{}), ""); +static_assert(ct::is_constexpr<F>(), ""); +static_assert(!ct::is_constexpr(B{}), ""); +static_assert(!ct::is_constexpr<B>(), ""); + +int main() {} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_lvalue_qualified.html b/doc/html/callable_traits/ref_is_lvalue_qualified.html
new file mode 100644
index 0000000..4a69ddc
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_lvalue_qualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_lvalue_qualified.hpp>
+ TODO
+
+ + Example +
++ [is_lvalue_qualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_reference_qualified.html b/doc/html/callable_traits/ref_is_reference_qualified.html
new file mode 100644
index 0000000..91519d0
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_reference_qualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_reference_qualified.hpp>
+ TODO
+
+ + Example +
++ [is_reference_qualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_rvalue_qualified.html b/doc/html/callable_traits/ref_is_rvalue_qualified.html
new file mode 100644
index 0000000..64cd7aa
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_rvalue_qualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_rvalue_qualified.hpp>
+ TODO
+
+ + Example +
++ [is_rvalue_qualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_unqualified.html b/doc/html/callable_traits/ref_is_unqualified.html
new file mode 100644
index 0000000..63c7eaf
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_unqualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_unqualified.hpp>
+ TODO
+
+ + Example +
++ [is_unqualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_is_volatile_qualified.html b/doc/html/callable_traits/ref_is_volatile_qualified.html
new file mode 100644
index 0000000..7a3e77a
--- /dev/null
+++ b/doc/html/callable_traits/ref_is_volatile_qualified.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/is_volatile_qualified.hpp>
+ TODO
+
+ + Example +
++ [is_volatile_qualified] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_max_arity.html b/doc/html/callable_traits/ref_max_arity.html
new file mode 100644
index 0000000..280b39a
--- /dev/null
+++ b/doc/html/callable_traits/ref_max_arity.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++max_arity +
+ #include<callable_traits/max_arity.hpp>
+ TODO
+
+ + Example +
++ [max_arity] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_min_arity.html b/doc/html/callable_traits/ref_min_arity.html
new file mode 100644
index 0000000..f0f8f69
--- /dev/null
+++ b/doc/html/callable_traits/ref_min_arity.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++min_arity +
+ #include<callable_traits/min_arity.hpp>
+ TODO
+
+ + Example +
++ [min_arity] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_qualified_function_type.html b/doc/html/callable_traits/ref_qualified_function_type.html
new file mode 100644
index 0000000..c8f0a4f
--- /dev/null
+++ b/doc/html/callable_traits/ref_qualified_function_type.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/qualified_function_type.hpp>
+ TODO
+
+ + Example +
++ [qualified_function_type] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_const_qualifier.html b/doc/html/callable_traits/ref_remove_const_qualifier.html
new file mode 100644
index 0000000..b0e3459
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_const_qualifier.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_const_qualifier.hpp>
+ TODO
+
+ + Example +
++ [remove_const_qualifier] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_cv_qualifiers.html b/doc/html/callable_traits/ref_remove_cv_qualifiers.html
new file mode 100644
index 0000000..fae36c4
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_cv_qualifiers.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_cv_qualifiers.hpp>
+ TODO
+
+ + Example +
++ [remove_cv_qualifiers] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_member_pointer.html b/doc/html/callable_traits/ref_remove_member_pointer.html
new file mode 100644
index 0000000..57e77ab
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_member_pointer.html
@@ -0,0 +1,86 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_member_pointer.hpp>
+ TODO
+
+ + Example +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +struct foo; + +template<typename T, typename Expect> +void test() { + using U = ct::remove_member_pointer<T>; + static_assert(std::is_same<Expect, U>{}, ""); +} + +int main() { + + { + using T = int(foo::*)(int) const; + using expect = int(int) const; + test<T, expect>(); + } { + using T = int foo::*; + using expect = int; + test<T, expect>(); + } { + using T = int(int); + test<T, T>(); + } { + using T = int(*)(int); + test<T, T>(); + } { + using T = int(&)(int); + test<T, T>(); + } +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_reference_qualifier.html b/doc/html/callable_traits/ref_remove_reference_qualifier.html
new file mode 100644
index 0000000..0b803e9
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_reference_qualifier.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_reference_qualifier.hpp>
+ TODO
+
+ + Example +
++ [remove_reference_qualifier] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_varargs.html b/doc/html/callable_traits/ref_remove_varargs.html
new file mode 100644
index 0000000..612036e
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_varargs.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_varargs.hpp>
+ TODO
+
+ + Example +
++ [remove_varargs] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_remove_volatile_qualifier.html b/doc/html/callable_traits/ref_remove_volatile_qualifier.html
new file mode 100644
index 0000000..1d3d4b4
--- /dev/null
+++ b/doc/html/callable_traits/ref_remove_volatile_qualifier.html
@@ -0,0 +1,54 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
+
+ #include<callable_traits/remove_volatile_qualifier.hpp>
+ TODO
+
+ + Example +
++ [remove_volatile_qualifier] +
+| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/ref_result_of.html b/doc/html/callable_traits/ref_result_of.html
new file mode 100644
index 0000000..2cfe24e
--- /dev/null
+++ b/doc/html/callable_traits/ref_result_of.html
@@ -0,0 +1,77 @@
+
+
+
+
+ |
+Home | +Libraries | +People | +FAQ | +More | +
+
+
+
+
+
+
+
++result_of +
+ #include<callable_traits/result_of.hpp>
+
+ + Example +
+#include <type_traits> +#include <callable_traits/callable_traits.hpp> + +namespace ct = callable_traits; + +using expect = int; + +struct foo; + +template<typename T> +void test() { + using result = ct::result_of<T>; + static_assert(std::is_same<expect, result>{}, ""); +} + +int main() { + + test<int()>(); + test<int(*)()>(); + test<int(&)()>(); + test<int() const>(); + test<int(foo::*)() const>(); + + auto x = []() -> int { return 0; }; + + test<decltype(x)>(); +} ++
| + | + |
+
+
+
+
+
diff --git a/doc/html/callable_traits/tuto.html b/doc/html/callable_traits/tuto.html
deleted file mode 100644
index 38a3d6c..0000000
--- a/doc/html/callable_traits/tuto.html
+++ /dev/null
@@ -1,249 +0,0 @@
-
-
-
-
+ |
- -
-
-
-
-
-
-- CallableTraits contains the following type traits and metafunctions (psuedo-code): -
-
- std::integral_constant constexpr functions
-
-
-
-
-
can_invoke(T&&, - Args&&...)-
- -
-
can_invoke_constexpr(T&&, - Args&&...)-
- -
-
is_constexpr(T&&)-
- -
-
is_constexpr<T>()-
- -
-
has_varargs(T&&)-
- -
-
has_varargs<T>()-
- -
-
has_void_return(T&&)-
- -
-
has_void_return<T>()-
- -
-
arity(T&&)-
- -
-
arity<T>()-
- -
-
min_arity(T&&)-
- -
-
min_arity<T>()-
- -
-
max_arity(T&&)-
- -
-
max_arity<T>()-
- -
-
is_unqualified(T&&)-
- -
-
is_unqualified<T>()-
- -
-
is_const_qualified(T&&)-
- -
-
is_const_qualified<T>()-
- -
-
is_volatile_qualified(T&&)-
- -
-
is_volatile_qualified<T>()-
- -
-
is_cv_qualified(T&&)-
- -
-
is_cv_qualified<T>()-
- -
-
is_reference_qualified(T&&)-
- -
-
is_reference_qualified<T>()-
- -
-
is_lvalue_qualified(T&&)-
- -
-
is_lvalue_qualified<T>()-
- -
-
is_rvalue_qualified(T&&)-
- -
-
is_rvalue_qualified<T>()-
-
- Template aliases -
--
-
-
-
args<T>-
- -
-
arg_at<I, T>-
- -
-
function_type<T>-
- -
-
qualified_function_type<T>-
- -
-
result_of<T>-
- -
-
apply_return<T, R>-
- -
-
apply_member_pointer<T, C>-
- -
-
remove_member_pointer<T>-
- -
-
add_const_qualifier<T>-
- -
-
remove_const_qualifier<T>-
- -
-
add_volatile_qualifier<T>-
- -
-
remove_volatile_qualifier<T>-
- -
-
add_cv_qualifiers<T>-
- -
-
remove_cv_qualifiers<T>-
- -
-
add_lvalue_qualifier<T>-
- -
-
add_rvalue_qualifier<T>-
- -
-
remove_reference_qualifiers<T>-
- -
-
add_varargs<T>-
- -
-
remove_varargs<T>-
-
- Other -
--
-
bind(T&&, - Args&&...)-
- Note: CallableTraits currently offers no interface for the manipulation of
- calling conventions. Also, no features are currently implemented to account
- for C++17's noexcept, but will
- be added in future versions for supported compilers.
-
- The simplest way to use CallableTraits is to include the main header file: -
-#include <callable_traits/callable_traits.hpp> --
- CallableTraits interface is also broken down by trait into individual header - files. To use only the traits you need, include one or more of the following - headers, which are listed alphabetically: -
-#include <callable_traits/add_const_qualifier.hpp> -#include <callable_traits/add_cv_qualifiers.hpp> -#include <callable_traits/add_lvalue_qualifier.hpp> -#include <callable_traits/add_rvalue_qualifier.hpp> -#include <callable_traits/add_varargs.hpp> -#include <callable_traits/add_volatile_qualifier.hpp> -#include <callable_traits/apply_member_pointer.hpp> -#include <callable_traits/apply_return.hpp> -#include <callable_traits/arg_at.hpp> -#include <callable_traits/args.hpp> -#include <callable_traits/arity.hpp> -#include <callable_traits/bind.hpp> -#include <callable_traits/can_invoke.hpp> -#include <callable_traits/can_invoke_constexpr.hpp> -#include <callable_traits/function_type.hpp> -#include <callable_traits/has_varargs.hpp> -#include <callable_traits/has_void_return.hpp> -#include <callable_traits/is_const_qualified.hpp> -#include <callable_traits/is_constexpr.hpp> -#include <callable_traits/is_lvalue_qualified.hpp> -#include <callable_traits/is_reference_qualified.hpp> -#include <callable_traits/is_rvalue_qualified.hpp> -#include <callable_traits/is_unqualified.hpp> -#include <callable_traits/is_volatile_qualified.hpp> -#include <callable_traits/max_arity.hpp> -#include <callable_traits/min_arity.hpp> -#include <callable_traits/qualified_function_type.hpp> -#include <callable_traits/remove_const_qualifier.hpp> -#include <callable_traits/remove_cv_qualifiers.hpp> -#include <callable_traits/remove_member_pointer.hpp> -#include <callable_traits/remove_reference_qualifier.hpp> -#include <callable_traits/remove_varargs.hpp> -#include <callable_traits/remove_volatile_qualifier.hpp> -#include <callable_traits/result_of.hpp> --
| - | - |
- - - diff --git a/doc/html/index.html b/doc/html/index.html index c506437..e4b04d2 100644 --- a/doc/html/index.html +++ b/doc/html/index.html @@ -2,16 +2,23 @@
 |
 |
+Home | +Libraries | +People | +FAQ | +More | +
- -
+
+
@@ -22,119 +29,296 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying - file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt ) + file LICENSE.md or copy at http://www.boost.org/LICENSE_1_0.txt)
Table of Contents
-
-
- Motivation +
- Introduction
- -
- Overview +
- Headers +
- add_const_qualifier +
- add_cv_qualifiers +
- add_lvalue_qualifier +
- add_rvalue_qualifier +
- add_varargs +
- add_volatile_qualifier +
- apply_member_pointer +
- apply_return +
- arg_at +
- args +
- arity +
- bind +
- can_invoke +
- can_invoke_constexpr +
- function_type +
- has_varargs +
- has_void_return +
- is_const_qualified +
- is_constexpr +
- is_lvalue_qualified +
- is_reference_qualified +
- is_rvalue_qualified +
- is_unqualified +
- is_volatile_qualified +
- max_arity +
- min_arity +
- qualified_function_type +
- remove_const_qualifier +
- remove_cv_qualifiers +
- remove_member_pointer +
- remove_reference_qualifier +
- remove_varargs +
- remove_volatile_qualifier +
- result_of
+
+ + Quick + Example +
+#include <type_traits> +#include <functional> +#include <tuple> +#include <callable_traits/callable_traits.hpp> + +struct foo { + void operator()(int, int&&, const int&, void* = nullptr) const {} +}; + +namespace ct = callable_traits; +using namespace std::placeholders; + +int main() { + + // indexed argument types + using second_arg = ct::arg_at<1, foo>; + static_assert(std::is_same<second_arg, int&&>::value, ""); + + // arg types are packaged into std::tuple, which serves as the default + // type list in CallableTraits (runtime capabilities are not used). + using args = ct::args<foo>; + using expected_args = std::tuple<int, int&&, const int&, void*>; + static_assert(std::is_same<args, expected_args>::value, ""); + + //callable_traits::result_of is a bit friendlier than std::result_of + using return_type = ct::result_of<foo>; + static_assert(std::is_same<return_type, void>::value, ""); + + //has_void_return is a quicker way to perform the check above + static_assert(ct::has_void_return(foo{}), ""); + + // callable_traits::function_type decays a callable type to + // a plain function type, which is structured in terms of INVOKE + using function_type = ct::function_type<foo>; + using expected_function_type = void(int, int&&, const int&, void*); + static_assert(std::is_same<function_type, expected_function_type>::value, ""); + + // when trait information can be conveyed in an std::integral_constant, + // callable_traits opts for constexpr functions instead of template aliases. + // This is done to encourage value semantics, and to simplify usage inside + // of forwarding functions. + static_assert(ct::arity(foo{}) == 4, ""); + static_assert(ct::max_arity(foo{}) == 4, ""); + static_assert(ct::min_arity(foo{}) == 3, ""); + + // CallableTraits provides constexpr functions so that the user doesn't + // need to worry about reference collapsing or decltype when dealing with + // universal references to callables. Still, you don't NEED an instance, + // because CallableTraits provides non-deduced function templates for + // all constexpr functions (except for can_invoke/can_invoke_constexpr and bind, + // which model std::invoke and std::bind, respectively -- more on these below). + // Here's an example of the non-deduced version of arity, which take an + // explicit type argument. We'll ignore these non-deduced overloads for the + // rest of this example. + static_assert(ct::arity<foo>() == 4, ""); + + // C-style variadics detection (ellipses in a signature) + static_assert(!ct::has_varargs(foo{}), ""); + + int i = 0; + + // callable_traits::can_invoke allows us to preview whether std::invoke will + // compile with the given arguments. + static_assert(ct::can_invoke(foo{}, 0, 0, i), ""); + // no error: std::invoke(foo{}, 0, 0, i); + + static_assert(!ct::can_invoke(foo{}, nullptr), ""); + // error: std::invoke(foo{}, nullptr); + + // For function objects, the following checks are determined by the + // qualifiers on operator(), rather than the category of the passed value. + // For member function pointers and abominable function types, the + // qualifiers on the function type are used. + static_assert(ct::is_const_qualified(foo{}), ""); + static_assert(!ct::is_volatile_qualified(foo{}), ""); + static_assert(!ct::is_reference_qualified(foo{}), ""); + static_assert(!ct::is_lvalue_qualified(foo{}), ""); + static_assert(!ct::is_rvalue_qualified(foo{}), ""); + + + // If you find yourself in the unfortunate situation of needing + // to manipulate member function pointer types, CallableTraits + // has all the tools you need to maintain your sanity. + + + using pmf = decltype(&foo::operator()); + + // So that you don't have to scroll back up to see, here's the type of pmf: + using with_const = void (foo::*)(int, int&&, const int&, void*) const; + static_assert(std::is_same<pmf, with_const>::value, ""); + + // Let's remove the const qualifier: + using mutable_pmf = ct::remove_const_qualifier<pmf>; + using without_const = void (foo::*)(int, int&&, const int&, void*) /*no const!*/; + static_assert(std::is_same<mutable_pmf, without_const>::value, ""); + + // Now let's add an rvalue qualifier (&&): + using rvalue_pmf = ct::add_rvalue_qualifier<pmf>; + using with_rvalue = void (foo::*)(int, int&&, const int&, void*) const &&; + static_assert(std::is_same<rvalue_pmf, with_rvalue>::value, ""); + + // You get the picture. CallableTraits lets you add and remove all PMF + // qualifiers (const, volatile, &, &&, and any combination thereof). + // These type operations can generally be performed on abominable function + // types as well. + + // is_constexpr would return std::true_type if foo's operator() were constexpr. + static_assert(!ct::is_constexpr(foo{}), ""); + + // to check constexprness of a function or member function, you must use an + // std::integral_constant, like this: + using pmf_constant = std::integral_constant<pmf, &foo::operator()>; + static_assert(!ct::is_constexpr(pmf_constant{}), ""); +} ++
+
+
+
+Motivation +
- The complexity of callable types in C++ is extensive: -
+ The complexity of callable types in C++ is extensive: +- - function types - + function types +
- - function pointers - + function pointers +
- - function references - + function references +
-
- objects with
operator()-
+ objects with - - objects with function pointer conversions - + objects with function pointer conversions +
- - "abominable" - function types - + "abominable" + function types +
- - pointers to member data - + pointers to member data +
- - pointers to member functions - + pointers to member functions +
-
- qualified overloads of member functions:
const, -volatile,&, -&&-
+ qualified overloads of member functions: -
- C-style varargs (
...) -
+ C-style varargs ( -
- calling conventions (
__cdecl, -__stdcall,__fastcall,pascal, - etc.) -
+ calling conventions ( -
-
noexcept(part - of the function type system in C++17) -
+
operator()
+
const,
+ volatile, &, &&
+
...)
+
__cdecl,
+ __stdcall, __fastcall, pascal,
+ etc.)
+
noexcept (part
+ of the function type system in C++17)
+
- CallableTraits provides a comprehensive, uniform, and modern type-level interface - for the manipulation and inspection of callable types in C++. By filling the - gaps where existing library solutions fall short, CallableTraits aims to provide - such an exhaustive interface for the features listed above that libary writers - will never again need to specialize templates - for callable types. With CallableTraits, library writers should never need - to write a template like this one: -
+CallableTraits provides a comprehensive, uniform, and
+ modern type-level interface for the manipulation and inspection of callable
+ types in C++. By filling the gaps where existing library solutions fall short,
+ CallableTraits aims to provide such an exhaustive interface
+ for the features listed above that library writers will never
+ again need to specialize templates for callable types. CallableTraits
+ eliminates the need for horrific template specializations like these:
+
template<typename Ret, typename T, typename... Args> struct foo<Ret(T::*)(Args..., ...) const volatile &&>{ - //... + //... };
- Several library solutions exist to manipulate these types, or to abstract away - their complexities. However, these solutions are occasionally inflexible or - lacking in features, especially regarding function objects/lambdas. In CallableTraits, - function pointers, function references, function types, abominable function - types, member function pointers, member data pointers, function objects/lambdas, - and references/pointers/smart pointers thereof are generally interchangeable. -
+ Several library solutions exist to manipulate these types, or to abstract + away their complexities. However, these solutions are occasionally inflexible + or lacking in features, especially regarding function objects/lambdas. In +CallableTraits, function pointers, function references,
+ function types, abominable function types, member function pointers, member
+ data pointers, function objects/lambdas, and references/pointers/smart pointers
+ thereof are generally interchangeable.
+
- The use cases for CallableTraits are closely related to those of function_traits - and FunctionTypes. -
+ The use cases forCallableTraits are closely related to
+ those of function_traits
+ and FunctionTypes.
+
+![[Important]](../../../../doc/src/images/important.png) |
+Important | +
|---|---|
+ |
-
- CallableTraits' template aliases and
constexpr-std::integral_constantfunctions are preferable - totypename foo::type- andfoo::value+CallableTraits' template aliases andconstexprstd::integral_constant+ functions are preferable totypename + foo::typeandfoo::value -
- CallableTraits offers a familar, consistent interface for the synthesis
- and decomposition of callable types
+
CallableTraitsoffers a familar, consistent interface + for the synthesis and decomposition of callable types-
- e.g.
callable_traits::remove_const_qualifier+ e.g.remove_const_qualifierparallelsstd::remove_const
@@ -151,7 +335,7 @@
function_traits<Callable>::arg2_type
-
- e.g.
-
- function objects are first-class citizens in CallableTraits
+ function objects are first-class citizens in
CallableTraits-
e.g.
result_ofcan accept a function object @@ -179,15 +363,16 @@
-
e.g.
At the time of this writing, there are 260 search
results on Stack Overflow concerning the conversion from std::bind
to std::function. There are 336 search
results concerning the conversion of lambdas to std::function.
With this example, we'll kill both birds with the same stone. The make_function function defined below will
- leverage CallableTraits to...
+ leverage CallableTraits to...
- @@ -202,9 +387,9 @@
Without real-world context, make_function
- may seem rather silly to those who are aware of the runtime costs of type
- erasure. However, whenever std::function
- is required by some 3rd party API, this example makes a bit more sense.
+ may seem rather silly to those who know the runtime costs of type erasure.
+ However, whenever std::function is required by some 3rd party
+ API, this example might make a bit more sense.
#include <functional> #include <callable_traits/callable_traits.hpp> @@ -213,11 +398,11 @@ namespace ct = callable_traits; - //`make_function` turns a non-overloaded callable into a type-erased std::function object + //make_function turns a non-overloaded callable into a type-erased std::function object template<typename T> inline decltype(auto) make_function(T&& t) { - // callable_traits::function_type decays any non-overloaded callable type to + // callable_traits::function_type decays any non-overloaded callable type to // a plain function type, which is structured in terms of INVOKE. using signature = ct::function_type<T&&>; @@ -225,7 +410,7 @@ return result_type{ std::forward<T>(t) }; } - //this `make_function` overload turns a bind expression into a type-erased std::function object + //this make_function overload turns a bind expression into a type-erased std::function object template<typename T, typename First, typename... Others> inline decltype(auto) make_function(T&& t, First&& first, Others&&... others) { @@ -235,22 +420,22 @@ // determine the de-facto signature of the std::bind return type, with special // considerations for conversions between reused placeholders and nested // placeholder expressions. For the sake of convenience, callable_traits::bind - // is also a thin forwarding wrapper around std::bind (which is the only true + // is also a thin forwarding wrapper around std::bind (which is the only true // runtime element in CallableTraits). using bind_expr = decltype(ct::bind( - std::forward<T>(t), - std::forward<First>(first), - std::forward<Others>(others)... + std::forward<T>(t), + std::forward<First>(first), + std::forward<Others>(others)... )); using signature = ct::function_type<bind_expr>; using result_type = std::function<signature>; return result_type{ std::bind( - std::forward<T>(t), - std::forward<First>(first), - std::forward<Others>(others)... + std::forward<T>(t), + std::forward<First>(first), + std::forward<Others>(others)... )}; } } @@ -302,6 +487,6 @@
- +