From 7a2cfa4d6042d7740319401f3f7cb7e6f2ec6b29 Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Fri, 20 Apr 2018 19:34:29 -0600 Subject: [PATCH] Stratosphere: Add WrapIpcCommandImpl templating. --- stratosphere/loader/Makefile | 2 +- .../loader/include/boost/callable_traits.hpp | 47 +++ .../callable_traits/add_member_const.hpp | 105 +++++ .../boost/callable_traits/add_member_cv.hpp | 101 +++++ .../add_member_lvalue_reference.hpp | 114 ++++++ .../add_member_rvalue_reference.hpp | 113 +++++ .../callable_traits/add_member_volatile.hpp | 100 +++++ .../boost/callable_traits/add_noexcept.hpp | 108 +++++ .../callable_traits/add_transaction_safe.hpp | 110 +++++ .../boost/callable_traits/add_varargs.hpp | 90 ++++ .../callable_traits/apply_member_pointer.hpp | 123 ++++++ .../boost/callable_traits/apply_return.hpp | 109 +++++ .../include/boost/callable_traits/args.hpp | 97 +++++ .../boost/callable_traits/class_of.hpp | 75 ++++ .../boost/callable_traits/detail/config.hpp | 109 +++++ .../boost/callable_traits/detail/core.hpp | 19 + .../detail/default_callable_traits.hpp | 207 ++++++++++ .../detail/forward_declarations.hpp | 54 +++ .../boost/callable_traits/detail/function.hpp | 192 +++++++++ .../detail/function_object.hpp | 107 +++++ .../detail/is_invocable_impl.hpp | 148 +++++++ .../detail/parameter_index_helper.hpp | 51 +++ .../boost/callable_traits/detail/pmd.hpp | 53 +++ .../boost/callable_traits/detail/pmf.hpp | 97 +++++ .../detail/polyfills/disjunction.hpp | 31 ++ .../detail/polyfills/make_index_sequence.hpp | 50 +++ .../detail/qualifier_flags.hpp | 123 ++++++ .../detail/set_function_qualifiers.hpp | 120 ++++++ .../callable_traits/detail/sfinae_errors.hpp | 89 ++++ .../boost/callable_traits/detail/traits.hpp | 29 ++ .../detail/unguarded/function.hpp | 23 ++ .../detail/unguarded/function_2.hpp | 23 ++ .../detail/unguarded/function_3.hpp | 260 ++++++++++++ .../detail/unguarded/function_ptr.hpp | 25 ++ .../detail/unguarded/function_ptr_2.hpp | 23 ++ .../detail/unguarded/function_ptr_3.hpp | 94 +++++ .../detail/unguarded/function_ptr_varargs.hpp | 23 ++ .../unguarded/function_ptr_varargs_2.hpp | 23 ++ .../unguarded/function_ptr_varargs_3.hpp | 98 +++++ .../callable_traits/detail/unguarded/pmf.hpp | 94 +++++ .../detail/unguarded/pmf_2.hpp | 74 ++++ .../detail/unguarded/pmf_3.hpp | 23 ++ .../detail/unguarded/pmf_4.hpp | 147 +++++++ .../detail/unguarded/pmf_varargs.hpp | 89 ++++ .../detail/unguarded/pmf_varargs_2.hpp | 78 ++++ .../detail/unguarded/pmf_varargs_3.hpp | 23 ++ .../detail/unguarded/pmf_varargs_4.hpp | 149 +++++++ .../boost/callable_traits/detail/utility.hpp | 111 +++++ .../boost/callable_traits/function_type.hpp | 97 +++++ .../callable_traits/has_member_qualifiers.hpp | 99 +++++ .../boost/callable_traits/has_varargs.hpp | 94 +++++ .../boost/callable_traits/has_void_return.hpp | 93 +++++ .../boost/callable_traits/is_const_member.hpp | 97 +++++ .../boost/callable_traits/is_cv_member.hpp | 95 +++++ .../boost/callable_traits/is_invocable.hpp | 103 +++++ .../is_lvalue_reference_member.hpp | 95 +++++ .../boost/callable_traits/is_noexcept.hpp | 95 +++++ .../callable_traits/is_reference_member.hpp | 98 +++++ .../is_rvalue_reference_member.hpp | 97 +++++ .../callable_traits/is_transaction_safe.hpp | 98 +++++ .../callable_traits/is_volatile_member.hpp | 100 +++++ .../callable_traits/qualified_class_of.hpp | 81 ++++ .../callable_traits/remove_member_const.hpp | 85 ++++ .../callable_traits/remove_member_cv.hpp | 87 ++++ .../remove_member_reference.hpp | 85 ++++ .../remove_member_volatile.hpp | 85 ++++ .../boost/callable_traits/remove_noexcept.hpp | 93 +++++ .../remove_transaction_safe.hpp | 93 +++++ .../boost/callable_traits/remove_varargs.hpp | 91 +++++ .../boost/callable_traits/return_type.hpp | 90 ++++ stratosphere/loader/source/ipc_templating.hpp | 386 ++++++++++++++++++ stratosphere/loader/source/iserviceobject.hpp | 4 +- .../loader/source/ldr_debug_monitor.cpp | 67 +-- .../loader/source/ldr_debug_monitor.hpp | 9 +- .../loader/source/ldr_process_manager.cpp | 56 +-- .../loader/source/ldr_process_manager.hpp | 10 +- .../loader/source/ldr_registration.cpp | 17 +- stratosphere/loader/source/ldr_shell.cpp | 35 +- stratosphere/loader/source/ldr_shell.hpp | 6 +- stratosphere/loader/source/servicesession.hpp | 62 +-- 80 files changed, 6694 insertions(+), 162 deletions(-) create mode 100644 stratosphere/loader/include/boost/callable_traits.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_member_const.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_member_cv.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_member_lvalue_reference.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_member_rvalue_reference.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_member_volatile.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_noexcept.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_transaction_safe.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/add_varargs.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/apply_member_pointer.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/apply_return.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/args.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/class_of.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/config.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/core.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/default_callable_traits.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/forward_declarations.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/function.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/function_object.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/is_invocable_impl.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/parameter_index_helper.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/pmd.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/pmf.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/polyfills/disjunction.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/polyfills/make_index_sequence.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/qualifier_flags.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/set_function_qualifiers.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/sfinae_errors.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/traits.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_2.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_3.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_2.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_3.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_2.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_3.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_2.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_3.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_4.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_2.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_3.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_4.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/detail/utility.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/function_type.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/has_member_qualifiers.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/has_varargs.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/has_void_return.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_const_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_cv_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_invocable.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_lvalue_reference_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_noexcept.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_reference_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_rvalue_reference_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_transaction_safe.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/is_volatile_member.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/qualified_class_of.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_member_const.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_member_cv.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_member_reference.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_member_volatile.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_noexcept.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_transaction_safe.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/remove_varargs.hpp create mode 100644 stratosphere/loader/include/boost/callable_traits/return_type.hpp create mode 100644 stratosphere/loader/source/ipc_templating.hpp diff --git a/stratosphere/loader/Makefile b/stratosphere/loader/Makefile index 84cf2adb1..a6304873f 100644 --- a/stratosphere/loader/Makefile +++ b/stratosphere/loader/Makefile @@ -48,7 +48,7 @@ CFLAGS := -g -Wall -O2 -ffunction-sections \ CFLAGS += $(INCLUDE) -D__SWITCH__ -CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11 +CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++1z ASFLAGS := -g $(ARCH) LDFLAGS = -specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) diff --git a/stratosphere/loader/include/boost/callable_traits.hpp b/stratosphere/loader/include/boost/callable_traits.hpp new file mode 100644 index 000000000..87f0fa622 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits.hpp @@ -0,0 +1,47 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_BOOST_CLBL_TRTS_HPP +#define BOOST_CLBL_TRTS_BOOST_CLBL_TRTS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/add_member_const.hpp b/stratosphere/loader/include/boost/callable_traits/add_member_const.hpp new file mode 100644 index 000000000..cd7280ef8 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_member_const.hpp @@ -0,0 +1,105 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_MEMBER_CONST_HPP +#define BOOST_CLBL_TRTS_ADD_MEMBER_CONST_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_member_const_hpp +/*` +[section:ref_add_member_const add_member_const] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using add_member_const_t = //see below +//<- +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + detail::sfinae_try< + typename detail::traits::add_member_const, + + detail::fail_when_same::add_member_const, + detail::abominable_functions_not_supported_on_this_compiler, + this_compiler_doesnt_support_abominable_function_types>, + + detail::fail_if_invalid::add_member_const, + member_qualifiers_are_illegal_for_this_type>>; +#else + + detail::try_but_fail_if_invalid< + typename detail::traits::add_member_const, + member_qualifiers_are_illegal_for_this_type>; + +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +namespace detail { + + template + struct add_member_const_impl {}; + + template + struct add_member_const_impl , detail::dummy>::type> + { + using type = add_member_const_t; + }; +} + +//-> + +template +struct add_member_const : detail::add_member_const_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds a member `const` qualifier to `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_member_const_t`]] + [[`int()`] [`int() const`]] + [[`int(foo::*)()`] [`int(foo::*)() const`]] + [[`int(foo::*)() &`] [`int(foo::*)() const &`]] + [[`int(foo::*)() &&`] [`int(foo::*)() const &&`]] + [[`int(foo::*)() const`] [`int(foo::*)() const`]] + [[`int(foo::*)() volatile`] [`int(foo::*)() const volatile`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() const transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_member_const.cpp] +[add_member_const] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_ADD_MEMBER_CONST_HPP + + + diff --git a/stratosphere/loader/include/boost/callable_traits/add_member_cv.hpp b/stratosphere/loader/include/boost/callable_traits/add_member_cv.hpp new file mode 100644 index 000000000..e11cc0754 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_member_cv.hpp @@ -0,0 +1,101 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_MEMBER_CV_HPP +#define BOOST_CLBL_TRTS_ADD_MEMBER_CV_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_member_cv_hpp +/*` +[section:ref_add_member_cv add_member_cv] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using add_member_cv_t = //see below +//<- +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + detail::sfinae_try< + typename detail::traits::add_member_cv, + + detail::fail_when_same::add_member_cv, + detail::abominable_functions_not_supported_on_this_compiler, + this_compiler_doesnt_support_abominable_function_types>, + + detail::fail_if_invalid::add_member_cv, + member_qualifiers_are_illegal_for_this_type>>; +#else + + detail::try_but_fail_if_invalid< + typename detail::traits::add_member_cv, + member_qualifiers_are_illegal_for_this_type>; + +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +namespace detail { + + template + struct add_member_cv_impl {}; + + template + struct add_member_cv_impl , detail::dummy>::type> + { + using type = add_member_cv_t; + }; +} + +//-> + +template +struct add_member_cv : detail::add_member_cv_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds member `const` and `volatile` qualifiers to `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_member_cv_t`]] + [[`int()`] [`int() const volatile`]] + [[`int(foo::*)()`] [`int(foo::*)() const volatile`]] + [[`int(foo::*)() &`] [`int(foo::*)() const volatile &`]] + [[`int(foo::*)() &&`] [`int(foo::*)() const volatile &&`]] + [[`int(foo::*)() const`] [`int(foo::*)() const volatile`]] + [[`int(foo::*)() volatile`] [`int(foo::*)() const volatile`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() const volatile transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_member_cv.cpp] +[add_member_cv] +[endsect] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/add_member_lvalue_reference.hpp b/stratosphere/loader/include/boost/callable_traits/add_member_lvalue_reference.hpp new file mode 100644 index 000000000..e23d71a00 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_member_lvalue_reference.hpp @@ -0,0 +1,114 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_MEMBER_LVALUE_REFERENCE_HPP +#define BOOST_CLBL_TRTS_ADD_MEMBER_LVALUE_REFERENCE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_member_lvalue_reference_hpp +/*` +[section:ref_add_member_lvalue_reference add_member_lvalue_reference] +[heading Header] +``#include `` +[heading Definition] +*/ + +#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +template +struct add_member_lvalue_reference_t { + static_assert(std::is_same::value, + "Reference member qualifiers are not supported by this configuration."); +}; + +#else + +template +using add_member_lvalue_reference_t = //see below +//<- +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + detail::sfinae_try< + typename detail::traits::add_member_lvalue_reference, + + detail::fail_when_same::add_member_lvalue_reference, + detail::abominable_functions_not_supported_on_this_compiler, + this_compiler_doesnt_support_abominable_function_types>, + + detail::fail_if_invalid< + typename detail::traits::add_member_lvalue_reference, + member_qualifiers_are_illegal_for_this_type>>; +#else + + detail::try_but_fail_if_invalid< + typename detail::traits::add_member_lvalue_reference, + member_qualifiers_are_illegal_for_this_type>; + +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +namespace detail { + + template + struct add_member_lvalue_reference_impl {}; + + template + struct add_member_lvalue_reference_impl , detail::dummy>::type> + { + using type = add_member_lvalue_reference_t; + }; +} +//-> + +template +struct add_member_lvalue_reference + : detail::add_member_lvalue_reference_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds a member lvalue reference qualifier (`&`) to `T`, if not already present. +* If an rvalue reference qualifier is present, the lvalue reference qualifier replaces it (in accordance with reference collapsing rules). + +[heading Input/Output Examples] +[table + [[`T`] [`add_member_lvalue_reference_t`]] + [[`int()`] [`int() &`]] + [[`int(foo::*)()`] [`int(foo::*)() &`]] + [[`int(foo::*)() &`] [`int(foo::*)() &`]] + [[`int(foo::*)() &&`] [`int(foo::*)() &`]] + [[`int(foo::*)() const`] [`int(foo::*)() const &`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() & transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_member_lvalue_reference.cpp] +[add_member_lvalue_reference] +[endsect] +*/ +//] + +#endif + diff --git a/stratosphere/loader/include/boost/callable_traits/add_member_rvalue_reference.hpp b/stratosphere/loader/include/boost/callable_traits/add_member_rvalue_reference.hpp new file mode 100644 index 000000000..84e3c5eaf --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_member_rvalue_reference.hpp @@ -0,0 +1,113 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_MEMBER_RVALUE_REFERENCE_HPP +#define BOOST_CLBL_TRTS_ADD_MEMBER_RVALUE_REFERENCE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_member_rvalue_reference_hpp +/*` +[section:ref_add_member_rvalue_reference add_member_rvalue_reference] +[heading Header] +``#include `` +[heading Definition] +*/ + +#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +template +struct add_member_rvalue_reference_t { + static_assert(std::is_same::value, + "Reference member qualifiers are not supported by this configuration."); +}; + +#else + +template +using add_member_rvalue_reference_t = //see below +//<- +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + detail::sfinae_try< + typename detail::traits::add_member_rvalue_reference, + + detail::fail_when_same::add_member_rvalue_reference, + detail::abominable_functions_not_supported_on_this_compiler, + this_compiler_doesnt_support_abominable_function_types>, + + detail::fail_if_invalid::add_member_rvalue_reference, + member_qualifiers_are_illegal_for_this_type>>; +#else + + detail::try_but_fail_if_invalid< + typename detail::traits::add_member_rvalue_reference, + member_qualifiers_are_illegal_for_this_type>; + +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +namespace detail { + + template + struct add_member_rvalue_reference_impl {}; + + template + struct add_member_rvalue_reference_impl , detail::dummy>::type> + { + using type = add_member_rvalue_reference_t; + }; +} +//-> + + +template +struct add_member_rvalue_reference + : detail::add_member_rvalue_reference_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds a member rvalue reference qualifier (`&&`) to `T`, if not already present. +* If an lvalue reference qualifier is present, the lvalue reference qualifier remains (in accordance with reference collapsing rules). + +[heading Input/Output Examples] +[table + [[`T`] [`add_member_rvalue_reference_t`]] + [[`int()`] [`int() &&`]] + [[`int(foo::*)()`] [`int(foo::*)() &&`]] + [[`int(foo::*)() &`] [`int(foo::*)() &`]] + [[`int(foo::*)() &&`] [`int(foo::*)() &&`]] + [[`int(foo::*)() const`] [`int(foo::*)() const &&`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() && transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_member_rvalue_reference.cpp] +[add_member_rvalue_reference] +[endsect][/section:ref_add_member_rvalue_reference] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/add_member_volatile.hpp b/stratosphere/loader/include/boost/callable_traits/add_member_volatile.hpp new file mode 100644 index 000000000..cb0a508a6 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_member_volatile.hpp @@ -0,0 +1,100 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_MEMBER_VOLATILE_HPP +#define BOOST_CLBL_TRTS_ADD_MEMBER_VOLATILE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_member_volatile_hpp +/*` +[section:ref_add_member_volatile add_member_volatile] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using add_member_volatile_t = //see below +//<- +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + detail::sfinae_try< + typename detail::traits::add_member_volatile, + + detail::fail_when_same::add_member_volatile, + detail::abominable_functions_not_supported_on_this_compiler, + this_compiler_doesnt_support_abominable_function_types>, + + detail::fail_if_invalid< + typename detail::traits::add_member_volatile, + member_qualifiers_are_illegal_for_this_type>>; +#else + + detail::try_but_fail_if_invalid< + typename detail::traits::add_member_volatile, + member_qualifiers_are_illegal_for_this_type>; + +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +namespace detail { + + template + struct add_member_volatile_impl {}; + + template + struct add_member_volatile_impl , detail::dummy>::type> + { + using type = add_member_volatile_t; + }; +} +//-> + +template +struct add_member_volatile : detail::add_member_volatile_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds a member volatile qualifier to `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_member_volatile_t`]] + [[`int()`] [`int() volatile`]] + [[`int(foo::*)()`] [`int(foo::*)() volatile`]] + [[`int(foo::*)() &`] [`int(foo::*)() volatile &`]] + [[`int(foo::*)() &&`] [`int(foo::*)() volatile &&`]] + [[`int(foo::*)() const`] [`int(foo::*)() const volatile`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() volatile transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_member_volatile.cpp] +[add_member_volatile] +[endsect][/section:ref_add_member_volatile] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/add_noexcept.hpp b/stratosphere/loader/include/boost/callable_traits/add_noexcept.hpp new file mode 100644 index 000000000..92b2dc55a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_noexcept.hpp @@ -0,0 +1,108 @@ +/* +@file add_noexcept + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_NOEXCEPT_HPP +#define BOOST_CLBL_TRTS_ADD_NOEXCEPT_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(add_noexcept) +BOOST_CLBL_TRTS_SFINAE_MSG(add_noexcept, cannot_add_noexcept_to_this_type) + +#ifndef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +template +struct add_noexcept_t { + static_assert(std::is_same::value, + "noexcept types not supported by this configuration."); +}; + +template +struct add_noexcept { + static_assert(std::is_same::value, + "noexcept types not supported by this configuration."); +}; + +#else + +//[ add_noexcept_hpp +/*` +[section:ref_add_noexcept add_noexcept] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using add_noexcept_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::add_noexcept, + cannot_add_noexcept_to_this_type>; + +namespace detail { + + template + struct add_noexcept_impl {}; + + template + struct add_noexcept_impl , detail::dummy>::type> + { + using type = add_noexcept_t; + }; +} +//-> + +template +struct add_noexcept : detail::add_noexcept_impl {}; + +//<- +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds a `noexcept` specifier to `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_noexcept_t`]] + [[`int()`] [`int() noexcept`]] + [[`int (&)()`] [`int(&)() noexcept`]] + [[`int (*)()`] [`int(*)() noexcept`]] + [[`int(foo::*)()`] [`int(foo::*)() noexcept`]] + [[`int(foo::*)() &`] [`int(foo::*)() & noexcept`]] + [[`int(foo::*)() &&`] [`int(foo::*)() && noexcept`]] + [[`int(foo::*)() const transaction_safe`] [`int(foo::*)() const transaction_safe noexcept`]] + [[`int(foo::*)() noexcept`] [`int(foo::*)() noexcept`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (*&)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_noexcept.cpp] +[add_noexcept] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_ADD_NOEXCEPT_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/add_transaction_safe.hpp b/stratosphere/loader/include/boost/callable_traits/add_transaction_safe.hpp new file mode 100644 index 000000000..2a634ba64 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_transaction_safe.hpp @@ -0,0 +1,110 @@ +/* +@file add_transaction_safe + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_TRANSACTION_SAFE_HPP +#define BOOST_CLBL_TRTS_ADD_TRANSACTION_SAFE_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(add_transaction_safe) +BOOST_CLBL_TRTS_SFINAE_MSG(add_transaction_safe, cannot_add_transaction_safe_to_this_type) + +#ifndef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +template +struct add_transaction_safe_t { + static_assert(std::is_same::value, + "transaction_safe not supported by this configuration."); +}; + +template +struct add_transaction_safe { + static_assert(std::is_same::value, + "transaction_safe not supported by this configuration."); +}; + +#else + +//[ add_transaction_safe_hpp +/*` +[section:ref_add_transaction_safe add_transaction_safe] +[heading Header] +``#include `` +[heading Definition] +*/ + + +template +using add_transaction_safe_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::add_transaction_safe, + cannot_add_transaction_safe_to_this_type>; + +namespace detail { + + template + struct add_transaction_safe_impl {}; + + template + struct add_transaction_safe_impl , detail::dummy>::type> + { + using type = add_transaction_safe_t; + }; +} +//-> + +template +struct add_transaction_safe + : detail::add_transaction_safe_impl {}; + +//<- +#endif // #ifndef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds the `transaction_safe` specifier to `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_transaction_safe_t`]] + [[`int()`] [`int() transaction_safe`]] + [[`int (&)()`] [`int(&)() transaction_safe`]] + [[`int (*)()`] [`int(*)() transaction_safe`]] + [[`int(foo::*)()`] [`int(foo::*)() transaction_safe`]] + [[`int(foo::*)() &`] [`int(foo::*)() & transaction_safe`]] + [[`int(foo::*)() &&`] [`int(foo::*)() && transaction_safe`]] + [[`int(foo::*)() const`] [`int(foo::*)() const transaction_safe`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)() transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (*&)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_transaction_safe.cpp] +[add_transaction_safe] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_ADD_TRANSACTION_SAFE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/add_varargs.hpp b/stratosphere/loader/include/boost/callable_traits/add_varargs.hpp new file mode 100644 index 000000000..9357e38ba --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/add_varargs.hpp @@ -0,0 +1,90 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ADD_VARARGS_HPP +#define BOOST_CLBL_TRTS_ADD_VARARGS_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ add_varargs_hpp +/*` +[section:ref_add_varargs add_varargs] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using add_varargs_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::add_varargs, + varargs_are_illegal_for_this_type>; + +namespace detail { + + template + struct add_varargs_impl {}; + + template + struct add_varargs_impl , detail::dummy>::type> + { + using type = add_varargs_t; + }; +} +//-> + +template +struct add_varargs : detail::add_varargs_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Adds C-style variadics (`...`) to the signature of `T`, if not already present. + +[heading Input/Output Examples] +[table + [[`T`] [`add_varargs_t`]] + [[`int()`] [`int(...)`]] + [[`int(int)`] [`int(int, ...)`]] + [[`int (&)()`] [`int(&)(...)`]] + [[`int (*)()`] [`int(*)(...)`]] + [[`int (*)(...)`] [`int(*)(...)`]] + [[`int(foo::*)()`] [`int(foo::*)(...)`]] + [[`int(foo::*)() &`] [`int(foo::*)(...) &`]] + [[`int(foo::*)() &&`] [`int(foo::*)(...) &&`]] + [[`int(foo::*)() const`] [`int(foo::*)(...) const`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)(...) transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (*&)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/add_varargs.cpp] +[add_varargs] +[endsect] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/apply_member_pointer.hpp b/stratosphere/loader/include/boost/callable_traits/apply_member_pointer.hpp new file mode 100644 index 000000000..efd3f9575 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/apply_member_pointer.hpp @@ -0,0 +1,123 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_APPLY_MEMBER_POINTER_HPP +#define BOOST_CLBL_TRTS_APPLY_MEMBER_POINTER_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(apply_member_pointer) +BOOST_CLBL_TRTS_SFINAE_MSG(apply_member_pointer, members_cannot_have_a_type_of_void) +BOOST_CLBL_TRTS_SFINAE_MSG(apply_member_pointer, second_template_argument_must_be_a_class_or_struct) + +namespace detail { + + template::value> + struct make_member_pointer; + + template + struct make_member_pointer { + using type = typename std::remove_reference::type C::*; + }; + + template + struct make_member_pointer { + using type = invalid_type; + }; + + template + struct make_member_pointer { + using type = error_type; + }; + + template + using make_member_pointer_t = typename make_member_pointer::type; +} + +//[ apply_member_pointer_hpp +/*` +[section:ref_apply_member_pointer apply_member_pointer] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using apply_member_pointer_t = //see below +//<- + detail::sfinae_try< + detail::fallback_if_invalid< + typename detail::traits::template apply_member_pointer, + typename detail::make_member_pointer::type>, + + detail::fail_when_same, + + detail::fail_if::value, + second_template_argument_must_be_a_class_or_struct> >; + +namespace detail { + + template + struct apply_member_pointer_impl {}; + + template + struct apply_member_pointer_impl , detail::dummy>::type> + { + using type = apply_member_pointer_t; + }; +} + +//-> + +template +struct apply_member_pointer : detail::apply_member_pointer_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` may be any type except `void` +* `C` must be a user-defined type + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* When `T` is a function, function pointer (unqualified), or function reference, then the aliased type is a member function pointer of `C` with the same parameters and return type. +* When `T` is a member function pointer (unqualified) of any type, the aliased type is a member function pointer of `C` with the same parameters and return type. +* Otherwise, the aliased type is a member data pointer equivalent to `std::remove_reference_t C::*`. + +[heading Input/Output Examples] +[table + [[`T`] [`apply_member_pointer_t`]] + [[`int()`] [`int(foo::*)()`]] + [[`int (&)()`] [`int(foo::*)()`]] + [[`int (*)()`] [`int(foo::*)()`]] + [[`int(bar::*)()`] [`int(foo::*)()`]] + [[`int(bar::*)() &`] [`int(foo::*)() &`]] + [[`int(bar::*)() &&`] [`int(foo::*)() &&`]] + [[`int(bar::*)() const`] [`int(foo::*)() const`]] + [[`int(bar::*)() transaction_safe`] [`int(foo::*)() transaction_safe`]] + [[`int bar::*`] [`int foo::*`]] + [[`int`] [`int foo::*`]] + [[`int &`] [`int foo::*`]] + [[`const int &`] [`const int foo::*`]] + [[`int (*const)()`] [`int (*const foo::*)()`]] + [[`void`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/apply_member_pointer.cpp] +[apply_member_pointer] +[endsect] +*/ +//] +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/apply_return.hpp b/stratosphere/loader/include/boost/callable_traits/apply_return.hpp new file mode 100644 index 000000000..6ed5ab74e --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/apply_return.hpp @@ -0,0 +1,109 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_APPLY_RETURN_HPP +#define BOOST_CLBL_TRTS_APPLY_RETURN_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(apply_return) +BOOST_CLBL_TRTS_SFINAE_MSG(apply_return, invalid_types_for_apply_return) + +namespace detail { + + template + struct apply_return_helper { + using type = typename detail::traits::template apply_return; + }; + + //special case + template + struct apply_return_helper, R> { + using type = R(Args...); + }; +} + +//[ apply_return_hpp +/*` +[section:ref_apply_return apply_return] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using apply_return_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::apply_return_helper::type, + invalid_types_for_apply_return>; + +namespace detail { + + template + struct apply_return_impl {}; + + template + struct apply_return_impl , detail::dummy>::type> + { + using type = apply_return_t; + }; +} + //-> + +template +struct apply_return : detail::apply_return_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must one of the following: + * `std::tuple` template instantiation + * function + * function pointer + * function reference + * member function pointer + * member data pointer +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* When `T` is `std::tuple`, the aliased type is `R(Args...)`. +* When `T` is a function, function pointer, function reference, or member function pointer, the aliased type's return type is `R`, but is otherwise identical to `T`. +* When `T` is a member data pointer of class `foo` to a `U` type (such that `T` is `U foo::*`), the aliased type is `R foo::*`. + +[heading Input/Output Examples] +[table + [[`T`] [`apply_return_t`]] + [[`std::tuple`] [`float(int, int)`]] + [[`int()`] [`float()`]] + [[`int (&)()`] [`float(&)()`]] + [[`int (*)()`] [`float(*)()`]] + [[`int (*)(...)`] [`float(*)()`]] + [[`int(foo::*)()`] [`float(foo::*)()`]] + [[`int(foo::*)() &`] [`float(foo::*)() &`]] + [[`int(foo::*)() &&`] [`float(foo::*)() &&`]] + [[`int(foo::*)() const`] [`float(foo::*)() const`]] + [[`int(foo::*)() transaction_safe`] [`float(foo::*)() transaction_safe`]] + [[`int foo::*`] [`float foo::*`]] + [[`int`] [(substitution failure)]] + [[`int (*const)()`] [(substitution failure)]] +] + +[heading Example Program] +[/import ../example/apply_return.cpp] +[apply_return] +[endsect] +*/ +//] +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/args.hpp b/stratosphere/loader/include/boost/callable_traits/args.hpp new file mode 100644 index 000000000..6dcaaccc1 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/args.hpp @@ -0,0 +1,97 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_ARGS_HPP +#define BOOST_CLBL_TRTS_ARGS_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ args_hpp +/*`[section:ref_args args] +[heading Header] +``#include `` +[heading Definition] +*/ + +template class Container = std::tuple> +using args_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits< + detail::shallow_decay>::template expand_args, + cannot_expand_the_parameter_list_of_first_template_argument>; + +namespace detail { + + template class Container, + typename = std::false_type> + struct args_impl {}; + + template class Container> + struct args_impl , detail::dummy>::type> + { + using type = args_t; + }; +} + +//-> + +template class Container = std::tuple> +struct args : detail::args_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function + * function pointer + * function reference + * member function pointer + * member data pointer + * user-defined type with a non-overloaded `operator()` + * type of a non-generic lambda + +[heading Behavior] +* When the constraints are violated, a substitution failure occurs. +* When `T` is a function, function pointer, or function reference, the aliased type is `Container` instantiated with the function's parameter types. +* When `T` is a function object, the aliased type is `Container` instantiated with the `T::operator()` parameter types. +* When `T` is a member function pointer, the aliased type is a `Container` instantiation, where the first type argument is a reference to the parent class of `T`, qualified according to the member qualifiers on `T`, such that the first type is equivalent to `boost::callable_traits::qualified_class_of_t`. The subsequent type arguments, if any, are the parameter types of the member function. +* When `T` is a member data pointer, the aliased type is `Container` with a single element, which is a `const` reference to the parent class of `T`. + +[heading Input/Output Examples] +[table + [[`T`] [`args_t`]] + [[`void(float, char, int)`] [`std::tuple`]] + [[`void(*)(float, char, int)`] [`std::tuple`]] + [[`void(*)()`] [`std::tuple<>`]] + [[`void(foo::* const &)(float, char, int)`] [`std::tuple`]] + [[`int(foo::*)(int) const`] [`std::tuple`]] + [[`void(foo::*)() volatile &&`] [`std::tuple`]] + [[`int foo::*`] [`std::tuple`]] + [[`const int foo::*`] [`std::tuple`]] + [[`int`] [(substitution failure)]] + [[`int (*const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/args.cpp] +[args] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_ARGS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/class_of.hpp b/stratosphere/loader/include/boost/callable_traits/class_of.hpp new file mode 100644 index 000000000..a9eee7970 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/class_of.hpp @@ -0,0 +1,75 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_class_of_HPP +#define BOOST_CLBL_TRTS_class_of_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ class_of_hpp +/*` +[section:ref_class_of class_of] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using class_of_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits>::class_type, + type_is_not_a_member_pointer>; + +namespace detail { + + template + struct class_of_impl {}; + + template + struct class_of_impl , detail::dummy>::type> + { + using type = class_of_t; + }; +} + +//-> + +template +struct class_of : detail::class_of_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a member pointer + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* The aliased type is the parent class of the member. In other words, if `T` is expanded to `U C::*`, the aliased type is `C`. + +[heading Input/Output Examples] +[table + [[`T`] [`class_of_t`]] + [[`int foo::*`] [`foo`]] + [[`void(foo::* const &)() const`] [`foo`]] +] + +[heading Example Program] +[import ../example/class_of.cpp] +[class_of] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_class_of_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/config.hpp b/stratosphere/loader/include/boost/callable_traits/detail/config.hpp new file mode 100644 index 000000000..946458187 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/config.hpp @@ -0,0 +1,109 @@ +/* +@Copyright Barrett Adair 2016-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_CONFIG_HPP +#define BOOST_CLBL_TRTS_DETAIL_CONFIG_HPP + +#include +#include +#include +#include + +#define BOOST_CLBL_TRTS_EMPTY_ +#define BOOST_CLBL_TRTS_EMPTY BOOST_CLBL_TRTS_EMPTY_ + +#ifdef __cpp_transactional_memory +# define BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +#endif + +#ifdef __cpp_inline_variables +# define BOOST_CLBL_TRAITS_INLINE_VAR inline +#else +# define BOOST_CLBL_TRAITS_INLINE_VAR +#endif + +#ifdef __cpp_noexcept_function_type +# define BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#endif + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +# define BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER transaction_safe +#else +# define BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER +#endif + +#ifndef __clang__ +# if defined(__GNUC__) +# define BOOST_CLBL_TRTS_GCC +# if __GNUC__ >= 6 +# define BOOST_CLBL_TRTS_GCC_AT_LEAST_6_0_0 +# endif +# if __GNUC__ < 5 +# define BOOST_CLBL_TRTS_GCC_OLDER_THAN_5_0_0 +# endif +# if __GNUC__ >= 5 +# define BOOST_CLBL_TRTS_GCC_AT_LEAST_4_9_2 +# elif __GNUC__ == 4 && __GNUC_MINOR__ == 9 && __GNUC_PATCHLEVEL__ >= 2 +# define BOOST_CLBL_TRTS_GCC_AT_LEAST_4_9_2 +# else +# define BOOST_CLBL_TRTS_GCC_OLDER_THAN_4_9_2 +# endif //#if __GNUC__ >= 5 +# endif //#if defined __GNUC__ +#endif // #ifndef __clang__ + +#ifdef _MSC_VER +# ifdef __clang__ +# define BOOST_CLBL_TRTS_CLANG_C2 +# else +# define BOOST_CLBL_TRTS_MSVC +# endif // #ifdef __clang__ +#endif // #ifdef _MSC_VER + +#define BOOST_CLBL_TRTS_IX_SEQ(...) ::std::index_sequence< __VA_ARGS__ > +#define BOOST_CLBL_TRTS_MAKE_IX_SEQ(...) ::std::make_index_sequence< __VA_ARGS__ > +#define BOOST_CLBL_TRTS_DISJUNCTION(...) ::std::disjunction< __VA_ARGS__ > + +#ifndef __cpp_variable_templates +# define BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES +#endif + +#ifndef __cpp_lib_logical_traits +# include +#endif //__cpp_lib_logical_traits + +#ifndef __cpp_lib_integer_sequence +# include +#endif // __cpp_lib_integer_sequence + +#if defined(BOOST_CLBL_TRTS_MSVC) && !defined(BOOST_DISABLE_WIN32) +# define BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC __cdecl +# define BOOST_CLBL_TRTS_PMF_VARGARGS_CDECL_DEFAULT +#else +# define BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#endif // #if defined(BOOST_CLBL_TRTS_MSVC) && !defined(BOOST_DISABLE_WIN32)) + +#if (defined(BOOST_CLBL_TRTS_GCC) && !defined(BOOST_CLBL_TRTS_GCC_AT_LEAST_4_9_2)) || defined(__INTEL_COMPILER) +# define BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS +# define BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS +#endif // #if defined BOOST_CLBL_TRTS_GCC && !defined(BOOST_CLBL_TRTS_GCC_AT_LEAST_4_9_2) + +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS +# define BOOST_CLBL_TRTS_ABOMINABLE_CONST BOOST_CLBL_TRTS_EMPTY +# define BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE BOOST_CLBL_TRTS_EMPTY +#else +# define BOOST_CLBL_TRTS_ABOMINABLE_CONST const +# define BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE volatile +#endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +# define BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER noexcept +#else +# define BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER BOOST_CLBL_TRTS_EMPTY +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_CONFIG_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/core.hpp b/stratosphere/loader/include/boost/callable_traits/detail/core.hpp new file mode 100644 index 000000000..77560283b --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/core.hpp @@ -0,0 +1,19 @@ +/* + +@Copyright Barrett Adair 2016-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_CORE_HPP +#define BOOST_CLBL_TRTS_DETAIL_CORE_HPP + +#include +#include +#include +#include +#include +#include + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_CORE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/default_callable_traits.hpp b/stratosphere/loader/include/boost/callable_traits/detail/default_callable_traits.hpp new file mode 100644 index 000000000..84970783a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/default_callable_traits.hpp @@ -0,0 +1,207 @@ +/* +Copyright Barrett Adair 2016-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_DEFAULT_BOOST_CLBL_TRTS_HPP +#define BOOST_CLBL_TRTS_DETAIL_DEFAULT_BOOST_CLBL_TRTS_HPP + +namespace boost { namespace callable_traits { namespace detail { + +template +struct default_callable_traits { + + // value is used by all traits classes to participate + // in the disjunction. + static constexpr bool value = false; + + // used facilitate the disjunction in + // + using traits = default_callable_traits; + + using error_t = error_type; + + // represents the type under consideration + using type = error_t; + + // std::true_type for callables with C-style variadics + using has_varargs = std::false_type; + + using return_type = error_t; + + // arg_types is a std::tuple of argument types for + // callables that are not overloaded/templated function objects. + // arg_types IS defined in terms of INVOKE, which means + // a PMF's arg_types tuple will use a reference to its + // parent class as the first argument, with qualifiers added to + // match the PMF's own qualifiers. + using arg_types = error_t; + + // arg_types without the decltype(*this) parameter for member functions + using non_invoke_arg_types = error_t; + + // An "approximation" of a callable type, in the form + // of a plain function type. Defined in terms of INVOKE. + // An identity alias for qualified/unqualified plain function + // types. + using function_type = error_t; + + // Used to smoothen the edges between PMFs and function objects + using function_object_signature = error_t; + + // An identity alias for qualified/unqualified plain function + // types. Equivalent to remove_member_pointer for PMFs. Same + // as function_type for other callable types. + using qualified_function_type = error_t; + + // Removes C-style variadics from a signature, if present. + // Aliases error_t for function objects and PMDs. + using remove_varargs = error_t; + + // Adds C-style variadics to a signature. Aliases + // error_t for function objects and PMDs. + using add_varargs = error_t; + + // std::true_type when the signature includes noexcept, when + // the feature is available + using is_noexcept = std::false_type; + + // adds noexcept to a signature if the feature is available + using add_noexcept = error_t; + + // removes noexcept from a signature if present + using remove_noexcept = error_t; + + // std::true_type when the signature includes transaction_safe, when + // the feature is available + using is_transaction_safe = std::false_type; + + // adds transaction_safe to a signature if the feature is available + using add_transaction_safe = error_t; + + // removes transaction_safe from a signature if present + using remove_transaction_safe = error_t; + + // The class of a PMD or PMF. error_t for other types + using class_type = error_t; + + // The qualified reference type of class_type. error_t + // for non-member-pointers. + using invoke_type = error_t; + + // Removes reference qualifiers from a signature. + using remove_reference = error_t; + + // Adds an lvalue qualifier to a signature, in arbitrary + // accordance with C++11 reference collapsing rules. + using add_member_lvalue_reference = error_t; + + // Adds an rvalue qualifier to a signature, in arbitrary + // accordance with C++11 reference collapsing rules. + using add_member_rvalue_reference = error_t; + + // Adds a const qualifier to a signature. + using add_member_const = error_t; + + // Adds a volatile qualifier to a signature. + using add_member_volatile = error_t; + + // Adds both const and volatile qualifiers to a signature. + using add_member_cv = error_t; + + // Removes a const qualifier from a signature, if present. + using remove_member_const = error_t; + + // Removes a volatile qualifier from a signature, if present. + using remove_member_volatile = error_t; + + // Removes both const and volatile qualifiers from a + // signature, if any. + using remove_member_cv = error_t; + + // Removes the member pointer from PMDs and PMFs. An identity + // alias for other callable types. + using remove_member_pointer = error_t; + + // Changes the parent class type for PMDs and PMFs. Turns + // function pointers, function references, and + // qualified/unqualified function types into PMFs. Turns + // everything else into member data pointers. + template::type, + typename L = typename std::conditional< + std::is_same::value, error_t, K>::type, + typename Class = typename std::conditional< + std::is_class::value, C, error_t>::type> + using apply_member_pointer = typename std::conditional< + std::is_same::value || std::is_same::value, + error_t, L Class::*>::type; + + // Changes the return type of PMFs, function pointers, function + // references, and qualified/unqualified function types. Changes + // the data type of PMDs. error_t for function objects. + template + using apply_return = error_t; + + // Expands the argument types into a template + template class Container> + using expand_args = error_t; + + template class Container, typename... RightArgs> + using expand_args_left = error_t; + + template class Container, typename... LeftArgs> + using expand_args_right = error_t; + + using clear_args = error_t; + + template + using push_front = error_t; + + template + using push_back = error_t; + + template + using pop_front = error_t; + + template + using pop_back = error_t; + + template + using insert_args = error_t; + + template + using remove_args = error_t; + + template + using replace_args = error_t; + + static constexpr qualifier_flags cv_flags = cv_of::value; + static constexpr qualifier_flags ref_flags = ref_of::value; + static constexpr qualifier_flags q_flags = cv_flags | ref_flags; + + using has_member_qualifiers = std::integral_constant; + using is_const_member = std::integral_constant; + using is_volatile_member = std::integral_constant; + using is_cv_member = std::integral_constant; + +#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + using is_reference_member = std::false_type; + using is_lvalue_reference_member = std::false_type; + using is_rvalue_reference_member = std::false_type; +#else + using is_reference_member = std::integral_constant; + using is_lvalue_reference_member = std::integral_constant; + using is_rvalue_reference_member = std::integral_constant; +#endif //#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +}; + +}}} // namespace boost::callable_traits::detail + +#endif // BOOST_CLBL_TRTS_DETAIL_DEFAULT_BOOST_CLBL_TRTS_HPP + diff --git a/stratosphere/loader/include/boost/callable_traits/detail/forward_declarations.hpp b/stratosphere/loader/include/boost/callable_traits/detail/forward_declarations.hpp new file mode 100644 index 000000000..9327759f6 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/forward_declarations.hpp @@ -0,0 +1,54 @@ +#ifndef BOOST_CLBL_TRTS_DETAIL_FORWARD_DECLARATIONS +#define BOOST_CLBL_TRTS_DETAIL_FORWARD_DECLARATIONS +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct function; + +template +struct has_normal_call_operator +{ + template + struct check { check(std::nullptr_t) {} }; + + template + static std::int8_t test( + check); + + template + static std::int16_t test(...); + + static constexpr bool value = + sizeof(test(nullptr)) == sizeof(std::int8_t); +}; + +struct callable_dummy { + void operator()() {} +}; + +template +using default_to_function_object = typename std::conditional< + has_normal_call_operator::value, + T, callable_dummy>::type; + +template +struct pmf; + +template +struct pmd; + +template::type> +using function_object_base = typename std::conditional< + has_normal_call_operator::value, + pmf::operator())>, + default_callable_traits>::type; + +template> +struct function_object; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_FORWARD_DECLARATIONS diff --git a/stratosphere/loader/include/boost/callable_traits/detail/function.hpp b/stratosphere/loader/include/boost/callable_traits/detail/function.hpp new file mode 100644 index 000000000..624c704d2 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/function.hpp @@ -0,0 +1,192 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_FUNCTION_HPP +#define BOOST_CLBL_TRTS_DETAIL_FUNCTION_HPP + +#include +#include +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct function : default_callable_traits {}; + +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#ifndef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + +// function pointers + +#define BOOST_CLBL_TRTS_CC_TAG dummy +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC +#define BOOST_CLBL_TRTS_ST +#include +#include +#undef BOOST_CLBL_TRTS_ST +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC + +/* ? +#ifdef BOOST_CLBL_TRTS_ENABLE_CDECL +#define BOOST_CLBL_TRTS_CC_TAG cdecl_tag +#define BOOST_CLBL_TRTS_VARARGS_CC __cdecl +#define BOOST_CLBL_TRTS_CC __cdecl +#define BOOST_CLBL_TRTS_ST +#include +#undef BOOST_CLBL_TRTS_ST +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif*/ + +#ifdef BOOST_CLBL_TRTS_ENABLE_STDCALL +#define BOOST_CLBL_TRTS_CC_TAG stdcall_tag +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC __stdcall +#define BOOST_CLBL_TRTS_ST +#include +#undef BOOST_CLBL_TRTS_ST +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif + +#ifdef BOOST_CLBL_TRTS_ENABLE_FASTCALL +#define BOOST_CLBL_TRTS_CC_TAG fastcall_tag +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC __fastcall +#define BOOST_CLBL_TRTS_ST +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_ST +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif + +#ifdef BOOST_CLBL_TRTS_ENABLE_PASCAL +#define BOOST_CLBL_TRTS_CC_TAG pascal_tag +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC +#define BOOST_CLBL_TRTS_ST pascal +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_ST +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif + +template +struct function : std::conditional::value, + function, default_callable_traits>::type { + + static constexpr const bool value = !std::is_pointer::value; + + using traits = function; + using base = function; + using type = T&; + using remove_varargs = typename base::remove_varargs&; + using add_varargs = typename base::add_varargs&; + + using remove_member_reference = reference_error; + using add_member_lvalue_reference = reference_error; + using add_member_rvalue_reference = reference_error; + using add_member_const = reference_error; + using add_member_volatile = reference_error; + using add_member_cv = reference_error; + using remove_member_const = reference_error; + using remove_member_volatile = reference_error; + using remove_member_cv = reference_error; + + template + using apply_return = typename base::template apply_return&; + + using clear_args = typename base::clear_args&; + + template + using push_front = typename base::template push_front&; + + template + using push_back = typename base::template push_back&; + + template + using pop_back = typename base::template pop_back&; + + template + using pop_front = typename base::template pop_front&; + + template + using insert_args = typename base::template insert_args&; + + template + using remove_args = typename base::template remove_args&; + + template + using replace_args = typename base::template replace_args&; +}; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_FUNCTION_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/function_object.hpp b/stratosphere/loader/include/boost/callable_traits/detail/function_object.hpp new file mode 100644 index 000000000..d12fc00e6 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/function_object.hpp @@ -0,0 +1,107 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_FUNCTION_OBJECT_HPP +#define BOOST_CLBL_TRTS_DETAIL_FUNCTION_OBJECT_HPP + +#include +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct function_object : Base { + + using type = T; + using error_t = error_type; + using function_type = typename Base::function_object_signature; + using arg_types = typename Base::non_invoke_arg_types; + using non_invoke_arg_types = arg_types; + + static constexpr const bool value = std::is_class< + typename std::remove_reference::type>::value; + + using traits = function_object; + using class_type = error_t; + using invoke_type = error_t; + using remove_varargs = error_t; + using add_varargs = error_t; + using is_noexcept = typename Base::is_noexcept; + using add_noexcept = error_t; + using remove_noexcept = error_t; + using is_transaction_safe = typename Base::is_transaction_safe; + using add_transaction_safe = error_t; + using remove_transaction_safe = error_t; + using clear_args = error_t; + + template class Container> + using expand_args = typename function::template + expand_args; + + template class Container, typename... RightArgs> + using expand_args_left = typename function::template + expand_args_left; + + template class Container, typename... LeftArgs> + using expand_args_right = typename function::template + expand_args_right; + + template + using apply_member_pointer = + typename std::remove_reference::type C::*; + + template + using apply_return = error_t; + + template + using push_front = error_t; + + template + using push_back = error_t; + + template + using pop_args_front = error_t; + + template + using pop_args_back = error_t; + + template + using insert_args = error_t; + + template + using remove_args = error_t; + + template + using replace_args = error_t; + + template + using pop_front = error_t; + + template + using pop_back = error_t; + + using remove_member_reference = error_t; + using add_member_lvalue_reference = error_t; + using add_member_rvalue_reference = error_t; + using add_member_const = error_t; + using add_member_volatile = error_t; + using add_member_cv = error_t; + using remove_member_const = error_t; + using remove_member_volatile = error_t; + using remove_member_cv = error_t; +}; + +template +struct function_object + : default_callable_traits<> {}; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_FUNCTION_OBJECT_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/is_invocable_impl.hpp b/stratosphere/loader/include/boost/callable_traits/detail/is_invocable_impl.hpp new file mode 100644 index 000000000..323886572 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/is_invocable_impl.hpp @@ -0,0 +1,148 @@ + /*! +@file + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP +#define BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP + +#include +#include +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + + template + struct can_dereference_t + { + template + struct check {}; + + template + static std::int8_t test( + check())>::type>* + ); + + template + static std::int16_t test(...); + + static constexpr const bool value = + sizeof(test(nullptr)) == sizeof(std::int8_t); + }; + + //returns std::true_type for pointers and smart pointers + template + using can_dereference = std::integral_constant::value>; + + + template + struct generalize_t { + using type = T; + }; + + template + struct generalize_t::value && !is_reference_wrapper::value + >>{ + using type = decltype(*std::declval()); + }; + + template + struct generalize_t> { + using type = decltype(std::declval().get()); + }; + + // When T is a pointer, generalize is the resulting type of the + // pointer dereferenced. When T is an std::reference_wrapper, generalize + // is the underlying reference type. Otherwise, generalize is T. + template + using generalize = typename generalize_t::type; + + // handles the member pointer rules of INVOKE + template>, + typename IsSame = std::is_same>> + using generalize_if_dissimilar = typename std::conditional< + IsBaseOf::value || IsSame::value, T, generalize>::type; + + template + struct test_invoke { + + template + auto operator()(Rgs&&... rgs) const -> + success()(static_cast(rgs)...))>; + + auto operator()(...) const -> substitution_failure; + }; + + template + struct test_invoke, true /*abominable*/> { + auto operator()(...) const -> substitution_failure; + }; + + template + struct test_invoke, Ignored> { + + using class_t = typename pmf::class_type; + + template> + auto operator()(U&& u, Rgs&&... rgs) const -> + success().*std::declval())(static_cast(rgs)...))>; + + auto operator()(...) const -> substitution_failure; + }; + + template + struct test_invoke, Ignored> { + + using class_t = typename pmd::class_type; + + template> + auto operator()(U&& u) const -> + success().*std::declval())>; + + auto operator()(...) const -> substitution_failure; + }; + + template + struct is_invocable_impl { + using traits = detail::traits; + using test = detail::test_invoke; + using result = decltype(test{}(::std::declval()...)); + using type = std::integral_constant; + }; + + template + struct is_invocable_impl { + using type = std::false_type; + }; + + template + struct is_invocable_r_impl { + using traits = detail::traits; + using test = detail::test_invoke; + using result = decltype(test{}(::std::declval()...)); + using type = typename std::is_convertible::type; + }; + + template + struct is_invocable_r_impl { + using type = std::false_type; + }; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_IMPL_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/parameter_index_helper.hpp b/stratosphere/loader/include/boost/callable_traits/detail/parameter_index_helper.hpp new file mode 100644 index 000000000..430217591 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/parameter_index_helper.hpp @@ -0,0 +1,51 @@ +#ifndef BOOST_CLBL_TRTS_PARAMETER_INDEX_HELPER_HPP +#define BOOST_CLBL_TRTS_PARAMETER_INDEX_HELPER_HPP + +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct parameter_index_helper { + + using error_t = error_type; + + using args_tuple = typename std::conditional::non_invoke_arg_types, + typename detail::traits::arg_types>::type; + + static constexpr bool has_parameter_list = + !std::is_same::value + && !std::is_same::value; + + using temp_tuple = typename std::conditional>::type; + + static constexpr std::size_t parameter_list_size = + std::tuple_size::value; + + static constexpr bool is_out_of_range = has_parameter_list && + I >= parameter_list_size + static_cast(AllowPlus1); + + static constexpr bool is_count_out_of_range = has_parameter_list && + I + Count > parameter_list_size + static_cast(AllowPlus1); + + static constexpr std::size_t index = + has_parameter_list && !is_out_of_range ? I : 0; + + static constexpr std::size_t count = + has_parameter_list && !is_count_out_of_range ? Count : 0; + + using permissive_tuple = typename std::conditional< + has_parameter_list && !is_out_of_range, + args_tuple, std::tuple>::type; + + using permissive_function = typename std::conditional< + has_parameter_list && !is_out_of_range, + T, error_t(error_t)>::type; +}; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_PARAMETER_INDEX_HELPER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/pmd.hpp b/stratosphere/loader/include/boost/callable_traits/detail/pmd.hpp new file mode 100644 index 000000000..13a2c4463 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/pmd.hpp @@ -0,0 +1,53 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_PMD_HPP +#define BOOST_CLBL_TRTS_DETAIL_PMD_HPP + +#include +#include +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct pmd : default_callable_traits {}; + +template +struct pmd : default_callable_traits<> { + + static constexpr bool value = true; + + using traits = pmd; + using class_type = T; + using invoke_type = T const &; + using type = D T::*; + using function_type = typename std::add_lvalue_reference::type(invoke_type); + using qualified_function_type = D(invoke_type); + using arg_types = std::tuple; + using non_invoke_arg_types = std::tuple<>; + + using return_type = typename std::add_lvalue_reference::type; + + template + using apply_member_pointer = D C::*; + + template + using apply_return = R T::*; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::true_type; +}; + +}}} // namespace boost::callable_traits::detail + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/detail/pmf.hpp b/stratosphere/loader/include/boost/callable_traits/detail/pmf.hpp new file mode 100644 index 000000000..5284e0d59 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/pmf.hpp @@ -0,0 +1,97 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_PMF_HPP +#define BOOST_CLBL_TRTS_DETAIL_PMF_HPP + +#include +#include +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +template +struct set_member_function_qualifiers_t; + +template +struct set_varargs_member_function_qualifiers_t; + +template +using set_member_function_qualifiers = + typename set_member_function_qualifiers_t::type; + +template +using set_varargs_member_function_qualifiers = + typename set_varargs_member_function_qualifiers_t::type; + +template +struct pmf : default_callable_traits {}; + +#define BOOST_CLBL_TRTS_CC_TAG dummy +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC + +#define BOOST_CLBL_TRTS_CC_TAG dummy +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC + +#ifdef BOOST_CLBL_TRTS_ENABLE_CDECL +#define BOOST_CLBL_TRTS_CC_TAG cdecl_tag +#define BOOST_CLBL_TRTS_VARARGS_CC __cdecl +#define BOOST_CLBL_TRTS_CC __cdecl +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_CDECL + +// Defining this macro enables undocumented features, likely broken. +// Too much work to maintain, but knock yourself out +#ifdef BOOST_CLBL_TRTS_ENABLE_STDCALL +#define BOOST_CLBL_TRTS_CC_TAG stdcall_tag +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC __stdcall +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_STDCALL + +// Defining this macro enables undocumented features, likely broken. +// Too much work to officially maintain, but knock yourself out +#ifdef BOOST_CLBL_TRTS_ENABLE_FASTCALL +#define BOOST_CLBL_TRTS_CC_TAG fastcall_tag +#define BOOST_CLBL_TRTS_VARARGS_CC BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC +#define BOOST_CLBL_TRTS_CC __fastcall +#include +#undef BOOST_CLBL_TRTS_CC +#undef BOOST_CLBL_TRTS_CC_TAG +#undef BOOST_CLBL_TRTS_VARARGS_CC +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_FASTCALL + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_PMF_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/polyfills/disjunction.hpp b/stratosphere/loader/include/boost/callable_traits/detail/polyfills/disjunction.hpp new file mode 100644 index 000000000..dc4f65c7c --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/polyfills/disjunction.hpp @@ -0,0 +1,31 @@ +/* +Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_POLYFILLS_DISJUNCTION_HPP +#define BOOST_CLBL_TRTS_DETAIL_POLYFILLS_DISJUNCTION_HPP + +#undef BOOST_CLBL_TRTS_DISJUNCTION +#define BOOST_CLBL_TRTS_DISJUNCTION(...) \ + ::boost::callable_traits::detail::disjunction<__VA_ARGS__> + +namespace boost { namespace callable_traits { namespace detail { + +//polyfill for C++17 std::disjunction +template +struct disjunction : std::false_type {}; + +template +struct disjunction : T {}; + +template +struct disjunction + : std::conditional>::type {}; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_POLYFILLS_DISJUNCTION_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/polyfills/make_index_sequence.hpp b/stratosphere/loader/include/boost/callable_traits/detail/polyfills/make_index_sequence.hpp new file mode 100644 index 000000000..a4a6e820c --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/polyfills/make_index_sequence.hpp @@ -0,0 +1,50 @@ +/* +Copyright Barrett Adair 2016-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_POLYFILLS_MAKE_INDEX_SEQUENCE_HPP +#define BOOST_CLBL_TRTS_DETAIL_POLYFILLS_MAKE_INDEX_SEQUENCE_HPP + +#undef BOOST_CLBL_TRTS_IX_SEQ +#define BOOST_CLBL_TRTS_IX_SEQ(...) \ + ::boost::callable_traits::detail::index_sequence<__VA_ARGS__> + +#undef BOOST_CLBL_TRTS_MAKE_IX_SEQ +#define BOOST_CLBL_TRTS_MAKE_IX_SEQ(...) \ + ::boost::callable_traits::detail::make_index_sequence<__VA_ARGS__> + +namespace boost { namespace callable_traits { namespace detail { + +template +struct index_sequence { using type = index_sequence; }; + +template +struct concat; + +template +struct concat, index_sequence> + : index_sequence {}; + +template + struct make_index_sequence_t; + +template +struct make_index_sequence_t : concat< + typename make_index_sequence_t::type, + typename make_index_sequence_t::type >::type {}; + +template<> +struct make_index_sequence_t<0> : index_sequence<> {}; + +template<> +struct make_index_sequence_t<1> : index_sequence<0> {}; + +template +using make_index_sequence = typename make_index_sequence_t::type; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_POLYFILLS_MAKE_INDEX_SEQUENCE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/qualifier_flags.hpp b/stratosphere/loader/include/boost/callable_traits/detail/qualifier_flags.hpp new file mode 100644 index 000000000..f69d246c4 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/qualifier_flags.hpp @@ -0,0 +1,123 @@ +/* +Defines `qualifier_flags` + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_QUALIFIER_FLAGS_HPP +#define BOOST_CLBL_TRTS_QUALIFIER_FLAGS_HPP + +#include + +namespace boost { namespace callable_traits { namespace detail { + +//bit qualifier_flags used to signify cv/ref qualifiers +using qualifier_flags = std::uint32_t; + +/* + | && & V C | +-------------------------------------------- +0 | 0 0 0 0 | default +1 | 0 0 0 1 | const +2 | 0 0 1 0 | volatile +3 | 0 0 1 1 | const volatile +-------------------------------------------- +4 | 0 1 0 0 | & +5 | 0 1 0 1 | const & +6 | 0 1 1 0 | volatile & +7 | 0 1 1 1 | const volatile & +-------------------------------------------- +8 | 1 0 0 0 | && +9 | 1 0 0 1 | const && +10 | 1 0 1 0 | volatile && +11 | 1 0 1 1 | const volatile && + +*/ + +// Flag representing the default qualifiers on a type +// or member function overload. +constexpr qualifier_flags default_ = 0; + +// Flag representing a const qualifier on a type or +// member function overload. +constexpr qualifier_flags const_ = 1; + +// Flag representing a volatile qualifier on a type +// or member function overload. +constexpr qualifier_flags volatile_ = 2; + +#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +constexpr qualifier_flags lref_ = default_; +constexpr qualifier_flags rref_ = default_; +#else + +// Flag representing an lvalue reference type, or +// an lvalue-reference-qualified member function +// overload. +constexpr qualifier_flags lref_ = 4; + +// Flag representing an lvalue reference type, or +// an rvalue-reference-qualified member function +// overload. +constexpr qualifier_flags rref_ = 8; + +#endif //#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +constexpr qualifier_flags cv_ = 3; + +template +using remove_const_flag = std::integral_constant< + qualifier_flags, Flags & ~const_>; + +template +using is_const = std::integral_constant; + +template +using remove_volatile_flag = std::integral_constant< + qualifier_flags, Flags & ~volatile_>; + +template::type> +using cv_of = std::integral_constant::value ? const_ : default_) + | (std::is_volatile::value ? volatile_ : default_)>; + +template +using ref_of = std::integral_constant::value ? rref_ + : (std::is_lvalue_reference::value ? lref_ + : default_)>; + +//bit-flag implementation of C++11 reference collapsing rules +template +using collapse_flags = std::integral_constant; + +template struct flag_map { static constexpr qualifier_flags value = default_; }; +template struct flag_map { static constexpr qualifier_flags value = lref_; }; +template struct flag_map { static constexpr qualifier_flags value = rref_; }; +template struct flag_map { static constexpr qualifier_flags value = const_; }; +template struct flag_map { static constexpr qualifier_flags value = const_ | lref_; }; +template struct flag_map { static constexpr qualifier_flags value = const_ | rref_; }; +template struct flag_map { static constexpr qualifier_flags value = volatile_; }; +template struct flag_map { static constexpr qualifier_flags value = volatile_ | lref_; }; +template struct flag_map { static constexpr qualifier_flags value = volatile_ | rref_; }; +template struct flag_map { static constexpr qualifier_flags value = const_ | volatile_; }; +template struct flag_map { static constexpr qualifier_flags value = const_ | volatile_ | lref_; }; +template struct flag_map { static constexpr qualifier_flags value = const_ | volatile_ | rref_; }; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_QUALIFIER_FLAGS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/set_function_qualifiers.hpp b/stratosphere/loader/include/boost/callable_traits/detail/set_function_qualifiers.hpp new file mode 100644 index 000000000..9dc7f405a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/set_function_qualifiers.hpp @@ -0,0 +1,120 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_SET_FUNCTION_QUALIFIERS_HPP +#define BOOST_CLBL_TRTS_DETAIL_SET_FUNCTION_QUALIFIERS_HPP + +#include + +#define BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(QUAL) \ +template \ +struct set_function_qualifiers_t < \ + flag_map::value, false, false, Return, Args...> { \ + using type = Return(Args...) QUAL; \ +}; \ + \ +template \ +struct set_function_qualifiers_t < \ + flag_map::value, true, false, Return, Args...> { \ + using type = Return(Args...) QUAL \ + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER; \ +}; \ + \ +template \ +struct set_function_qualifiers_t < \ + flag_map::value, false, true, Return, Args...> { \ + using type = Return(Args...) QUAL \ + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; \ +}; \ + \ +template \ +struct set_function_qualifiers_t < \ + flag_map::value, true, true, Return, Args...> { \ + using type = Return(Args...) QUAL \ + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER \ + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; \ +}; \ + \ +template \ +struct set_varargs_function_qualifiers_t < \ + flag_map::value, false, false, Return, Args...> { \ + using type = Return(Args..., ...) QUAL; \ +}; \ + \ +template \ +struct set_varargs_function_qualifiers_t < \ + flag_map::value, true, false, Return, Args...> { \ + using type = Return(Args..., ...) QUAL \ + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER; \ +}; \ + \ +template \ +struct set_varargs_function_qualifiers_t < \ + flag_map::value, false, true, Return, Args...> { \ + using type = Return(Args..., ...) QUAL \ + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; \ +}; \ + \ +template \ +struct set_varargs_function_qualifiers_t < \ + flag_map::value, true, true, Return, Args...> { \ + using type = Return(Args..., ...) QUAL \ + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER \ + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; \ +} \ +/**/ + +namespace boost { namespace callable_traits { namespace detail { + + template + struct set_function_qualifiers_t { + using type = Return(Args...); + }; + + template + struct set_varargs_function_qualifiers_t { + using type = Return(Args..., ...); + }; + +#ifndef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(volatile); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const volatile); + +#ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(&); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(&&); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const &); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const &&); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(volatile &); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(volatile &&); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const volatile &); + BOOST_CLBL_TRTS_SET_FUNCTION_QUALIFIERS(const volatile &&); + +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + template + using set_function_qualifiers = + typename set_function_qualifiers_t::type; + + template + using set_varargs_function_qualifiers = + typename set_varargs_function_qualifiers_t::type; + +}}} // namespace boost::callable_traits::detail + +#endif //BOOST_CLBL_TRTS_DETAIL_SET_FUNCTION_QUALIFIERS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/sfinae_errors.hpp b/stratosphere/loader/include/boost/callable_traits/detail/sfinae_errors.hpp new file mode 100644 index 000000000..485d17259 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/sfinae_errors.hpp @@ -0,0 +1,89 @@ +/* +@Copyright Barrett Adair 2016-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_SFINAE_ERRORS_HPP +#define BOOST_CLBL_TRTS_SFINAE_ERRORS_HPP + +#include + +namespace boost { namespace callable_traits { namespace detail { + + struct sfinae_error{}; + + template + struct success { + static constexpr bool value = true; + struct _ { using type = T; }; + }; + + template + struct fail_if : T { + static_assert(std::is_base_of::value, + "incorrect usage of fail_if"); + + static constexpr bool value = B; + }; + + template + using sfinae_try = typename BOOST_CLBL_TRTS_DISJUNCTION( + FailIfs..., success)::_::type; + + template + struct fail { + using type = typename std::conditional::value, + FailMsg, FailMsg>::type::_::type; + }; + +}}} // namespace boost::callable_traits::detail + +#define BOOST_CLBL_TRTS_PP_CAT_(x, y) x ## y +#define BOOST_CLBL_TRTS_PP_CAT(x, y) BOOST_CLBL_TRTS_PP_CAT_(x, y) + +#define BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(origin) \ +namespace error { \ + template \ + struct origin : \ + ::boost::callable_traits::detail::sfinae_error \ + { struct _ {}; }; \ +} \ +/**/ + +#define BOOST_CLBL_TRTS_SFINAE_MSG(origin, name) \ +struct BOOST_CLBL_TRTS_PP_CAT(name, _ ){}; \ +struct name : error::origin< \ + BOOST_CLBL_TRTS_PP_CAT(name, _ )>{}; \ +/**/ + +namespace boost { namespace callable_traits { + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(parameters) + BOOST_CLBL_TRTS_SFINAE_MSG(parameters, index_out_of_range_for_parameter_list) + BOOST_CLBL_TRTS_SFINAE_MSG(parameters, cannot_determine_parameters_for_this_type) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(varargs) + BOOST_CLBL_TRTS_SFINAE_MSG(varargs, varargs_are_illegal_for_this_type) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(member_qualifiers) + BOOST_CLBL_TRTS_SFINAE_MSG(member_qualifiers, member_qualifiers_are_illegal_for_this_type) + BOOST_CLBL_TRTS_SFINAE_MSG(member_qualifiers, this_compiler_doesnt_support_abominable_function_types) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(transaction_safe_) + BOOST_CLBL_TRTS_SFINAE_MSG(transaction_safe_, transaction_safe_is_not_supported_by_this_configuration) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(expand_args) + BOOST_CLBL_TRTS_SFINAE_MSG(expand_args, cannot_expand_the_parameter_list_of_first_template_argument) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(member_pointer_required) + BOOST_CLBL_TRTS_SFINAE_MSG(member_pointer_required, type_is_not_a_member_pointer) + + BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(reference_error) + BOOST_CLBL_TRTS_SFINAE_MSG(reference_error, reference_type_not_supported_by_this_metafunction) + +}} // namespace boost::callable_traits + +#endif // #ifndef BOOST_CLBL_TRTS_SFINAE_ERRORS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/traits.hpp b/stratosphere/loader/include/boost/callable_traits/detail/traits.hpp new file mode 100644 index 000000000..e5a587f0b --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/traits.hpp @@ -0,0 +1,29 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_TRAITS_HPP +#define BOOST_CLBL_TRTS_DETAIL_TRAITS_HPP + +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + + // Here is where the magic happens + template + using traits = typename BOOST_CLBL_TRTS_DISJUNCTION( + function_object>, + function, + pmf, + pmd, + default_callable_traits + )::traits; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_TRAITS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function.hpp new file mode 100644 index 000000000..a1d32e90a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::false_type +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::true_type +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE transaction_safe +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_2.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_2.hpp new file mode 100644 index 000000000..562b4e933 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_2.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::false_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC noexcept +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::true_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_3.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_3.hpp new file mode 100644 index 000000000..2c329c411 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_3.hpp @@ -0,0 +1,260 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +macros used: + +BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS - the function-level qualifiers for the + current inclusion (combinations of `const` `volatile` `&` `&&`, or nothing) + +BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE - the transaction_safe specifier for + the current include (`transaction_safe` or nothing) + +BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE is `transaction_safe` + +BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER - `transaction_safe` when + BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE is enabled, otherwise nothing + +BOOST_CLBL_TRTS_NOEXCEPT_SPEC - the noexcept specifier for + the current include (`noexcept` or nothing) + +BOOST_CLBL_TRTS_IS_NOEXCEPT - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_NOEXCEPT_SPEC is `noexcept` + +BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER - `noexcept` if + BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES is defined, otherwise nothing + +*/ + +template +struct function + : default_callable_traits { + + static constexpr bool value = true; + + using traits = function; + + using return_type = Return; + + using arg_types = std::tuple; + using non_invoke_arg_types = arg_types; + + using type = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using function_type = Return(Args...); + + using qualified_function_type = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using remove_varargs = type; + + using add_varargs = Return (Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using qualifiers = default_callable_traits; + + template + using set_qualifiers = set_function_qualifiers; + + #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + using add_member_lvalue_reference = abominable_functions_not_supported_on_this_compiler; + using add_member_rvalue_reference = abominable_functions_not_supported_on_this_compiler; + using add_member_const = abominable_functions_not_supported_on_this_compiler; + using add_member_volatile = abominable_functions_not_supported_on_this_compiler; + using add_member_cv = abominable_functions_not_supported_on_this_compiler; + + #else + + using add_member_lvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_rvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_const = set_qualifiers; + + using add_member_volatile = set_qualifiers; + + using add_member_cv = set_qualifiers; + + #endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + using remove_member_reference = set_qualifiers; + + using remove_member_const = set_qualifiers< + qualifiers::ref_flags | remove_const_flag::value>; + + using remove_member_volatile = set_qualifiers< + qualifiers::ref_flags | remove_volatile_flag::value>; + + using remove_member_cv = set_qualifiers; + + template + using apply_member_pointer = add_member_pointer; + + template + using apply_return = NewReturn(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::false_type; +}; + + +template +struct function + : default_callable_traits { + + static constexpr bool value = true; + + using has_varargs = std::true_type; + using traits = function; + using return_type = Return; + using arg_types = std::tuple; + + using type = Return (Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using function_type = Return(Args..., ...); + + using qualified_function_type = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using remove_varargs = Return (Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_varargs = type; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using qualifiers = default_callable_traits; + + template + using set_qualifiers = set_varargs_function_qualifiers; + + #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + using add_member_lvalue_reference = abominable_functions_not_supported_on_this_compiler; + using add_member_rvalue_reference = abominable_functions_not_supported_on_this_compiler; + using add_member_const = abominable_functions_not_supported_on_this_compiler; + using add_member_volatile = abominable_functions_not_supported_on_this_compiler; + using add_member_cv = abominable_functions_not_supported_on_this_compiler; + + #else + + using add_member_lvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_rvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_const = set_qualifiers; + + using add_member_volatile = set_qualifiers; + + using add_member_cv = set_qualifiers; + + #endif // #ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS + + using remove_member_reference = set_qualifiers; + + using remove_member_const = set_qualifiers< + qualifiers::ref_flags | remove_const_flag::value>; + + using remove_member_volatile = set_qualifiers< + qualifiers::ref_flags | remove_volatile_flag::value>; + + using remove_member_cv = set_qualifiers; + + template + using apply_member_pointer = + Return( BOOST_CLBL_TRTS_DEFAULT_VARARGS_CC U::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_return = NewReturn(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::false_type; +}; diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr.hpp new file mode 100644 index 000000000..4aa8ad593 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr.hpp @@ -0,0 +1,25 @@ +/* +Copyright (c) 2016 Modified Work Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::false_type +#include + +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::true_type +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE transaction_safe +#include +#endif + +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_2.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_2.hpp new file mode 100644 index 000000000..b54f2ed80 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_2.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::false_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC noexcept +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::true_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_3.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_3.hpp new file mode 100644 index 000000000..e657b57ef --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_3.hpp @@ -0,0 +1,94 @@ +/* +Copyright (c) 2016 Modified Work Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +macros used: + +BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE - the transaction_safe specifier for + the current include (`transaction_safe` or nothing) + +BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE is `transaction_safe` + +BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER - `transaction_safe` when + BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE is enabled, otherwise nothing + +BOOST_CLBL_TRTS_NOEXCEPT_SPEC - the noexcept specifier for + the current include (`noexcept` or nothing) + +BOOST_CLBL_TRTS_IS_NOEXCEPT - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_NOEXCEPT_SPEC is `noexcept` + +BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER - `noexcept` if + BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES is defined, otherwise nothing +*/ + +template +struct function< + BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC> + : default_callable_traits<> { + + static constexpr bool value = true; + + using traits = function; + + using return_type = Return; + + using arg_types = std::tuple; + using non_invoke_arg_types = arg_types; + + using type = BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using function_type = Return(Args...); + using qualified_function_type = function_type; + using remove_varargs = type; + + using add_varargs = + BOOST_CLBL_TRTS_ST Return (BOOST_CLBL_TRTS_VARARGS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_member_pointer = + BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC U::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_return = + BOOST_CLBL_TRTS_ST NewReturn(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::false_type; +}; + diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs.hpp new file mode 100644 index 000000000..625f0d62e --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Modified Work Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::false_type +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::true_type +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE transaction_safe +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_2.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_2.hpp new file mode 100644 index 000000000..9ed68fc13 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_2.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::false_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC noexcept +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::true_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_3.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_3.hpp new file mode 100644 index 000000000..42e22931a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/function_ptr_varargs_3.hpp @@ -0,0 +1,98 @@ +/* +Copyright (c) 2016 Modified Work Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +macros used: + +BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE - the transaction_safe specifier for + the current include (`transaction_safe` or nothing) + +BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE is `transaction_safe` + +BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER - `transaction_safe` when + BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE is enabled, otherwise nothing + +BOOST_CLBL_TRTS_NOEXCEPT_SPEC - the noexcept specifier for + the current include (`noexcept` or nothing) + +BOOST_CLBL_TRTS_IS_NOEXCEPT - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_NOEXCEPT_SPEC is `noexcept` + +BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER - `noexcept` if + BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES is defined, otherwise nothing +*/ + +template +struct function + : default_callable_traits<> { + + static constexpr bool value = true; + + using has_varargs = std::true_type; + + using traits = function; + + using return_type = Return; + + using arg_types = std::tuple; + using non_invoke_arg_types = arg_types; + + using type = + BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_VARARGS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using function_type = Return(Args..., ...); + + using qualified_function_type = function_type; + + using remove_varargs = + BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC *)(Args...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_varargs = type; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(BOOST_CLBL_TRTS_VARARGS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(BOOST_CLBL_TRTS_VARARGS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_member_pointer = + BOOST_CLBL_TRTS_ST Return(BOOST_CLBL_TRTS_VARARGS_CC U::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_return = + BOOST_CLBL_TRTS_ST NewReturn(BOOST_CLBL_TRTS_VARARGS_CC *)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::false_type; +}; + diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf.hpp new file mode 100644 index 000000000..de9e7a34a --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf.hpp @@ -0,0 +1,94 @@ +/* +Copyright (c) 2001 Peter Dimov and Multi Media Ltd. +Copyright (c) 2016 Modified Work Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +*/ + +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_CONST +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_CONST BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_2.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_2.hpp new file mode 100644 index 000000000..e3568fb14 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_2.hpp @@ -0,0 +1,74 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +*/ + +template +struct set_member_function_qualifiers_t< + flag_map::value, + false, // IsTransactionSafe + false, // IsNoexcept + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS; +}; + +template +struct set_member_function_qualifiers_t< + flag_map::value, + false, + true, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; +}; + +template +struct set_member_function_qualifiers_t< + flag_map::value, + true, + false, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER; +}; + +template +struct set_member_function_qualifiers_t< + flag_map::value, + true, + true, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; +}; + +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::false_type +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE + +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::true_type +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE transaction_safe +#include +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_3.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_3.hpp new file mode 100644 index 000000000..62b34f2bc --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_3.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::false_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC noexcept +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::true_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_4.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_4.hpp new file mode 100644 index 000000000..5a1f48ce2 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_4.hpp @@ -0,0 +1,147 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS - the function-level qualifiers for the + current inclusion (combinations of `const` `volatile` `&` `&&`, or nothing) + +BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE - the transaction_safe specifier for + the current include (`transaction_safe` or nothing) + +BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE is `transaction_safe` + +BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER - `transaction_safe` when + BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE is defined, otherwise nothing + +BOOST_CLBL_TRTS_NOEXCEPT_SPEC - the noexcept specifier for + the current include (`noexcept` or nothing) + +BOOST_CLBL_TRTS_IS_NOEXCEPT - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_NOEXCEPT_SPEC is `noexcept` + +BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER - `noexcept` if + BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES is defined, otherwise nothing +*/ + +template +struct pmf + : default_callable_traits { + + static constexpr bool value = true; + + using traits = pmf; + + using return_type = Return; + + using type = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using invoke_type = typename std::conditional< + std::is_rvalue_reference::value, + T BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS, + typename std::add_lvalue_reference::type + >::type; + + using arg_types = std::tuple; + using non_invoke_arg_types = std::tuple; + + using function_object_signature = Return(Args...); + + using function_type = Return(invoke_type, Args...); + + using qualified_function_type = Return(Args...) + BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using remove_varargs = type; + + using add_varargs = + Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using class_type = T; + + using qualifiers = default_callable_traits; + + template + using set_qualifiers = set_member_function_qualifiers< + Flags, is_transaction_safe::value, is_noexcept::value, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...>; + + using remove_member_reference = set_qualifiers; + + using add_member_lvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_rvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_const = set_qualifiers; + + using add_member_volatile = set_qualifiers; + + using add_member_cv = set_qualifiers; + + using remove_member_const = set_qualifiers< + qualifiers::ref_flags | remove_const_flag::value>; + + using remove_member_volatile = set_qualifiers< + qualifiers::ref_flags | remove_volatile_flag::value>; + + using remove_member_cv = set_qualifiers; + + template + using apply_member_pointer = + Return(BOOST_CLBL_TRTS_CC U::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_return = + NewReturn(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::true_type; +}; diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs.hpp new file mode 100644 index 000000000..bd40f2bdf --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs.hpp @@ -0,0 +1,89 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +*/ + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_CONST +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS \ + BOOST_CLBL_TRTS_ABOMINABLE_CONST BOOST_CLBL_TRTS_ABOMINABLE_VOLATILE +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile & +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const volatile & +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS volatile && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#define BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS const volatile && +#define BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS const volatile && +#include +#undef BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS +#undef BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + +#endif // #ifndef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_2.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_2.hpp new file mode 100644 index 000000000..5de066819 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_2.hpp @@ -0,0 +1,78 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +*/ + +template +struct set_varargs_member_function_qualifiers_t < + flag_map::value, + false, // IsTransactionSafe + false, // IsNoexcept + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = + Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS; +}; + +template +struct set_varargs_member_function_qualifiers_t < + flag_map::value, + false, + true, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = + Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; +}; + +template +struct set_varargs_member_function_qualifiers_t < + flag_map::value, + true, + false, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = + Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER; +}; + +template +struct set_varargs_member_function_qualifiers_t < + flag_map::value, + true, + true, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...> { + + using type = + Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; +}; + +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::false_type +#include + +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE + +#ifdef BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE + +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE std::true_type +#define BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE transaction_safe +#include +#endif + +#undef BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE +#undef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_3.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_3.hpp new file mode 100644 index 000000000..905a5a6d9 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_3.hpp @@ -0,0 +1,23 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY +*/ + +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::false_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT + +#ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES +#define BOOST_CLBL_TRTS_NOEXCEPT_SPEC noexcept +#define BOOST_CLBL_TRTS_IS_NOEXCEPT std::true_type +#include +#undef BOOST_CLBL_TRTS_NOEXCEPT_SPEC +#undef BOOST_CLBL_TRTS_IS_NOEXCEPT +#endif // #ifdef BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES \ No newline at end of file diff --git a/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_4.hpp b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_4.hpp new file mode 100644 index 000000000..ca33ebf96 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/unguarded/pmf_varargs_4.hpp @@ -0,0 +1,149 @@ +/* +Copyright (c) 2016 Barrett Adair + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +HEADER GUARDS INTENTIONALLY OMITTED +DO NOT INCLUDE THIS HEADER DIRECTLY + +BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS - the function-level qualifiers for the + current inclusion (combinations of `const` `volatile` `&` `&&`, or nothing) + +BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE - the transaction_safe specifier for + the current include (`transaction_safe` or nothing) + +BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE is `transaction_safe` + +BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER - `transaction_safe` when + BOOST_CLBL_TRTS_ENABLE_TRANSACTION_SAFE is enabled, otherwise nothing + +BOOST_CLBL_TRTS_NOEXCEPT_SPEC - the noexcept specifier for + the current include (`noexcept` or nothing) + +BOOST_CLBL_TRTS_IS_NOEXCEPT - `std::true_type` or `std::false_type`, + tied on whether BOOST_CLBL_TRTS_NOEXCEPT_SPEC is `noexcept` + +BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER - `noexcept` if + BOOST_CLBL_TRTS_ENABLE_NOEXCEPT_TYPES is defined, otherwise nothing +*/ + +template +struct pmf + : default_callable_traits { + + static constexpr bool value = true; + + using has_varargs = std::true_type; + + using traits = pmf; + + using return_type = Return; + + using type = Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using invoke_type = typename std::conditional< + std::is_rvalue_reference::value, + T BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS, + typename std::add_lvalue_reference::type + >::type; + + using arg_types = std::tuple; + using non_invoke_arg_types = std::tuple; + + using function_object_signature = Return(Args..., ...); + + using function_type = Return(invoke_type, Args..., ...); + + using qualified_function_type = Return(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_ABOMINABLE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using remove_varargs = + Return(BOOST_CLBL_TRTS_CC T::*)(Args...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_varargs = type; + + using is_noexcept = BOOST_CLBL_TRTS_IS_NOEXCEPT; + + using remove_noexcept = Return(BOOST_CLBL_TRTS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE; + + using add_noexcept = Return(BOOST_CLBL_TRTS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPECIFIER; + + using is_transaction_safe = BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE; + + using remove_transaction_safe = Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using add_transaction_safe = Return(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_TRANSACTION_SAFE_SPECIFIER + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + using class_type = T; + + using qualifiers = default_callable_traits; + + template + using set_qualifiers = set_varargs_member_function_qualifiers< + Flags, is_transaction_safe::value, is_noexcept::value, + BOOST_CLBL_TRTS_CC_TAG, T, Return, Args...>; + + using remove_member_reference = set_qualifiers; + + using add_member_lvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_rvalue_reference = set_qualifiers< + collapse_flags::value>; + + using add_member_const = set_qualifiers; + + using add_member_volatile = set_qualifiers; + + using add_member_cv = set_qualifiers; + + using remove_member_const = set_qualifiers< + qualifiers::ref_flags | remove_const_flag::value>; + + using remove_member_volatile = set_qualifiers< + qualifiers::ref_flags | remove_volatile_flag::value>; + + using remove_member_cv = set_qualifiers; + + template + using apply_member_pointer = + Return(BOOST_CLBL_TRTS_VARARGS_CC U::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template + using apply_return = + NewReturn(BOOST_CLBL_TRTS_VARARGS_CC T::*)(Args..., ...) + BOOST_CLBL_TRTS_INCLUDE_QUALIFIERS + BOOST_CLBL_TRTS_INCLUDE_TRANSACTION_SAFE + BOOST_CLBL_TRTS_NOEXCEPT_SPEC; + + template class Container> + using expand_args = Container; + + using is_member_pointer = std::true_type; +}; diff --git a/stratosphere/loader/include/boost/callable_traits/detail/utility.hpp b/stratosphere/loader/include/boost/callable_traits/detail/utility.hpp new file mode 100644 index 000000000..d5a28cc3c --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/detail/utility.hpp @@ -0,0 +1,111 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP +#define BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP + +#include +#include +#include + +namespace boost { namespace callable_traits { namespace detail { + +struct cdecl_tag{}; +struct stdcall_tag{}; +struct fastcall_tag{}; +struct pascal_tag{}; + +struct invalid_type { invalid_type() = delete; }; +struct reference_error { reference_error() = delete; }; + +template +using error_type = typename std::conditional< + std::is_reference::value, reference_error, invalid_type>::type; + +#ifdef BOOST_CLBL_TRTS_DISABLE_ABOMINABLE_FUNCTIONS +struct abominable_functions_not_supported_on_this_compiler{}; +#endif + +// used to convey "this type doesn't matter" in code +struct dummy {}; + +// used as return type in failed SFINAE tests +struct substitution_failure : std::false_type{}; + +template +using bool_type = std::integral_constant; + +// shorthand for std::tuple_element +template +using at = typename std::tuple_element::type; + +template +using add_member_pointer = T Class::*; + +template + using fail_when_same = fail_if::value, ErrorType>; + +template::type> +using try_but_fail_if_invalid = sfinae_try, + fail_when_same>; + +template::type, + bool is_reference_error = std::is_same::value> +using fail_if_invalid = fail_if< + std::is_same::value || is_reference_error, + typename std::conditional::type>; + +template +using fallback_if_invalid = typename std::conditional< + std::is_same::value, Fallback, T>::type; + +template class Alias, typename U = Alias> +struct force_sfinae { + using type = U; +}; + +template +using shallow_decay = typename std::remove_cv< + typename std::remove_reference::type>::type; + +template +struct is_reference_wrapper_t { + using type = std::false_type; +}; + +template +struct is_reference_wrapper_t> { + using type = std::true_type; +}; + +template +using is_reference_wrapper = + typename is_reference_wrapper_t>::type; + +template +struct unwrap_reference_t { + using type = T; +}; + +template +struct unwrap_reference_t> { + using type = decltype(std::declval().get()); +}; + +// removes std::reference_wrapper +template +using unwrap_reference = typename unwrap_reference_t::type; + +}}} // namespace boost::callable_traits::detail + +#endif // #ifndef BOOST_CLBL_TRTS_DETAIL_UTILITY_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/function_type.hpp b/stratosphere/loader/include/boost/callable_traits/function_type.hpp new file mode 100644 index 000000000..a3305f7bf --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/function_type.hpp @@ -0,0 +1,97 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_FUNCTION_TYPE_HPP +#define BOOST_CLBL_TRTS_FUNCTION_TYPE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ function_type_hpp +/*`[section:ref_function_type function_type] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using function_type_t = //see below +//<- + detail::try_but_fail_if_invalid>::function_type, + cannot_determine_parameters_for_this_type>; + +namespace detail { + + template + struct function_type_impl {}; + + template + struct function_type_impl , detail::dummy>::type> + { + using type = function_type_t; + }; +} + +//-> + +template +struct function_type : detail::function_type_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function + * function pointer + * function reference + * member function pointer + * member data pointer + * user-defined type with a non-overloaded `operator()` + * type of a non-generic lambda + +[heading Behavior] +* When the constraints are violated, a substitution failure occurs. +* When `T` is a function, the aliased type is identical to `T`, except that the aliased function type will not have member qualifiers or the `transaction_safe` specifier. +* When `T` is a function pointer, the aliased type is equivalent to `std::remove_pointer_t`. +* When `T` is a function reference, the aliased type is equivalent to `std::remove_reference_t`. +* When `T` is a function object, the aliased type is a function type with the same return type and parameter list as `T`'s `operator()`. +* When `T` is a member function pointer, the aliased type is a function type with the same return type as `T`, and the first parameter is a reference to the parent class of `T`, qualified according to the member qualifiers on `T`. The subsequent parameters, if any, are the parameter types of `T`. +* When `T` is a member data pointer, the aliased type is a function type returning the underlying member type of `T`, taking a single parameter, which is a `const` reference to the parent type of `T`. +* In all cases, the aliased function type will not have member qualifiers, and will not have the `transaction_safe` specifier. + +[heading Input/Output Examples] +[table + [[`T`] [`function_type_t`]] + [[`void(int)`] [`void(int)`]] + [[`void(int) const`] [`void(int)`]] + [[`void(int) transaction_safe`] [`void(int)`]] + [[`void(*const &)(int)`] [`void(int)`]] + [[`void(&)(int)`] [`void(int)`]] + [[`void(* volatile)()`] [`void()`]] + [[`int(foo::*)(int)`] [`int(foo&, int)`]] + [[`int(foo::*)(int) const`] [`int(const foo&, int)`]] + [[`void(foo::*)() volatile &&`] [`void(volatile foo&&)`]] + [[`int foo::*`] [`int(const foo&)`]] + [[`const int foo::*`] [`int(const foo&)`]] + [[`int`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/function_type.cpp] +[function_type] +[endsect] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/has_member_qualifiers.hpp b/stratosphere/loader/include/boost/callable_traits/has_member_qualifiers.hpp new file mode 100644 index 000000000..3ab44d3b0 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/has_member_qualifiers.hpp @@ -0,0 +1,99 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_HAS_MEMBER_QUALIFIERS_HPP +#define BOOST_CLBL_TRTS_HAS_MEMBER_QUALIFIERS_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ has_member_qualifiers_hpp +/*`[section:ref_has_member_qualifiers has_member_qualifiers] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct has_member_qualifiers; + +//<- +template +struct has_member_qualifiers : detail::traits< + detail::shallow_decay>::has_member_qualifiers { + + using type = typename detail::traits< + detail::shallow_decay>::has_member_qualifiers; +}; + +// older compilers don't support variable templates +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct has_member_qualifiers_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool has_member_qualifiers_v = //see below +//<- + detail::traits>::has_member_qualifiers::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `std::false_type` is inherited by `has_member_qualifiers` and is aliased by `typename has_member_qualifiers::type`, except when one of the following criteria is met, in which case `std::true_type` would be similarly inherited and aliased: + * `T` is a function with member qualifiers + * `T` is a member function pointer with member qualifiers + * `T` is a function object with a member-qualified `operator()` +* On compilers that support variable templates, `has_member_qualifiers_v` is equivalent to `has_member_qualifiers::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`has_member_qualifiers_v`]] + [[`void() const`] [`true`]] + [[`void() const transaction_safe`] [`true`]] + [[`void() volatile &&`] [`true`]] + [[`int(foo::*)() &`] [`true`]] + [[`void(foo::*)() const`] [`true`]] + [[`void(foo::*&)() const`] [`true`]] + [[`void(foo::* const)() const`] [`true`]] + [[`void()`] [`false`]] + [[`void() transaction_safe`] [`false`]] + [[`void(*)()`] [`false`]] + [[`void(*&)()`] [`false`]] + [[`int`] [`false`]] + [[`const int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/has_member_qualifiers.cpp] +[has_member_qualifiers] +[endsect] +*/ +//] + +#endif //BOOST_CLBL_TRTS_HAS_MEMBER_QUALIFIERS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/has_varargs.hpp b/stratosphere/loader/include/boost/callable_traits/has_varargs.hpp new file mode 100644 index 000000000..7f7982417 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/has_varargs.hpp @@ -0,0 +1,94 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_HAS_VARARGS_HPP +#define BOOST_CLBL_TRTS_HAS_VARARGS_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ has_varargs_hpp +/*`[section:ref_has_varargs has_varargs] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct has_varargs; + +//<- +template +struct has_varargs : detail::traits< + detail::shallow_decay>::has_varargs { + + using type = typename detail::traits< + detail::shallow_decay>::has_varargs; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct has_varargs_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool has_varargs_v = //see below +//<- + detail::traits>::has_varargs::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `std::false_type` is inherited by `has_varargs` and is aliased by `typename has_varargs::type`, except when one of the following criteria is met, in which case `std::true_type` would be similarly inherited and aliased: + * `T` is a function, function pointer, or function reference where the function's parameter list includes C-style variadics. + * `T` is a pointer to a member function with C-style variadics in the parameter list. + * `T` is a function object with a non-overloaded `operator()`, which has C-style variadics in the parameter list of its `operator()`. +* On compilers that support variable templates, `has_varargs_v` is equivalent to `has_varargs::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`has_varargs_v`]] + [[`void(...)`] [`true`]] + [[`void(int, ...) const`] [`true`]] + [[`void(* volatile)(...)`] [`true`]] + [[`void(&)(...)`] [`true`]] + [[`void(foo::*)(...) const`] [`true`]] + [[`void(*)()`] [`false`]] + [[`void(*&)()`] [`false`]] + [[`int`] [`false`]] + [[`const int`] [`false`]] + [[`int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/has_varargs.cpp] +[has_varargs] +[endsect] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/has_void_return.hpp b/stratosphere/loader/include/boost/callable_traits/has_void_return.hpp new file mode 100644 index 000000000..06f80f3dd --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/has_void_return.hpp @@ -0,0 +1,93 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_HAS_VOID_RETURN_HPP +#define BOOST_CLBL_TRTS_HAS_VOID_RETURN_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ has_void_return_hpp +/*`[section:ref_has_void_return has_void_return] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct has_void_return; + +//<- +template +struct has_void_return + : std::is_same>::return_type, void> {}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct has_void_return_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> + +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool has_void_return_v = //see below +//<- + std::is_same>::return_type, void>::value; + +#endif + +}} // namespace boost::callable_traits +//-> + + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `std::false_type` is inherited by `has_void_return` and is aliased by `typename has_void_return::type`, except when one of the following criteria is met, in which case `std::true_type` would be similarly inherited and aliased: + * `T` is a function, function pointer, or function reference where the function's return type is `void`. + * `T` is a pointer to a member function whose return type is `void`. + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` function returns `void`. +* On compilers that support variable templates, `has_void_return_v` is equivalent to `has_void_return::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`has_void_return_v`]] + [[`void()`] [`true`]] + [[`void(int) const`] [`true`]] + [[`void(* const &)()`] [`true`]] + [[`void(&)()`] [`true`]] + [[`void(foo::*)() const`] [`true`]] + [[`int(*)()`] [`false`]] + [[`int(*&)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`void* foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/has_void_return.cpp] +[has_void_return] +[endsect] +*/ +//] + +#endif diff --git a/stratosphere/loader/include/boost/callable_traits/is_const_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_const_member.hpp new file mode 100644 index 000000000..f0a7ad252 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_const_member.hpp @@ -0,0 +1,97 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_CONST_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_CONST_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_const_member_hpp +/*`[section:ref_is_const_member is_const_member] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct is_const_member; + +//<- +template +struct is_const_member + : detail::traits>::is_const_member { + using type = typename detail::traits< + detail::shallow_decay>::is_const_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_const_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_const_member_v = //see below +//<- + detail::traits>::is_const_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_const_member::value` is `true` when either: + * `T` is a function type with a `const` member qualifier + * `T` is a pointer to a member function with a `const` member qualifier + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a `const` member qualifier +* On compilers that support variable templates, `is_const_member_v` is equivalent to `is_const_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_const_member_v`]] + [[`int() const`] [`true`]] + [[`int() const volatile`] [`true`]] + [[`int() const & transaction_safe`] [`true`]] + [[`int() const &&`] [`true`]] + [[`int(foo::*&)() const`] [`true`]] + [[`int(foo::*)() const volatile`] [`true`]] + [[`int(foo::*)() const volatile &&`][`true`]] + [[`int(foo::* const)() const`] [`true`]] + [[`int()`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &&`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_const_member.cpp] +[is_const_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_CONST_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_cv_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_cv_member.hpp new file mode 100644 index 000000000..6e95545ee --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_cv_member.hpp @@ -0,0 +1,95 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_CV_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_CV_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_cv_member_hpp +/*`[section:ref_is_cv_member is_cv_member] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct is_cv_member; + +//<- +template +struct is_cv_member + : detail::traits>::is_cv_member { + using type = typename detail::traits< + detail::shallow_decay>::is_cv_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_cv_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_cv_member_v = //see below +//<- + detail::traits>::is_cv_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_cv_member::value` is `true` when either: + * `T` is a function type with both `const` and `volatile` member qualifiers + * `T` is a pointer to a member function with both `const` and `volatile` member qualifiers + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has both `const` and `volatile` member qualifiers +* On compilers that support variable templates, `is_cv_member_v` is equivalent to `is_cv_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_cv_member_v`]] + [[`int() const volatile`] [`true`]] + [[`int() const volatile &`] [`true`]] + [[`int(foo::* const &)() const volatile`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::*)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &&`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_cv_member.cpp] +[is_cv_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_CV_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_invocable.hpp b/stratosphere/loader/include/boost/callable_traits/is_invocable.hpp new file mode 100644 index 000000000..892d8fb71 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_invocable.hpp @@ -0,0 +1,103 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_HPP +#define BOOST_CLBL_TRTS_IS_INVOCABLE_HPP + +#include +#include + +namespace boost { namespace callable_traits { + +//[ is_invocable_hpp +/*`[section:ref_is_invocable is_invocable] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct is_invocable; + +// inherits from either std::true_type or std::false_type +template +struct is_invocable_r; + +//<- +template +struct is_invocable : detail::is_invocable_impl::type { + using type = typename detail::is_invocable_impl::type; +}; + +template +struct is_invocable_r + : detail::is_invocable_r_impl< + typename detail::is_invocable_impl::type, Ret, T, Args...>::type +{ + using type = typename detail::is_invocable_r_impl< + typename detail::is_invocable_impl::type, Ret, T, Args...>::type; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_invocable_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +template +struct is_invocable_r_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_invocable_v = //see below +//<- + detail::is_invocable_impl, Args...>::type::value; +//-> + +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_invocable_r_v = //see below +//<- + detail::is_invocable_r_impl< + typename detail::is_invocable_impl::type, + Ret, T, Args...>::type::value; +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* standalone c++11 implementation of c++17 `std::is_invocable`, `std::is_invocable_r` +[note ref-qualified overloads of `operator()` with different signatures are not handled correctly yet.] + +[heading Example Program] +[import ../example/is_invocable.cpp] +[is_invocable] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_INVOCABLE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_lvalue_reference_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_lvalue_reference_member.hpp new file mode 100644 index 000000000..89500cb93 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_lvalue_reference_member.hpp @@ -0,0 +1,95 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_LVALUE_REFERENCE_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_LVALUE_REFERENCE_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_lvalue_reference_member_hpp +/*`[section:ref_is_lvalue_reference_member is_lvalue_reference_member] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct is_lvalue_reference_member; + +//<- +template +struct is_lvalue_reference_member + : detail::traits>::is_lvalue_reference_member { + using type = typename detail::traits< + detail::shallow_decay>::is_lvalue_reference_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_lvalue_reference_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_lvalue_reference_member_v = //see below +//<- + detail::traits>::is_lvalue_reference_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_lvalue_reference_member::value` is `true` when either: + * `T` is a function type with a '&' member qualifier + * `T` is a pointer to a member function with a '&' member qualifiers + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a '&' member qualifier +* On compilers that support variable templates, `is_lvalue_reference_member_v` is equivalent to `is_lvalue_reference_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_lvalue_reference_member_v`]] + [[`int() &`] [`true`]] + [[`int(foo::* const)() const &`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::*)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &&`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_lvalue_reference_member.cpp] +[is_lvalue_reference_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_LVALUE_REFERENCE_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_noexcept.hpp b/stratosphere/loader/include/boost/callable_traits/is_noexcept.hpp new file mode 100644 index 000000000..36320f689 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_noexcept.hpp @@ -0,0 +1,95 @@ +/* +@file is_noexcept + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_NOEXCEPT_HPP +#define BOOST_CLBL_TRTS_IS_NOEXCEPT_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_noexcept_hpp +/*`[section:ref_is_noexcept is_noexcept] +[heading Header] +``#include `` +[heading Definition] +*/ + +// inherits from either std::true_type or std::false_type +template +struct is_noexcept; + +//<- +template +struct is_noexcept : detail::traits>::is_noexcept { + using type = typename detail::traits< + detail::shallow_decay>::is_noexcept; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_noexcept_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_noexcept_v = //see below +//<- + detail::traits>::is_noexcept::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none +* +[heading Behavior] +* `is_noexcept::value` is `true` when either: + * `T` is a function type, function pointer type, function reference type, or member function pointer type where the function has a `noexcept` specifier + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a `noexcept` specifier +* On compilers that support variable templates, `is_noexcept_v` is equivalent to `is_noexcept::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_noexcept_v`]] + [[`int() const noexcept`] [`true`]] + [[`int(* const &)() noexcept`] [`true`]] + [[`int(&)() noexcept`] [`true`]] + [[`int(foo::*)() noexcept`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::*)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_noexcept.cpp] +[is_noexcept] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_NOEXCEPT_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_reference_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_reference_member.hpp new file mode 100644 index 000000000..ef893a04d --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_reference_member.hpp @@ -0,0 +1,98 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_REFERENCE_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_REFERENCE_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_reference_member_hpp +/*`[section:ref_is_reference_member is_reference_member] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct is_reference_member; + +//<- +template +struct is_reference_member : detail::traits< + detail::shallow_decay>::is_reference_member { + + using type = typename detail::traits< + detail::shallow_decay>::is_reference_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_reference_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_reference_member_v = //see below +//<- + detail::traits>::is_reference_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_reference_member::value` is `true` when either: + * `T` is a function type with a '&' or '&&' member qualifier + * `T` is a pointer to a member function with a '&' or '&&' member qualifiers + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a '&' or '&&' member qualifier +* On compilers that support variable templates, `is_reference_member_v` is equivalent to `is_reference_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_reference_member_v`]] + [[`int() &`] [`true`]] + [[`int() const &&`] [`true`]] + [[`int(foo::* const)() &&`] [`true`]] + [[`int(foo::*)(...) volatile &`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::*)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_reference_member.cpp] +[is_reference_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_REFERENCE_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_rvalue_reference_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_rvalue_reference_member.hpp new file mode 100644 index 000000000..a852ce6e1 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_rvalue_reference_member.hpp @@ -0,0 +1,97 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_RVALUE_REFERENCE_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_RVALUE_REFERENCE_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_rvalue_reference_member_hpp +/*`[section:ref_is_rvalue_reference_member is_rvalue_reference_member] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct is_rvalue_reference_member; + +//<- +template +struct is_rvalue_reference_member : detail::traits< + detail::shallow_decay>::is_rvalue_reference_member { + + using type = typename detail::traits< + detail::shallow_decay>::is_rvalue_reference_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_rvalue_reference_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_rvalue_reference_member_v = //see below +//<- + detail::traits>::is_rvalue_reference_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_rvalue_reference_member::value` is `true` when either: + * `T` is a function type with a '&&' member qualifier + * `T` is a pointer to a member function with a '&&' member qualifiers + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a '&&' member qualifier +* On compilers that support variable templates, `is_rvalue_reference_member_v` is equivalent to `is_rvalue_reference_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_rvalue_reference_member_v`]] + [[`int() const &&`] [`true`]] + [[`int(foo::*)() &&`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::* volatile)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_rvalue_reference_member.cpp] +[is_rvalue_reference_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_RVALUE_REFERENCE_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_transaction_safe.hpp b/stratosphere/loader/include/boost/callable_traits/is_transaction_safe.hpp new file mode 100644 index 000000000..51c98c53e --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_transaction_safe.hpp @@ -0,0 +1,98 @@ +/* +@file is_transaction_safe + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE_HPP +#define BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_transaction_safe_hpp +/*`[section:ref_is_transaction_safe is_transaction_safe] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct is_transaction_safe; + +//<- +template +struct is_transaction_safe : detail::traits< + detail::shallow_decay>::is_transaction_safe { + + using type = typename detail::traits< + detail::shallow_decay>::is_transaction_safe; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_transaction_safe_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_transaction_safe_v = //see below +//<- + detail::traits>::is_transaction_safe::value; + +#endif + +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* none +* +[heading Behavior] +* `is_transaction_safe::value` is `true` when either: + * `T` is a function type, function pointer type, function reference type, or member function pointer type where the function has a `transaction_safe` specifier + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a `transaction_safe` specifier +* On compilers that support variable templates, `is_transaction_safe_v` is equivalent to `is_transaction_safe::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_transaction_safe_v`]] + [[`int() const transaction_safe`] [`true`]] + [[`int(*)() transaction_safe`] [`true`]] + [[`int(&)() transaction_safe`] [`true`]] + [[`int(foo::* const)() transaction_safe`] [`true`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int(foo::*)() const`] [`false`]] + [[`int() const`] [`false`]] + [[`int() volatile`] [`false`]] + [[`int() &`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`const int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_transaction_safe.cpp] +[is_transaction_safe] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_TRANSACTION_SAFE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/is_volatile_member.hpp b/stratosphere/loader/include/boost/callable_traits/is_volatile_member.hpp new file mode 100644 index 000000000..2309eec62 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/is_volatile_member.hpp @@ -0,0 +1,100 @@ +/* + * +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_IS_VOLATILE_MEMBER_HPP +#define BOOST_CLBL_TRTS_IS_VOLATILE_MEMBER_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ is_volatile_member_hpp +/*`[section:ref_is_volatile_member is_volatile_member] +[heading Header] +``#include `` +[heading Definition] +*/ + + +// inherits from either std::true_type or std::false_type +template +struct is_volatile_member; + +//<- +template +struct is_volatile_member : detail::traits< + detail::shallow_decay>::is_volatile_member { + + using type = typename detail::traits< + detail::shallow_decay>::is_volatile_member; +}; + +#ifdef BOOST_CLBL_TRTS_DISABLE_VARIABLE_TEMPLATES + +template +struct is_volatile_member_v { + static_assert(std::is_same::value, + "Variable templates not supported on this compiler."); +}; + +#else +//-> +// only available when variable templates are supported +template +//<- +BOOST_CLBL_TRAITS_INLINE_VAR +//-> +constexpr bool is_volatile_member_v = //see below +//<- + detail::traits>::is_volatile_member::value; + +#endif + +}} // namespace boost::callable_traits +//-> + + +/*` +[heading Constraints] +* none + +[heading Behavior] +* `is_volatile_member::value` is `true` when either: + * `T` is a function type with a `volatile` member qualifier + * `T` is a pointer to a member function with a `volatile` member qualifier + * `T` is a function object with a non-overloaded `operator()`, where the `operator()` has a `volatile` member qualifier +* On compilers that support variable templates, `is_volatile_member_v` is equivalent to `is_volatile_member::value`. + +[heading Input/Output Examples] +[table + [[`T`] [`is_volatile_member_v`]] + [[`int() volatile`] [`true`]] + [[`int() const volatile`] [`true`]] + [[`int() volatile &&`] [`true`]] + [[`int(foo::*)() volatile`] [`true`]] + [[`int(foo::* const)() volatile`] [`true`]] + [[`int(foo::*)() const volatile`] [`true`]] + [[`int(foo::*)() const volatile &&`][`true`]] + [[`int()`] [`false`]] + [[`int() const`] [`false`]] + [[`int() &&`] [`false`]] + [[`int(*)()`] [`false`]] + [[`int`] [`false`]] + [[`int foo::*`] [`false`]] + [[`volatile int foo::*`] [`false`]] +] + +[heading Example Program] +[import ../example/is_volatile_member.cpp] +[is_volatile_member] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_IS_VOLATILE_MEMBER_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/qualified_class_of.hpp b/stratosphere/loader/include/boost/callable_traits/qualified_class_of.hpp new file mode 100644 index 000000000..9f9e58117 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/qualified_class_of.hpp @@ -0,0 +1,81 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_QUALIFIED_class_of_HPP +#define BOOST_CLBL_TRTS_QUALIFIED_class_of_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ qualified_class_of_hpp +/*` +[section:ref_qualified_class_of qualified_class_of] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using qualified_class_of_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits>::invoke_type, + type_is_not_a_member_pointer>; + +namespace detail { + + template + struct qualified_class_of_impl {}; + + template + struct qualified_class_of_impl , detail::dummy>::type> + { + using type = qualified_class_of_t; + }; +} + +//-> + +template +struct qualified_class_of : detail::qualified_class_of_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a member pointer + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* If `T` is a member function pointer, the aliased type is the parent class of the member, qualified according to the member qualifiers on `T`. If `T` does not have a member reference qualifier, then the aliased type will be an lvalue reference. +* If `T` is a member data pointer, the aliased type is equivalent to `ct::class_of const &`. + +[heading Input/Output Examples] +[table + [[`T`] [`qualified_class_of_t`]] + [[`void(foo::*)()`] [`foo &`]] + [[`void(foo::* volatile)() const`] [`foo const &`]] + [[`void(foo::*)() &&`] [`foo &&`]] + [[`void(foo::*&)() volatile &&`] [`foo volatile &&`]] + [[`int foo::*`] [`foo const &`]] + [[`const int foo::*`] [`foo const &`]] +] + +[heading Example Program] +[import ../example/qualified_class_of.cpp] +[qualified_class_of] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_QUALIFIED_class_of_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_member_const.hpp b/stratosphere/loader/include/boost/callable_traits/remove_member_const.hpp new file mode 100644 index 000000000..132680082 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_member_const.hpp @@ -0,0 +1,85 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_CONST_HPP +#define BOOST_CLBL_TRTS_REMOVE_MEMBER_CONST_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ remove_member_const_hpp +/*` +[section:ref_remove_member_const remove_member_const] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_member_const_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_member_const, + member_qualifiers_are_illegal_for_this_type>; + +namespace detail { + + template + struct remove_member_const_impl {}; + + template + struct remove_member_const_impl , detail::dummy>::type> + { + using type = remove_member_const_t; + }; +} + +//-> + +template +struct remove_member_const : detail::remove_member_const_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes the member `const` qualifier from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_member_const_t`]] + [[`int() const`] [`int()`]] + [[`int(foo::*)() const`] [`int(foo::*)()`]] + [[`int(foo::*)() const &`] [`int(foo::*)() &`]] + [[`int(foo::*)() const &&`] [`int(foo::*)() &&`]] + [[`int(foo::*)() const`] [`int(foo::*)()`]] + [[`int(foo::*)() const volatile`] [`int(foo::*)() volatile`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_member_const.cpp] +[remove_member_const] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_CONST_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_member_cv.hpp b/stratosphere/loader/include/boost/callable_traits/remove_member_cv.hpp new file mode 100644 index 000000000..30d99a082 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_member_cv.hpp @@ -0,0 +1,87 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_CV_HPP +#define BOOST_CLBL_TRTS_REMOVE_MEMBER_CV_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ remove_member_cv_hpp +/*` +[section:ref_remove_member_cv remove_member_cv] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_member_cv_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_member_cv, + member_qualifiers_are_illegal_for_this_type>; + +namespace detail { + + template + struct remove_member_cv_impl {}; + + template + struct remove_member_cv_impl , detail::dummy>::type> + { + using type = remove_member_cv_t; + }; +} + +//-> + +template +struct remove_member_cv : detail::remove_member_cv_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes member `const` and/or `volatile` qualifiers from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_member_cv_t`]] + [[`int() const volatile`] [`int()`]] + [[`int(foo::*)() const volatile`] [`int(foo::*)()`]] + [[`int(foo::*)() volatile`] [`int(foo::*)()`]] + [[`int(foo::*)() const`] [`int(foo::*)()`]] + [[`int(foo::*)() const &`] [`int(foo::*)() &`]] + [[`int(foo::*)() const &&`] [`int(foo::*)() &&`]] + [[`int(foo::*)() const`] [`int(foo::*)()`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_member_cv.cpp] +[remove_member_cv] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_CV_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_member_reference.hpp b/stratosphere/loader/include/boost/callable_traits/remove_member_reference.hpp new file mode 100644 index 000000000..d4e4b62ce --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_member_reference.hpp @@ -0,0 +1,85 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_REFERENCE_HPP +#define BOOST_CLBL_TRTS_REMOVE_MEMBER_REFERENCE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ remove_member_reference_hpp +/*` +[section:ref_remove_member_reference remove_member_reference] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_member_reference_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_member_reference, + member_qualifiers_are_illegal_for_this_type>; + +namespace detail { + + template + struct remove_member_reference_impl {}; + + template + struct remove_member_reference_impl , detail::dummy>::type> + { + using type = remove_member_reference_t; + }; +} + +//-> + +template +struct remove_member_reference + : detail::remove_member_reference_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occuers if the constraints are violated. +* Removes member `&` or `&&` qualifiers from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_member_const_t`]] + [[`int() &`] [`int()`]] + [[`int(foo::*)() &`] [`int(foo::*)()`]] + [[`int(foo::*)() const &`] [`int(foo::*)() const`]] + [[`int(foo::*)() const &&`] [`int(foo::*)() const`]] + [[`int(foo::*)()`] [`int(foo::*)()`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_member_reference.cpp] +[remove_member_reference] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_REFERENCE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_member_volatile.hpp b/stratosphere/loader/include/boost/callable_traits/remove_member_volatile.hpp new file mode 100644 index 000000000..d20c79684 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_member_volatile.hpp @@ -0,0 +1,85 @@ +/* + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_VOLATILE_HPP +#define BOOST_CLBL_TRTS_REMOVE_MEMBER_VOLATILE_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ remove_member_volatile_hpp +/*` +[section:ref_remove_member_volatile remove_member_volatile] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_member_volatile_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_member_volatile, + member_qualifiers_are_illegal_for_this_type>; + +namespace detail { + + template + struct remove_member_volatile_impl {}; + + template + struct remove_member_volatile_impl , detail::dummy>::type> + { + using type = remove_member_volatile_t; + }; +} + +//-> + +template +struct remove_member_volatile : detail::remove_member_volatile_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be a function type or a member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes the member `volatile` qualifier from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_member_volatile_t`]] + [[`int() volatile`] [`int()`]] + [[`int(foo::*)() volatile`] [`int(foo::*)()`]] + [[`int(foo::*)() volatile &`] [`int(foo::*)() &`]] + [[`int(foo::*)() volatile &&`] [`int(foo::*)() &&`]] + [[`int(foo::*)() volatile`] [`int(foo::*)()`]] + [[`int(foo::*)() const volatile`] [`int(foo::*)() const`]] + [[`int`] [(substitution failure)]] + [[`int (&)()`] [(substitution failure)]] + [[`int (*)()`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_member_volatile.cpp] +[remove_member_volatile] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_MEMBER_VOLATILE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_noexcept.hpp b/stratosphere/loader/include/boost/callable_traits/remove_noexcept.hpp new file mode 100644 index 000000000..7b1fcb347 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_noexcept.hpp @@ -0,0 +1,93 @@ +/* +@file remove_noexcept + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_NOEXCEPT_HPP +#define BOOST_CLBL_TRTS_REMOVE_NOEXCEPT_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(remove_noexcept) +BOOST_CLBL_TRTS_SFINAE_MSG(remove_noexcept, cannot_remove_noexcept_from_this_type) + +//[ remove_noexcept_hpp +/*` +[section:ref_remove_noexcept remove_noexcept] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_noexcept_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_noexcept, + cannot_remove_noexcept_from_this_type>; + +namespace detail { + + template + struct remove_noexcept_impl {}; + + template + struct remove_noexcept_impl , detail::dummy>::type> + { + using type = remove_noexcept_t; + }; +} + +//-> + +template +struct remove_noexcept : detail::remove_noexcept_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` + +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes the `noexcept` specifier from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_noexcept_t`]] + [[`int() const noexcept`] [`int() const`]] + [[`int(*)() noexcept`] [`int(*)()`]] + [[`int(&)() noexcept`] [`int(&)()`]] + [[`int(foo::*)() noexcept`] [`int(foo::*)()`]] + [[`int() const`] [`int() const`]] + [[`int(*)()`] [`int(*)()`]] + [[`int(&)()`] [`int(&)()`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_noexcept.cpp] +[remove_noexcept] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_NOEXCEPT_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_transaction_safe.hpp b/stratosphere/loader/include/boost/callable_traits/remove_transaction_safe.hpp new file mode 100644 index 000000000..4e37a3666 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_transaction_safe.hpp @@ -0,0 +1,93 @@ +/* +@file remove_transaction_safe + +@Copyright Barrett Adair 2015-2017 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_TRANSACTION_SAFE_HPP +#define BOOST_CLBL_TRTS_REMOVE_TRANSACTION_SAFE_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(remove_transaction_safe) +BOOST_CLBL_TRTS_SFINAE_MSG(remove_transaction_safe, cannot_remove_transaction_safe_from_this_type) + +//[ remove_transaction_safe_hpp +/*` +[section:ref_remove_transaction_safe remove_transaction_safe] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_transaction_safe_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_transaction_safe, + cannot_remove_transaction_safe_from_this_type>; + +namespace detail { + + template + struct remove_transaction_safe_impl {}; + + template + struct remove_transaction_safe_impl , detail::dummy>::type> + { + using type = remove_transaction_safe_t; + }; +} + +//-> + +template +struct remove_transaction_safe : detail::remove_transaction_safe_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` + +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes the member `transaction_safe` specifier from `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_transaction_safe_t`]] + [[`int() const transaction_safe`] [`int() const`]] + [[`int(*)() transaction_safe`] [`int(*)()`]] + [[`int(&)() transaction_safe`] [`int(&)()`]] + [[`int(foo::*)() transaction_safe`] [`int(foo::*)()`]] + [[`int() const`] [`int() const`]] + [[`int(*)()`] [`int(*)()`]] + [[`int(&)()`] [`int(&)()`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (foo::* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_transaction_safe.cpp] +[remove_transaction_safe] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_TRANSACTION_SAFE_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/remove_varargs.hpp b/stratosphere/loader/include/boost/callable_traits/remove_varargs.hpp new file mode 100644 index 000000000..874651c60 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/remove_varargs.hpp @@ -0,0 +1,91 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_REMOVE_VARARGS_HPP +#define BOOST_CLBL_TRTS_REMOVE_VARARGS_HPP + +#include + +namespace boost { namespace callable_traits { + +//[ remove_varargs_hpp +/*` +[section:ref_remove_varargs remove_varargs] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using remove_varargs_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits::remove_varargs, + varargs_are_illegal_for_this_type>; + +namespace detail { + + template + struct remove_varargs_impl {}; + + template + struct remove_varargs_impl , detail::dummy>::type> + { + using type = remove_varargs_t; + }; +} + +//-> + +template +struct remove_varargs : detail::remove_varargs_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function type + * function pointer type + * function reference type + * member function pointer type +* If `T` is a pointer, it may not be cv/ref qualified + +[heading Behavior] +* A substitution failure occurs if the constraints are violated. +* Removes C-style variadics (`...`) from the signature of `T`, if present. + +[heading Input/Output Examples] +[table + [[`T`] [`remove_varargs_t`]] + [[`int(...)`] [`int()`]] + [[`int(int, ...)`] [`int(int)`]] + [[`int (&)(...)`] [`int(&)()`]] + [[`int (*)()`] [`int(*)()`]] + [[`int(foo::*)(...)`] [`int(foo::*)()`]] + [[`int(foo::*)(...) &`] [`int(foo::*)() &`]] + [[`int(foo::*)(...) &&`] [`int(foo::*)() &&`]] + [[`int(foo::*)(...) const`] [`int(foo::*)() const`]] + [[`int(foo::*)(...) transaction_safe`] [`int(foo::*)() transaction_safe`]] + [[`int`] [(substitution failure)]] + [[`int foo::*`] [(substitution failure)]] + [[`int (* const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/remove_varargs.cpp] +[remove_varargs] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_REMOVE_VARARGS_HPP diff --git a/stratosphere/loader/include/boost/callable_traits/return_type.hpp b/stratosphere/loader/include/boost/callable_traits/return_type.hpp new file mode 100644 index 000000000..586b0d249 --- /dev/null +++ b/stratosphere/loader/include/boost/callable_traits/return_type.hpp @@ -0,0 +1,90 @@ +/* + +@Copyright Barrett Adair 2015-2017 + +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#ifndef BOOST_CLBL_TRTS_RESULT_OF_HPP +#define BOOST_CLBL_TRTS_RESULT_OF_HPP + +#include + +namespace boost { namespace callable_traits { + +BOOST_CLBL_TRTS_DEFINE_SFINAE_ERROR_ORIGIN(return_type) +BOOST_CLBL_TRTS_SFINAE_MSG(return_type, unable_to_determine_return_type) + +//[ return_type_hpp +/*` +[section:ref_return_type return_type] +[heading Header] +``#include `` +[heading Definition] +*/ + +template +using return_type_t = //see below +//<- + detail::try_but_fail_if_invalid< + typename detail::traits>::return_type, + unable_to_determine_return_type>; + +namespace detail { + + template + struct return_type_impl {}; + + template + struct return_type_impl , detail::dummy>::type> + { + using type = return_type_t; + }; +} + +//-> + +template +struct return_type : detail::return_type_impl {}; + +//<- +}} // namespace boost::callable_traits +//-> + +/*` +[heading Constraints] +* `T` must be one of the following: + * function + * function pointer + * function reference + * member function pointer + * member data pointer + * user-defined type with a non-overloaded `operator()` + * type of a non-generic lambda + +[heading Behavior] +* When the constraints are violated, a substitution failure occurs. +* The aliased type is the return type of `T`. + +[heading Input/Output Examples] +[table + [[`T`] [`return_type_t`]] + [[`void()`] [`void`]] + [[`float(*)()`] [`float`]] + [[`const char*(&)()`] [`const char *`]] + [[`int(foo::*)() const`] [`int`]] + [[`int`] [(substitution failure)]] + [[`int (*const)()`] [(substitution failure)]] +] + +[heading Example Program] +[import ../example/return_type.cpp] +[return_type] +[endsect] +*/ +//] + +#endif // #ifndef BOOST_CLBL_TRTS_RESULT_OF_HPP diff --git a/stratosphere/loader/source/ipc_templating.hpp b/stratosphere/loader/source/ipc_templating.hpp new file mode 100644 index 000000000..b3dd3be1f --- /dev/null +++ b/stratosphere/loader/source/ipc_templating.hpp @@ -0,0 +1,386 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +/* Represents an A descriptor. */ +template +struct InBuffer { + T *buffer; + size_t num_elements; + BufferType type; + + InBuffer(void *b, size_t n) : buffer((T *)b), num_elements(n/sizeof(T)) { } +}; + +/* Represents a B descriptor. */ +template +struct OutBuffer { + T *buffer; + size_t num_elements; + + OutBuffer(void *b, size_t n) : buffer((T *)b), num_elements(n/sizeof(T)) { } +}; + +/* Represents an X descriptor. */ +template +struct InPointer { + T *pointer; + size_t num_elements; + + InPointer(void *p, size_t n) : pointer((T *)p), num_elements(n/sizeof(T)) { } +}; + +/* Represents a C descriptor. */ +struct OutPointerWithServerSizeBase {}; + +template +struct OutPointerWithServerSize : OutPointerWithServerSizeBase { + T *pointer; + static const size_t num_elements = n; + + OutPointerWithServerSize(void *p) : pointer((T *)p) { } +}; + +/* Represents a C descriptor with size in raw data. */ +template +struct OutPointerWithClientSize { + T *pointer; + size_t num_elements; + + OutPointerWithClientSize(void *p, size_t n) : pointer((T *)p), num_elements(n/sizeof(T)) { } +}; + +/* Represents an input PID. */ +struct PidDescriptor { + u64 pid; + + PidDescriptor(u64 p) : pid(p) { } +}; + +/* Represents a moved handle. */ +struct MovedHandle { + Handle handle; + + MovedHandle(Handle h) : handle(h) { } +}; + +/* Represents a copied handle. */ +struct CopiedHandle { + Handle handle; + + CopiedHandle(Handle h) : handle(h) { } +}; + +/* Utilities. */ +template class Template> +struct is_specialization_of { + static const bool value = false; +}; + +template