Subject: [Boost-commit] svn:boost r73160 - sandbox/conversion/boost/conversion/type_traits
From: vicente.botet_at_[hidden]
Date: 2011-07-17 04:40:22
Author: viboes
Date: 2011-07-17 04:40:21 EDT (Sun, 17 Jul 2011)
New Revision: 73160
URL: http://svn.boost.org/trac/boost/changeset/73160
Log:
conversion: added variadic version for is_constructible
Text files modified:
sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp | 175 +++++++++++++++++++++++++++++++++++++--
1 files changed, 166 insertions(+), 9 deletions(-)
Modified: sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp
==============================================================================
--- sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp (original)
+++ sandbox/conversion/boost/conversion/type_traits/is_constructible.hpp 2011-07-17 04:40:21 EDT (Sun, 17 Jul 2011)
@@ -68,11 +68,6 @@
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/remove_all_extents.hpp>
-
-#ifndef BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX
-#define BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX 3
-#endif
-
#if ! defined BOOST_NO_DECLTYPE
#if defined _MSC_VER
#if ! defined BOOST_NO_SFINAE_EXPR
@@ -130,6 +125,169 @@
template<std::size_t N>
struct dummy;
}
+}
+#ifndef BOOST_NO_VARIADIC_TEMPLATES
+namespace boost {
+ namespace type_traits_detail_is_constructible {
+
+
+ // template <class T, class... Args> struct is_constructible;
+
+ // main is_constructible test
+#if defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_DECLTYPE
+ #ifndef BOOST_NO_RVALUE_REFERENCES
+ template <class T, class ...Args>
+ //decltype(move(T(declval<Args>()...)), true_type())
+ decltype(T(declval<Args>()...), true_type())
+ test(T&&, Args&& ...);
+ template <class ...Args>
+ false_type
+ test(any, Args&& ...);
+ #else
+ template <class T, class ...Args>
+ decltype(T(declval<Args>()...), true_type())
+ test(T&, Args& ...);
+ template <class ...Args>
+ false_type
+ test(any, Args& ...);
+ #endif
+
+ template <bool, class T, class... Args>
+ struct imp // false, T is not a scalar
+ : public common_type
+ <
+ decltype(test(declval<T>(), declval<Args>()...))
+ >::type
+ {};
+#elif defined BOOST_CONVERSION_IS_CONSTRUCTIBLE_USES_SIZEOF
+
+ template <bool, class T, class... Args>
+ struct imp // false, T is not a scalar
+ {
+ template<class X>
+ static type_traits_detail_is_constructible::yes_type
+ test(type_traits_detail_is_constructible::dummy<sizeof(X(declval<Args>()...))>*);
+
+ template<class X>
+ static type_traits_detail_is_constructible::no_type
+ test(...);
+
+ static const bool value =
+ sizeof(test<T>(0)) == sizeof(type_traits_detail_is_constructible::yes_type);
+ typedef boost::integral_constant<bool,value> type;
+ };
+
+
+#else
+ template <bool, class T, class... Args>
+ struct imp // false, T is not a scalar
+ : public false_type
+ {};
+#endif
+
+ // function types are not constructible
+
+ template <class R, class... A1, class... A2>
+ struct imp<false, R(A1...), A2...>
+ : public false_type
+ {};
+
+ // handle scalars and reference types
+
+ // Scalars are default constructible, references are not
+
+ template <class T>
+ struct imp<true, T>
+ : public is_scalar<T>
+ {};
+
+ // Scalars and references are constructible from one arg if that arg is
+ // implicitly convertible to the scalar or reference.
+
+ template <class T, class A0>
+ struct imp<true, T, A0> : is_convertible<A0,T>
+ {};
+
+ // Scalars and references are not constructible from multiple args.
+
+ template <class T, class A0, class ...Args>
+ struct imp<true, T, A0, Args...>
+ : public false_type
+ {};
+
+ // Treat scalars and reference types separately
+
+ template <bool, class T, class... Args>
+ struct void_check
+ : public imp<is_scalar<T>::value || is_reference<T>::value,
+ T, Args...>
+ {};
+
+ // If any of T or Args is void, is_constructible should be false
+
+ template <class T, class... Args>
+ struct void_check<true, T, Args...>
+ : public false_type
+ {};
+
+ template <class ...Args> struct contains_void;
+
+ template <> struct contains_void<> : false_type {};
+
+ template <class A0, class ...Args>
+ struct contains_void<A0, Args...>
+ {
+ static const bool value = is_void<A0>::value ||
+ contains_void<Args...>::value;
+ };
+
+ }
+
+ // is_constructible entry point
+
+ template <class T, class... Args>
+ struct is_constructible
+ : public type_traits_detail_is_constructible::void_check<
+ type_traits_detail_is_constructible::contains_void<T, Args...>::value
+ || is_abstract<T>::value,
+ T, Args...>
+ {};
+
+ namespace type_traits_detail_is_constructible {
+
+ // Array types are default constructible if their element type
+ // is default constructible
+
+ template <class A, size_t N>
+ struct imp<false, A[N]>
+ : public is_constructible<typename remove_all_extents<A>::type>
+ {};
+
+ // Otherwise array types are not constructible by this syntax
+
+ template <class A, size_t N, class ...Args>
+ struct imp<false, A[N], Args...>
+ : public false_type
+ {};
+
+ // Incomplete array types are not constructible
+
+ template <class A, class ...Args>
+ struct imp<false, A[], Args...>
+ : public false_type
+ {};
+
+ }
+}
+#else // BOOST_NO_VARIADIC_TEMPLATES
+
+/////////////////
+
+#ifndef BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX
+#define BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX 3
+#endif
+
+namespace boost {
template <class T, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(BOOST_CONVERSION_TT_IS_CONSTRUCTIBLE_ARITY_MAX), class A, = type_traits_detail_is_constructible::nat BOOST_PP_INTERCEPT)> \
struct is_constructible;
@@ -349,10 +507,9 @@
}
-
-
}
-#endif
-#endif
+#endif // variadic
+#endif // doc
+#endif // header