fix type_traits implementations

sprout/type_traits/is_copy_assignable.hpp

@@ -10,15 +10,25 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 
 namespace sprout {
 	//
 	// is_copy_assignable
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_copy_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_copy_assignable_impl<T, false>
+			: public std::is_assignable<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_copy_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_copy_assignable<T> >
+		: public sprout::detail::is_copy_assignable_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_copy_constructible.hpp

@@ -10,15 +10,25 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 
 namespace sprout {
 	//
 	// is_copy_constructible
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_copy_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_copy_constructible_impl<T, false>
+			: public std::is_constructible<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_copy_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_copy_constructible<T> >
+		: public sprout::detail::is_copy_constructible_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_move_assignable.hpp

@@ -10,15 +10,25 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 
 namespace sprout {
 	//
 	// is_move_assignable
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_move_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_move_assignable_impl<T, false>
+			: public std::is_assignable<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_move_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_move_assignable<T> >
+		: public sprout::detail::is_move_assignable_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_move_constructible.hpp

@@ -10,15 +10,25 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 
 namespace sprout {
 	//
 	// is_move_constructible
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_move_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_move_constructible_impl<T, false>
+			: public std::is_constructible<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_move_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_move_constructible<T> >
+		: public sprout::detail::is_move_constructible_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_nothrow_copy_assignable.hpp

@@ -10,15 +10,26 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/is_nothrow_assignable.hpp>
 
 namespace sprout {
 	//
 	// is_nothrow_copy_assignable
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_nothrow_copy_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_nothrow_copy_assignable_impl<T, false>
+			: public sprout::is_nothrow_assignable<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_nothrow_copy_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_nothrow_copy_assignable<T> >
+		: public sprout::detail::is_nothrow_copy_assignable_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_nothrow_copy_constructible.hpp

@@ -10,15 +10,26 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/is_nothrow_constructible.hpp>
 
 namespace sprout {
 	//
 	// is_nothrow_copy_constructible
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_nothrow_copy_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_nothrow_copy_constructible_impl<T, false>
+			: public sprout::is_nothrow_constructible<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_nothrow_copy_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_nothrow_copy_constructible<T> >
+		: public sprout::detail::is_nothrow_copy_constructible_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_nothrow_move_assignable.hpp

@@ -10,15 +10,26 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/is_nothrow_assignable.hpp>
 
 namespace sprout {
 	//
 	// is_nothrow_move_assignable
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_nothrow_move_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_nothrow_move_assignable_impl<T, false>
+			: public sprout::is_nothrow_assignable<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_nothrow_move_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_nothrow_move_assignable<T> >
+		: public sprout::detail::is_nothrow_move_assignable_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_nothrow_move_constructible.hpp

@@ -10,15 +10,26 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/is_nothrow_constructible.hpp>
 
 namespace sprout {
 	//
 	// is_nothrow_move_constructible
 	//
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_nothrow_move_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_nothrow_move_constructible_impl<T, false>
+			: public sprout::is_nothrow_constructible<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_nothrow_move_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_nothrow_move_constructible<T> >
+		: public sprout::detail::is_nothrow_move_constructible_impl<T>
 	{};
 
 #if SPROUT_USE_VARIABLE_TEMPLATES

sprout/type_traits/is_trivially_copy_assignable.hpp

@@ -10,27 +10,27 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 #include <sprout/type_traits/is_trivially_assignable.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
 
 namespace sprout {
 	//
 	// is_trivially_copy_assignable
 	//
-#if !defined(_LIBCPP_VERSION)
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_trivially_copy_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_trivially_copy_assignable_impl<T, false>
+			: public sprout::is_trivially_assignable<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_trivially_copy_assignable
-		: public sprout::is_trivially_assignable<
+		: public sprout::detail::is_trivially_copy_assignable_impl<T>
-			typename std::add_lvalue_reference<T>::type,
-			typename std::add_lvalue_reference<T>::type const
-		>
 	{};
-#else	// #if !defined(_LIBCPP_VERSION)
-	template<typename T>
-	struct is_trivially_copy_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_trivially_copy_assignable<T> >
-	{};
-#endif	// #if !defined(_LIBCPP_VERSION)
 
 #if SPROUT_USE_VARIABLE_TEMPLATES
 	template<typename T>

sprout/type_traits/is_trivially_copy_constructible.hpp

@@ -10,24 +10,27 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 #include <sprout/type_traits/is_trivially_constructible.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
 
 namespace sprout {
 	//
 	// is_trivially_copy_constructible
 	//
-#if !defined(_LIBCPP_VERSION)
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_trivially_copy_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_trivially_copy_constructible_impl<T, false>
+			: public sprout::is_trivially_constructible<T, T const&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_trivially_copy_constructible
-		: public sprout::is_trivially_constructible<T, typename std::add_lvalue_reference<T>::type const>
+		: public sprout::detail::is_trivially_copy_constructible_impl<T>
 	{};
-#else	// #if !defined(_LIBCPP_VERSION)
-	template<typename T>
-	struct is_trivially_copy_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_trivially_copy_constructible<T> >
-	{};
-#endif	// #if !defined(_LIBCPP_VERSION)
 
 #if SPROUT_USE_VARIABLE_TEMPLATES
 	template<typename T>

sprout/type_traits/is_trivially_move_assignable.hpp

@@ -10,27 +10,27 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 #include <sprout/type_traits/is_trivially_assignable.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
 
 namespace sprout {
 	//
 	// is_trivially_move_assignable
 	//
-#if !defined(_LIBCPP_VERSION)
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_trivially_move_assignable_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_trivially_move_assignable_impl<T, false>
+			: public sprout::is_trivially_assignable<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_trivially_move_assignable
-		: public sprout::is_trivially_assignable<
+		: public sprout::detail::is_trivially_move_assignable_impl<T>
-			typename std::add_lvalue_reference<T>::type,
-			typename std::add_rvalue_reference<T>::type
-		>
 	{};
-#else	// #if !defined(_LIBCPP_VERSION)
-	template<typename T>
-	struct is_trivially_move_assignable
-		: public sprout::detail::type_traits_wrapper<std::is_trivially_move_assignable<T> >
-	{};
-#endif	// #if !defined(_LIBCPP_VERSION)
 
 #if SPROUT_USE_VARIABLE_TEMPLATES
 	template<typename T>

sprout/type_traits/is_trivially_move_constructible.hpp

@@ -10,24 +10,27 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 #include <sprout/type_traits/is_trivially_constructible.hpp>
-#include <sprout/type_traits/detail/type_traits_wrapper.hpp>
 
 namespace sprout {
 	//
 	// is_trivially_move_constructible
 	//
-#if !defined(_LIBCPP_VERSION)
+	namespace detail {
+		template<typename T, bool = std::is_void<T>::value>
+		struct is_trivially_move_constructible_impl
+			: public sprout::false_type
+		{};
+		template<typename T>
+		struct is_trivially_move_constructible_impl<T, false>
+			: public sprout::is_trivially_constructible<T, T&&>
+		{};
+	}	// namespace detail
 	template<typename T>
 	struct is_trivially_move_constructible
-		: public sprout::is_trivially_constructible<T, typename std::add_rvalue_reference<T>::type>
+		: public sprout::detail::is_trivially_move_constructible_impl<T>
 	{};
-#else	// #if !defined(_LIBCPP_VERSION)
-	template<typename T>
-	struct is_trivially_move_constructible
-		: public sprout::detail::type_traits_wrapper<std::is_trivially_move_constructible<T> >
-	{};
-#endif	// #if !defined(_LIBCPP_VERSION)
 
 #if SPROUT_USE_VARIABLE_TEMPLATES
 	template<typename T>