123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279 |
- // (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
- //
- // Use, modification and distribution are subject to the Boost Software License,
- // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- // http://www.boost.org/LICENSE_1_0.txt).
- //
- // See http://www.boost.org/libs/type_traits for most recent version including documentation.
- #include <boost/config.hpp>
- #include <boost/type_traits/detail/config.hpp>
- // cannot include this header without getting warnings of the kind:
- // gcc:
- // warning: value computed is not used
- // warning: comparison between signed and unsigned integer expressions
- // msvc:
- // warning C4018: '<' : signed/unsigned mismatch
- // warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data
- // warning C4547: '*' : operator before comma has no effect; expected operator with side-effect
- // warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
- // warning C4804: '<' : unsafe use of type 'bool' in operation
- // warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
- // cannot find another implementation -> declared as system header to suppress these warnings.
- #if defined(__GNUC__)
- # pragma GCC system_header
- #elif defined(BOOST_MSVC)
- # pragma warning ( push )
- # pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133)
- # if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
- # pragma warning ( disable : 6334)
- # endif
- #endif
- #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
- #include <boost/type_traits/integral_constant.hpp>
- #include <boost/type_traits/make_void.hpp>
- #include <boost/type_traits/is_convertible.hpp>
- #include <boost/type_traits/is_void.hpp>
- #include <boost/type_traits/add_reference.hpp>
- #include <utility>
- namespace boost
- {
- namespace binary_op_detail {
- struct dont_care;
- template <class T, class U, class Ret, class = void>
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {};
- template <class T, class U, class Ret>
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type>
- : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>()), Ret>::value> {};
- template <class T, class U, class = void >
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {};
- template <class T, class U>
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type>
- : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::value> {};
- template <class T, class U, class = void>
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {};
- template <class T, class U>
- struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type>
- : public boost::true_type {};
- }
- template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
- struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, U, Ret> {};
- template <class T, class U>
- struct BOOST_TT_TRAIT_NAME<T, U, void> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T, U> {};
- template <class T, class U>
- struct BOOST_TT_TRAIT_NAME<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T, U> {};
- }
- #else
- #include <boost/type_traits/detail/yes_no_type.hpp>
- #include <boost/type_traits/integral_constant.hpp>
- #include <boost/type_traits/is_base_of.hpp>
- #include <boost/type_traits/is_const.hpp>
- #include <boost/type_traits/is_convertible.hpp>
- #include <boost/type_traits/is_fundamental.hpp>
- #include <boost/type_traits/is_integral.hpp>
- #include <boost/type_traits/is_pointer.hpp>
- #include <boost/type_traits/is_same.hpp>
- #include <boost/type_traits/is_void.hpp>
- #include <boost/type_traits/remove_cv.hpp>
- #include <boost/type_traits/remove_pointer.hpp>
- #include <boost/type_traits/remove_reference.hpp>
- #include <boost/type_traits/detail/is_likely_lambda.hpp>
- namespace boost {
- namespace detail {
- // This namespace ensures that argument-dependent name lookup does not mess things up.
- namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
- // 1. a function to have an instance of type T without requiring T to be default
- // constructible
- template <typename T> T &make();
- // 2. we provide our operator definition for types that do not have one already
- // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
- // found in the type's own namespace (our own operator is used) so that we have
- // a means to know that our operator was used
- struct no_operator { };
- // this class allows implicit conversions and makes the following operator
- // definition less-preferred than any other such operators that might be found
- // via argument-dependent name lookup
- struct any { template <class T> any(T const&); };
- // when operator BOOST_TT_TRAIT_OP is not available, this one is used
- no_operator operator BOOST_TT_TRAIT_OP (const any&, const any&);
- // 3. checks if the operator returns void or not
- // conditions: Lhs!=void and Rhs!=void
- // we first redefine "operator," so that we have no compilation error if
- // operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
- // (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
- // operator BOOST_TT_TRAIT_OP returns void or not:
- // - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
- // - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
- struct returns_void_t { };
- template <typename T> int operator,(const T&, returns_void_t);
- template <typename T> int operator,(const volatile T&, returns_void_t);
- // this intermediate trait has member value of type bool:
- // - value==true -> operator BOOST_TT_TRAIT_OP returns void
- // - value==false -> operator BOOST_TT_TRAIT_OP does not return void
- template < typename Lhs, typename Rhs >
- struct operator_returns_void {
- // overloads of function returns_void make the difference
- // yes_type and no_type have different size by construction
- static ::boost::type_traits::yes_type returns_void(returns_void_t);
- static ::boost::type_traits::no_type returns_void(int);
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
- };
- // 4. checks if the return type is Ret or Ret==dont_care
- // conditions: Lhs!=void and Rhs!=void
- struct dont_care { };
- template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
- struct operator_returns_Ret;
- template < typename Lhs, typename Rhs >
- struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template < typename Lhs, typename Rhs >
- struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template < typename Lhs, typename Rhs >
- struct operator_returns_Ret < Lhs, Rhs, void, true > {
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
- template < typename Lhs, typename Rhs >
- struct operator_returns_Ret < Lhs, Rhs, void, false > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- template < typename Lhs, typename Rhs, typename Ret >
- struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- // otherwise checks if it is convertible to Ret using the sizeof trick
- // based on overload resolution
- // condition: Ret!=void and Ret!=dont_care and the operator does not return void
- template < typename Lhs, typename Rhs, typename Ret >
- struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
- static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
- static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
- };
- // 5. checks for operator existence
- // condition: Lhs!=void and Rhs!=void
- // checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
- // existing one;
- // this is done with redefinition of "operator," that returns no_operator or has_operator
- struct has_operator { };
- no_operator operator,(no_operator, has_operator);
- template < typename Lhs, typename Rhs >
- struct operator_exists {
- static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
- static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
- };
- // 6. main trait: to avoid any compilation error, this class behaves
- // differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the
- // standard.
- // Forbidden_if is a bool that is:
- // - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
- // (would yield compilation error if used)
- // - false otherwise
- template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
- struct trait_impl1;
- template < typename Lhs, typename Rhs, typename Ret >
- struct trait_impl1 < Lhs, Rhs, Ret, true > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- template < typename Lhs, typename Rhs, typename Ret >
- struct trait_impl1 < Lhs, Rhs, Ret, false > {
- BOOST_STATIC_CONSTANT(bool,
- value = (operator_exists < Lhs, Rhs >::value && operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value));
- };
- // some specializations needs to be declared for the special void case
- template < typename Rhs, typename Ret >
- struct trait_impl1 < void, Rhs, Ret, false > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- template < typename Lhs, typename Ret >
- struct trait_impl1 < Lhs, void, Ret, false > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- template < typename Ret >
- struct trait_impl1 < void, void, Ret, false > {
- BOOST_STATIC_CONSTANT(bool, value = false);
- };
- // defines some typedef for convenience
- template < typename Lhs, typename Rhs, typename Ret >
- struct trait_impl {
- typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
- typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
- typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
- typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
- typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
- typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
- BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
- };
- } // namespace impl
- } // namespace detail
- // this is the accessible definition of the trait to end user
- template <class Lhs, class Rhs=Lhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care>
- struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl < Lhs, Rhs, Ret >::value)>{};
- } // namespace boost
- #endif
- #if defined(BOOST_MSVC)
- # pragma warning ( pop )
- #endif
|