diff options
Diffstat (limited to 'deps/tao_tuple/28626e99/include/tao/seq')
22 files changed, 851 insertions, 0 deletions
diff --git a/deps/tao_tuple/28626e99/include/tao/seq/concatenate.hpp b/deps/tao_tuple/28626e99/include/tao/seq/concatenate.hpp new file mode 100644 index 0000000000..fd74924e1e --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/concatenate.hpp @@ -0,0 +1,29 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_CONCATENATE_HPP +#define TAOCPP_SEQUENCES_INCLUDE_CONCATENATE_HPP + +#include <type_traits> + +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + template< typename, typename > + struct concatenate; + + template< typename TA, TA... As, typename TB, TB... Bs > + struct concatenate< integer_sequence< TA, As... >, integer_sequence< TB, Bs... > > + { + using type = integer_sequence< typename std::common_type< TA, TB >::type, As..., Bs... >; + }; + + template< typename A, typename B > + using concatenate_t = typename concatenate< A, B >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_CONCATENATE_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/config.hpp b/deps/tao_tuple/28626e99/include/tao/seq/config.hpp new file mode 100644 index 0000000000..29958766c3 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/config.hpp @@ -0,0 +1,25 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_CONFIG_HPP +#define TAOCPP_SEQUENCES_INCLUDE_CONFIG_HPP + +#if __cplusplus >= 201402L +# define TAOCPP_USE_STD_INTEGER_SEQUENCE +#endif + +#if (__cplusplus >= 201402L) && defined(_LIBCPP_VERSION) +# define TAOCPP_USE_STD_MAKE_INTEGER_SEQUENCE +#endif + +#if defined(__cpp_fold_expressions) +# define TAOCPP_FOLD_EXPRESSIONS +#elif __cplusplus > 201402L +# if defined(__apple_build_version__) && (__clang_major__ >= 7) +# define TAOCPP_FOLD_EXPRESSIONS +# elif defined(__clang__) && ((__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 6))) +# define TAOCPP_FOLD_EXPRESSIONS +# endif +#endif + +#endif // TAOCPP_SEQUENCES_INCLUDE_CONFIG_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/exclusive_scan.hpp b/deps/tao_tuple/28626e99/include/tao/seq/exclusive_scan.hpp new file mode 100644 index 0000000000..e8a7c28f0f --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/exclusive_scan.hpp @@ -0,0 +1,43 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_EXCLUSIVE_SCAN_HPP +#define TAOCPP_SEQUENCES_INCLUDE_EXCLUSIVE_SCAN_HPP + +#include <utility> + +#include "make_integer_sequence.hpp" +#include "partial_sum.hpp" + +namespace tao +{ + namespace seq + { + namespace impl + { + template< typename S, typename = make_index_sequence< S::size() > > + struct exclusive_scan; + + template< typename S, std::size_t... Is > + struct exclusive_scan< S, index_sequence< Is... > > + { + using type = integer_sequence< typename S::value_type, partial_sum< Is, S >::value... >; + }; + } + + template< typename T, T... Ns > + struct exclusive_scan + : impl::exclusive_scan< integer_sequence< T, Ns... > > + {}; + + template< typename T, T... Ns > + struct exclusive_scan< integer_sequence< T, Ns... > > + : impl::exclusive_scan< integer_sequence< T, Ns... > > + {}; + + template< typename T, T... Ns > + using exclusive_scan_t = typename exclusive_scan< T, Ns... >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_EXCLUSIVE_SCAN_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/fold.hpp b/deps/tao_tuple/28626e99/include/tao/seq/fold.hpp new file mode 100644 index 0000000000..fa05c6fce7 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/fold.hpp @@ -0,0 +1,57 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_FOLD_HPP +#define TAOCPP_SEQUENCES_INCLUDE_FOLD_HPP + +#include <type_traits> + +#include "values.hpp" +#include "integer_sequence.hpp" +#include "make_integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + namespace impl + { + template< template< typename U, U, U > class, typename, bool, typename T, T... > + struct folder; + + template< template< typename U, U, U > class OP, std::size_t... Is, typename T, T... Ns > + struct folder< OP, index_sequence< Is... >, false, T, Ns... > + { + using values = seq::values< T, Ns... >; + using type = integer_sequence< T, OP< T, values::data[ 2 * Is ], values::data[ 2 * Is + 1 ] >::value... >; + }; + + template< template< typename U, U, U > class OP, std::size_t... Is, typename T, T N, T... Ns > + struct folder< OP, index_sequence< Is... >, true, T, N, Ns... > + { + using values = seq::values< T, Ns... >; + using type = integer_sequence< T, N, OP< T, values::data[ 2 * Is ], values::data[ 2 * Is + 1 ] >::value... >; + }; + } + + template< template< typename U, U, U > class, typename T, T... > + struct fold; + + template< template< typename U, U, U > class OP, typename T, T N > + struct fold< OP, T, N > + : std::integral_constant< T, N > + {}; + + template< template< typename U, U, U > class OP, typename T, T... Ns > + struct fold + : fold< OP, typename impl::folder< OP, make_index_sequence< sizeof...( Ns ) / 2 >, sizeof...( Ns ) % 2 == 1, T, Ns... >::type > + {}; + + template< template< typename U, U, U > class OP, typename T, T... Ns > + struct fold< OP, integer_sequence< T, Ns... > > + : fold< OP, T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_FOLD_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/head.hpp b/deps/tao_tuple/28626e99/include/tao/seq/head.hpp new file mode 100644 index 0000000000..fcfecf0744 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/head.hpp @@ -0,0 +1,30 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_HEAD_HPP +#define TAOCPP_SEQUENCES_INCLUDE_HEAD_HPP + +#include <type_traits> + +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + template< typename T, T... Ns > + struct head; + + template< typename T, T N, T... Ns > + struct head< T, N, Ns... > + : std::integral_constant< T, N > + {}; + + template< typename T, T... Ns > + struct head< integer_sequence< T, Ns... > > + : head< T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_HEAD_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/inclusive_scan.hpp b/deps/tao_tuple/28626e99/include/tao/seq/inclusive_scan.hpp new file mode 100644 index 0000000000..dc4bf72886 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/inclusive_scan.hpp @@ -0,0 +1,32 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_INCLUSIVE_SCAN_HPP +#define TAOCPP_SEQUENCES_INCLUDE_INCLUSIVE_SCAN_HPP + +#include <utility> + +#include "plus.hpp" +#include "exclusive_scan.hpp" +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + template< typename T, T... Ns > + struct inclusive_scan + : plus< exclusive_scan_t< T, Ns... >, integer_sequence< T, Ns... > > + {}; + + template< typename T, T... Ns > + struct inclusive_scan< integer_sequence< T, Ns... > > + : plus< exclusive_scan_t< integer_sequence< T, Ns... > >, integer_sequence< T, Ns... > > + {}; + + template< typename T, T... Ns > + using inclusive_scan_t = typename inclusive_scan< T, Ns... >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_INCLUSIVE_SCAN_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/integer_sequence.hpp b/deps/tao_tuple/28626e99/include/tao/seq/integer_sequence.hpp new file mode 100644 index 0000000000..9f5cf64eda --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/integer_sequence.hpp @@ -0,0 +1,43 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_INTEGER_SEQUENCE_HPP +#define TAOCPP_SEQUENCES_INCLUDE_INTEGER_SEQUENCE_HPP + +#include <cstddef> +#include <utility> + +#include "config.hpp" + +namespace tao +{ + namespace seq + { + +#ifdef TAOCPP_USE_STD_INTEGER_SEQUENCE + + using std::integer_sequence; + using std::index_sequence; + +#else + + template< typename T, T... Ns > + struct integer_sequence + { + using value_type = T; + + static constexpr std::size_t size() noexcept + { + return sizeof...( Ns ); + } + }; + + template< std::size_t... Ns > + using index_sequence = integer_sequence< std::size_t, Ns... >; + +#endif + + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_INTEGER_SEQUENCE_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/is_all.hpp b/deps/tao_tuple/28626e99/include/tao/seq/is_all.hpp new file mode 100644 index 0000000000..5707058755 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/is_all.hpp @@ -0,0 +1,35 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_IS_ALL_HPP +#define TAOCPP_SEQUENCES_INCLUDE_IS_ALL_HPP + +#include "config.hpp" + +#ifndef TAOCPP_FOLD_EXPRESSIONS +#include "integer_sequence.hpp" +#endif + +#include <type_traits> + +namespace tao +{ + namespace seq + { + +#ifdef TAOCPP_FOLD_EXPRESSIONS + + template< bool... Bs > + using is_all = std::integral_constant< bool, ( Bs && ... ) >; + +#else + + template< bool... Bs > + using is_all = std::integral_constant< bool, std::is_same< integer_sequence< bool, true, Bs... >, integer_sequence< bool, Bs..., true > >::value >; + +#endif + + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_IS_ALL_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/is_any.hpp b/deps/tao_tuple/28626e99/include/tao/seq/is_any.hpp new file mode 100644 index 0000000000..36c39f66aa --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/is_any.hpp @@ -0,0 +1,35 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_IS_ANY_HPP +#define TAOCPP_SEQUENCES_INCLUDE_IS_ANY_HPP + +#include "config.hpp" + +#ifndef TAOCPP_FOLD_EXPRESSIONS +#include "is_all.hpp" +#endif + +#include <type_traits> + +namespace tao +{ + namespace seq + { + +#ifdef TAOCPP_FOLD_EXPRESSIONS + + template< bool... Bs > + using is_any = std::integral_constant< bool, ( Bs || ... ) >; + +#else + + template< bool... Bs > + using is_any = std::integral_constant< bool, !is_all< !Bs... >::value >; + +#endif + + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_IS_ANY_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/make_integer_sequence.hpp b/deps/tao_tuple/28626e99/include/tao/seq/make_integer_sequence.hpp new file mode 100644 index 0000000000..23a4e97180 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/make_integer_sequence.hpp @@ -0,0 +1,84 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_MAKE_INTEGER_SEQUENCE_HPP +#define TAOCPP_SEQUENCES_INCLUDE_MAKE_INTEGER_SEQUENCE_HPP + +#include <cstddef> +#include <utility> +#include <type_traits> + +#include "config.hpp" +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + +#ifdef TAOCPP_USE_STD_MAKE_INTEGER_SEQUENCE + + using std::make_integer_sequence; + using std::make_index_sequence; + using std::index_sequence_for; + +#else + + // idea from http://stackoverflow.com/a/13073076 + + namespace impl + { + template< typename, std::size_t, bool > + struct double_up; + + template< typename T, T... Ns, std::size_t N > + struct double_up< integer_sequence< T, Ns... >, N, false > + { + using type = integer_sequence< T, Ns..., ( N + Ns )... >; + }; + + template< typename T, T... Ns, std::size_t N > + struct double_up< integer_sequence< T, Ns... >, N, true > + { + using type = integer_sequence< T, Ns..., ( N + Ns )..., 2 * N >; + }; + + template< typename T, T N, typename = void > + struct generate; + + template< typename T, T N > + using generate_t = typename generate< T, N >::type; + + template< typename T, T N, typename > + struct generate + : double_up< generate_t< T, N / 2 >, N / 2, N % 2 == 1 > + {}; + + template< typename T, T N > + struct generate< T, N, typename std::enable_if< ( N == 0 ) >::type > + { + using type = integer_sequence< T >; + }; + + template< typename T, T N > + struct generate< T, N, typename std::enable_if< ( N == 1 ) >::type > + { + using type = integer_sequence< T, 0 >; + }; + } + + template< typename T, T N > + using make_integer_sequence = impl::generate_t< T, N >; + + template< std::size_t N > + using make_index_sequence = make_integer_sequence< std::size_t, N >; + + template< typename... Ts > + using index_sequence_for = make_index_sequence< sizeof...( Ts ) >; + +#endif + + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_MAKE_INTEGER_SEQUENCE_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/map.hpp b/deps/tao_tuple/28626e99/include/tao/seq/map.hpp new file mode 100644 index 0000000000..e2ff85ebb8 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/map.hpp @@ -0,0 +1,31 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_MAP_HPP +#define TAOCPP_SEQUENCES_INCLUDE_MAP_HPP + +#include <cstddef> +#include <utility> + +#include "integer_sequence.hpp" +#include "select.hpp" + +namespace tao +{ + namespace seq + { + template< typename, typename > + struct map; + + template< std::size_t... Ns, typename M > + struct map< index_sequence< Ns... >, M > + { + using type = integer_sequence< typename M::value_type, select< Ns, M >::value... >; + }; + + template< typename S, typename M > + using map_t = typename map< S, M >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_MAP_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/max.hpp b/deps/tao_tuple/28626e99/include/tao/seq/max.hpp new file mode 100644 index 0000000000..b3f5be7976 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/max.hpp @@ -0,0 +1,33 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_MAX_HPP +#define TAOCPP_SEQUENCES_INCLUDE_MAX_HPP + +#include "fold.hpp" + +#include <type_traits> + +namespace tao +{ + namespace seq + { + namespace impl + { + template< typename T, T A, T B > + using max = std::integral_constant< T, ( ( A > B ) ? A : B ) >; + } + + template< typename T, T... Ns > + struct max + : fold< impl::max, T, Ns... > + {}; + + template< typename T, T... Ns > + struct max< integer_sequence< T, Ns... > > + : max< T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_MAX_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/min.hpp b/deps/tao_tuple/28626e99/include/tao/seq/min.hpp new file mode 100644 index 0000000000..42bc6e1610 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/min.hpp @@ -0,0 +1,33 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_MIN_HPP +#define TAOCPP_SEQUENCES_INCLUDE_MIN_HPP + +#include "fold.hpp" + +#include <type_traits> + +namespace tao +{ + namespace seq + { + namespace impl + { + template< typename T, T A, T B > + using min = std::integral_constant< T, ( ( A < B ) ? A : B ) >; + } + + template< typename T, T... Ns > + struct min + : fold< impl::min, T, Ns... > + {}; + + template< typename T, T... Ns > + struct min< integer_sequence< T, Ns... > > + : min< T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_MIN_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/minus.hpp b/deps/tao_tuple/28626e99/include/tao/seq/minus.hpp new file mode 100644 index 0000000000..087443b58f --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/minus.hpp @@ -0,0 +1,29 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_MINUS_HPP +#define TAOCPP_SEQUENCES_INCLUDE_MINUS_HPP + +#include <type_traits> + +#include "zip.hpp" + +namespace tao +{ + namespace seq + { + namespace impl + { + template< typename T, T A, T B > + using minus = std::integral_constant< T, A - B >; + } + + template< typename A, typename B > + using minus = zip< impl::minus, A, B >; + + template< typename A, typename B > + using minus_t = typename minus< A, B >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_MINUS_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/partial_sum.hpp b/deps/tao_tuple/28626e99/include/tao/seq/partial_sum.hpp new file mode 100644 index 0000000000..b66a02d5f0 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/partial_sum.hpp @@ -0,0 +1,42 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_PARTIAL_SUM_HPP +#define TAOCPP_SEQUENCES_INCLUDE_PARTIAL_SUM_HPP + +#include <cstddef> +#include <utility> + +#include "make_integer_sequence.hpp" +#include "sum.hpp" + +namespace tao +{ + namespace seq + { + namespace impl + { + template< std::size_t, typename S, typename = make_index_sequence< S::size() > > + struct partial_sum; + + template< std::size_t I, typename T, T... Ns, std::size_t... Is > + struct partial_sum< I, integer_sequence< T, Ns... >, index_sequence< Is... > > + : seq::sum< T, ( ( Is < I ) ? Ns : 0 )... > + { + static_assert( I <= sizeof...( Is ), "tao::seq::partial_sum<I, S>: I is out of range" ); + }; + } + + template< std::size_t I, typename T, T... Ns > + struct partial_sum + : impl::partial_sum< I, integer_sequence< T, Ns... > > + {}; + + template< std::size_t I, typename T, T... Ns > + struct partial_sum< I, integer_sequence< T, Ns... > > + : impl::partial_sum< I, integer_sequence< T, Ns... > > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_PARTIAL_SUM_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/plus.hpp b/deps/tao_tuple/28626e99/include/tao/seq/plus.hpp new file mode 100644 index 0000000000..18ac4c435e --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/plus.hpp @@ -0,0 +1,29 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_PLUS_HPP +#define TAOCPP_SEQUENCES_INCLUDE_PLUS_HPP + +#include <type_traits> + +#include "zip.hpp" + +namespace tao +{ + namespace seq + { + namespace impl + { + template< typename T, T A, T B > + using plus = std::integral_constant< T, A + B >; + } + + template< typename A, typename B > + using plus = zip< impl::plus, A, B >; + + template< typename A, typename B > + using plus_t = typename plus< A, B >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_PLUS_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/select.hpp b/deps/tao_tuple/28626e99/include/tao/seq/select.hpp new file mode 100644 index 0000000000..c84c2e2179 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/select.hpp @@ -0,0 +1,29 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_SELECT_HPP +#define TAOCPP_SEQUENCES_INCLUDE_SELECT_HPP + +#include <cstddef> +#include <type_traits> + +#include "integer_sequence.hpp" +#include "values.hpp" + +namespace tao +{ + namespace seq + { + template< std::size_t I, typename T, T... Ns > + struct select + : std::integral_constant< T, values< T, Ns... >::data[ I ] > + {}; + + template< std::size_t I, typename T, T... Ns > + struct select< I, integer_sequence< T, Ns... > > + : select< I, T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_SELECT_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/sum.hpp b/deps/tao_tuple/28626e99/include/tao/seq/sum.hpp new file mode 100644 index 0000000000..67ac671582 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/sum.hpp @@ -0,0 +1,72 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015-2016 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_SUM_HPP +#define TAOCPP_SEQUENCES_INCLUDE_SUM_HPP + +#include <type_traits> +#include <utility> + +#include "integer_sequence.hpp" +#include "config.hpp" + +#ifndef TAOCPP_FOLD_EXPRESSIONS +#include <cstddef> +#include "make_integer_sequence.hpp" +#endif + +namespace tao +{ + namespace seq + { + +#ifdef TAOCPP_FOLD_EXPRESSIONS + + template< typename T, T... Ns > + struct sum + : std::integral_constant< T, ( Ns + ... + T( 0 ) ) > + {}; + +#else + + namespace impl + { + template< std::size_t, std::size_t N > + struct chars + { + char dummy[ N + 1 ]; + }; + + template< typename, std::size_t... > + struct collector; + + template< std::size_t... Is, std::size_t... Ns > + struct collector< index_sequence< Is... >, Ns... > + : chars< Is, Ns >... + {}; + + template< std::size_t N, typename T, T... Ns > + struct sum + { + using type = std::integral_constant< + T, + T( sizeof( collector< make_index_sequence< N >, ( ( Ns > 0 ) ? Ns : 0 )... > ) - N ) - + T( sizeof( collector< make_index_sequence< N >, ( ( Ns < 0 ) ? -Ns : 0 )... > ) - N ) >; + }; + } + + template< typename T, T... Ns > + struct sum + : impl::sum< sizeof...( Ns ) + 1, T, Ns..., 0 >::type + {}; + +#endif + + template< typename T, T... Ns > + struct sum< integer_sequence< T, Ns... > > + : sum< T, Ns... > + {}; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_SUM_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/tail.hpp b/deps/tao_tuple/28626e99/include/tao/seq/tail.hpp new file mode 100644 index 0000000000..da0caa6f1a --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/tail.hpp @@ -0,0 +1,34 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_TAIL_HPP +#define TAOCPP_SEQUENCES_INCLUDE_TAIL_HPP + +#include <type_traits> + +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + template< typename T, T... Ns > + struct tail; + + template< typename T, T N, T... Ns > + struct tail< T, N, Ns... > + { + using type = integer_sequence< T, Ns... >; + }; + + template< typename T, T... Ns > + struct tail< integer_sequence< T, Ns... > > + : tail< T, Ns... > + {}; + + template< typename T, T... Ns > + using tail_t = typename tail< T, Ns... >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_TAIL_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/type_by_index.hpp b/deps/tao_tuple/28626e99/include/tao/seq/type_by_index.hpp new file mode 100644 index 0000000000..572c973c4e --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/type_by_index.hpp @@ -0,0 +1,57 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_TYPE_BY_INDEX_HPP +#define TAOCPP_SEQUENCES_INCLUDE_TYPE_BY_INDEX_HPP + +#include <cstddef> +#include <type_traits> + +#include "make_integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + // based on http://stackoverflow.com/questions/18942322 + + namespace impl + { + template< std::size_t > + struct any + { + any( ... ); + }; + + template< typename > + struct wrapper; + + template< typename > + struct unwrap; + + template< typename T > + struct unwrap< wrapper< T > > + { + using type = T; + }; + + template< typename > + struct get_nth; + + template< std::size_t... Is > + struct get_nth< index_sequence< Is... > > + { + template< typename T > + static T deduce( any< Is & 0 >..., T*, ... ); + }; + } + + template< std::size_t I, typename... Ts > + using type_by_index = impl::unwrap< decltype( impl::get_nth< make_index_sequence< I > >::deduce( std::declval< impl::wrapper< Ts >* >()... ) ) >; + + template< std::size_t I, typename... Ts > + using type_by_index_t = typename type_by_index< I, Ts... >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_TYPE_BY_INDEX_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/values.hpp b/deps/tao_tuple/28626e99/include/tao/seq/values.hpp new file mode 100644 index 0000000000..d7e3b5d8a1 --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/values.hpp @@ -0,0 +1,19 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_VALUES_HPP +#define TAOCPP_SEQUENCES_INCLUDE_VALUES_HPP + +namespace tao +{ + namespace seq + { + template< typename T, T... Ns > + struct values + { + static constexpr T data[] = { Ns... }; + }; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_VALUES_HPP diff --git a/deps/tao_tuple/28626e99/include/tao/seq/zip.hpp b/deps/tao_tuple/28626e99/include/tao/seq/zip.hpp new file mode 100644 index 0000000000..42683b408f --- /dev/null +++ b/deps/tao_tuple/28626e99/include/tao/seq/zip.hpp @@ -0,0 +1,30 @@ +// The Art of C++ / Sequences +// Copyright (c) 2015 Daniel Frey + +#ifndef TAOCPP_SEQUENCES_INCLUDE_ZIP_HPP +#define TAOCPP_SEQUENCES_INCLUDE_ZIP_HPP + +#include <type_traits> + +#include "integer_sequence.hpp" + +namespace tao +{ + namespace seq + { + template< template< typename U, U, U > class, typename, typename > + struct zip; + + template< template< typename U, U, U > class OP, typename TA, TA... As, typename TB, TB... Bs > + struct zip< OP, integer_sequence< TA, As... >, integer_sequence< TB, Bs... > > + { + using CT = typename std::common_type< TA, TB >::type; + using type = integer_sequence< CT, OP< CT, As, Bs >::value... >; + }; + + template< template< typename U, U, U > class OP, typename A, typename B > + using zip_t = typename zip< OP, A, B >::type; + } +} + +#endif // TAOCPP_SEQUENCES_INCLUDE_ZIP_HPP |