Implement is_tuple<>/if_tuple<>.

Author: evoskuil

include/bitcoin/system/constraints.hpp

@@ -259,7 +259,7 @@ template <typename Integer>
 using if_floating_point = bool_if<
     is_floating_point<Integer>>;
 
-/// std::array/std::vector
+/// std::array/std::vector/std::tuple
 
 template <typename Type>
 using if_std_array = bool_if<
@@ -274,6 +274,10 @@ using if_integral_array = bool_if<
     is_std_array<Type> &&
     is_integral_integer<typename Type::value_type>>;
 
+template <typename Type>
+using if_tuple = bool_if<
+    is_tuple<Type>>;
+
 template <typename Type>
 using if_byte_insertable = bool_if<
     std::is_base_of<std::string, Type>::value ||

include/bitcoin/system/typelets.hpp

@@ -97,7 +97,7 @@ constexpr size_t bits = to_bits(sizeof(Type));
 template <size_t Bits, std::enable_if_t<is_byte_sized(Bits), bool> = true>
 constexpr size_t bytes = Bits / byte_bits;
 
-/// std_array.
+/// std_array/std_vector.
 /// ---------------------------------------------------------------------------
 
 template<typename>
@@ -140,7 +140,7 @@ constexpr size_t size_of()
 
     // Type constraint fails to match as throw is not constexpr.
     if (count > (std::numeric_limits<size_t>::max() / size))
-        throw overflow_exception("type contraint violated");
+        throw overflow_exception("type constraint violated");
 
     return size * count;
 }
@@ -151,9 +151,16 @@ template <typename Larger, typename Smaller, size_t Lanes = one,
     ////std::enable_if_t<Lanes <= (max_size_t / size_of<Smaller>()), bool> = true>
 constexpr size_t capacity = size_of<Larger>() / (Lanes * size_of<Smaller>());
 
-/// std::tuple decay elements.
+/// std::tuple.
 /// ---------------------------------------------------------------------------
 
+template <typename, typename = void>
+struct is_tuple_t : std::false_type {};
+template <typename ...Args>
+struct is_tuple_t<std::tuple<Args...>> : std::true_type {};
+template<typename Type>
+constexpr bool is_tuple = is_tuple_t<Type>::value;
+
 template <typename Tuple>
 struct decay_tuple;
 

test/constraints.cpp

@@ -645,6 +645,12 @@ static_assert(is_defined<if_integral_array<std_array<uint8_t, 0>>>);
 ////static_assert(!is_defined<if_integral_array<std_array<base, 0>>>);
 ////static_assert(!is_defined<if_integral_array<uint8_t>>);
 
+static_assert(is_defined<if_tuple<std::tuple<>>>);
+static_assert(is_defined<if_tuple<std::tuple<uint8_t, bool>>>);
+////static_assert(!is_defined<if_tuple<std_array<uint8_t, 0>>>);
+////static_assert(!is_defined<if_tuple<uint8_t>>);
+////static_assert(!is_defined<if_tuple<bool>>);
+
 static_assert(is_defined<if_byte_insertable<std::string>>);
 static_assert(is_defined<if_byte_insertable<std::vector<uint8_t>>>);
 static_assert(is_defined<if_byte_insertable<std_vector<uint8_t>>>);

test/typelets.cpp

@@ -417,11 +417,18 @@ static_assert(size_of<std_array<const volatile std_array<std_array<uint32_t, 42>
 static_assert(size_of<std_array<std_array<const volatile std_array<uint32_t, 42>, 24>, 8>>() == sizeof(uint32_t) * 42 * 24 * 8);
 static_assert(size_of<const volatile std_array<const volatile std_array<const volatile std_array<uint32_t, 42>, 24>, 8>&>() == sizeof(uint32_t) * 42 * 24 * 8);
 
-
-// std::tuple decay elements.
+// std::tuple.
 // ----------------------------------------------------------------------------
 // is_same_type decays individual types (but not tuple elements).
 
+static_assert(!is_tuple<uint8_t>);
+static_assert(!is_tuple<std::string>);
+static_assert(!is_tuple<std::array<uint8_t, 42>>);
+static_assert( is_tuple<std::tuple<int, bool>>);
+static_assert( is_tuple<std::tuple<>>);
+static_assert( is_same_type<decltype(is_tuple<std_array<uint8_t, 0>>), const bool>);
+static_assert( is_same_type<decltype(is_tuple<std::tuple<int, bool>&>), const bool>);
+
 using test_tuple = std::tuple<int&, bool&&, const std::string&>;
 static_assert( is_same_type<decay_tuple<test_tuple>, decay_tuple<test_tuple>>);
 static_assert(!is_same_type<test_tuple, decay_tuple<test_tuple>>);