Merge pull request #1754 from evoskuil/master

Set preprocessor conformance in vc++, add decay_tuple.

Author: evoskuil

builds/msvc/properties/Common.props

@@ -27,7 +27,7 @@
 
       <!-- Language -->
       <!-- /Zc is conformance mode. -->
-      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>/Zc:__cplusplus /Zc:preprocessor %(AdditionalOptions)</AdditionalOptions>
       <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>

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,6 +151,25 @@ 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.
+/// ---------------------------------------------------------------------------
+
+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;
+
+template <typename ...Args>
+struct decay_tuple<std::tuple<Args...>>
+{
+    using type = std::tuple<std::decay_t<Args>...>;
+};
+
 /// uintx_t detection.
 /// ---------------------------------------------------------------------------
 

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,6 +417,62 @@ 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.
+// ----------------------------------------------------------------------------
+// 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>>);
+static_assert(!is_same_type<decay_tuple<test_tuple>, test_tuple>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, test_tuple>::type, int>);
+static_assert(!std::is_same_v<std::tuple_element<1, test_tuple>::type, bool>);
+static_assert(!std::is_same_v<std::tuple_element<2, test_tuple>::type, std::string>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, test_tuple>::type, const int>);
+static_assert(!std::is_same_v<std::tuple_element<1, test_tuple>::type, const bool>);
+static_assert(!std::is_same_v<std::tuple_element<2, test_tuple>::type, const std::string>);
+
+static_assert( std::is_same_v<std::tuple_element<0, test_tuple>::type, int&>);
+static_assert(!std::is_same_v<std::tuple_element<1, test_tuple>::type, bool&>);
+static_assert(!std::is_same_v<std::tuple_element<2, test_tuple>::type, std::string&>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, test_tuple>::type, int&&>);
+static_assert( std::is_same_v<std::tuple_element<1, test_tuple>::type, bool&&>);
+static_assert(!std::is_same_v<std::tuple_element<2, test_tuple>::type, std::string&&>);
+
+using normal_test_tuple = std::tuple<int, bool, std::string>;
+using decayed_test_tuple = decay_tuple<test_tuple>::type;
+static_assert(is_same_type<normal_test_tuple, decayed_test_tuple>);
+
+static_assert(std::is_same_v<std::tuple_element<0, decayed_test_tuple>::type, int>);
+static_assert(std::is_same_v<std::tuple_element<1, decayed_test_tuple>::type, bool>);
+static_assert(std::is_same_v<std::tuple_element<2, decayed_test_tuple>::type, std::string>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, decayed_test_tuple>::type, const int>);
+static_assert(!std::is_same_v<std::tuple_element<1, decayed_test_tuple>::type, const bool>);
+static_assert(!std::is_same_v<std::tuple_element<2, decayed_test_tuple>::type, const std::string>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, decayed_test_tuple>::type, int&>);
+static_assert(!std::is_same_v<std::tuple_element<1, decayed_test_tuple>::type, bool&>);
+static_assert(!std::is_same_v<std::tuple_element<2, decayed_test_tuple>::type, std::string&>);
+
+static_assert(!std::is_same_v<std::tuple_element<0, decayed_test_tuple>::type, int&&>);
+static_assert(!std::is_same_v<std::tuple_element<1, decayed_test_tuple>::type, bool&&>);
+static_assert(!std::is_same_v<std::tuple_element<2, decayed_test_tuple>::type, std::string&&>);
+
+// is_uintx
+// ----------------------------------------------------------------------------
+
 static_assert(is_uintx<uint5_t>);
 static_assert(is_uintx<uint11_t>);
 static_assert(is_uintx<uint48_t>);