boost/intrusive/detail/mpl.hpp
///////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2006-2009 // // Distributed under 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/intrusive for documentation. // ///////////////////////////////////////////////////////////////////////////// #ifndef BOOST_INTRUSIVE_DETAIL_MPL_HPP #define BOOST_INTRUSIVE_DETAIL_MPL_HPP #include <boost/intrusive/detail/config_begin.hpp> #include <cstddef> namespace boost { namespace intrusive { namespace detail { typedef char one; struct two {one _[2];}; template< bool C_ > struct bool_ { static const bool value = C_; }; typedef bool_<true> true_; typedef bool_<false> false_; typedef true_ true_type; typedef false_ false_type; typedef char yes_type; struct no_type { char padding[8]; }; template <bool B, class T = void> struct enable_if_c { typedef T type; }; template <class T> struct enable_if_c<false, T> {}; template <class Cond, class T = void> struct enable_if : public enable_if_c<Cond::value, T>{}; template<class F, class Param> struct apply { typedef typename F::template apply<Param>::type type; }; template <class T, class U> class is_convertible { typedef char true_t; class false_t { char dummy[2]; }; static true_t dispatch(U); static false_t dispatch(...); static const T &trigger(); public: static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); }; template< bool C , typename T1 , typename T2 > struct if_c { typedef T1 type; }; template< typename T1 , typename T2 > struct if_c<false,T1,T2> { typedef T2 type; }; template< typename C , typename T1 , typename T2 > struct if_ { typedef typename if_c<0 != C::value, T1, T2>::type type; }; template< bool C , typename F1 , typename F2 > struct eval_if_c : if_c<C,F1,F2>::type {}; template< typename C , typename T1 , typename T2 > struct eval_if : if_<C,T1,T2>::type {}; // identity is an extension: it is not part of the standard. template <class T> struct identity { typedef T type; }; #if defined(BOOST_MSVC) || defined(__BORLANDC_) #define BOOST_INTRUSIVE_TT_DECL __cdecl #else #define BOOST_INTRUSIVE_TT_DECL #endif #if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) #define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS #endif template <typename T> struct is_unary_or_binary_function_impl { static const bool value = false; }; template <typename R> struct is_unary_or_binary_function_impl<R (*)()> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (*)(...)> { static const bool value = true; }; /* #ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS template <typename R> struct is_unary_or_binary_function_impl<R (__stdcall*)()> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__stdcall*)(...)> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__stdcall*)(...)> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__fastcall*)()> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__fastcall*)(...)> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__cdecl*)()> { static const bool value = true; }; template <typename R> struct is_unary_or_binary_function_impl<R (__cdecl*)(...)> { static const bool value = true; }; #endif */ template <typename R, class T0> struct is_unary_or_binary_function_impl<R (*)(T0)> { static const bool value = true; }; template <typename R, class T0> struct is_unary_or_binary_function_impl<R (*)(T0...)> { static const bool value = true; }; #ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)> { static const bool value = true; }; /* template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__stdcall*)(T0...)> { static const bool value = true; }; template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)> { static const bool value = true; }; template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__fastcall*)(T0...)> { static const bool value = true; }; template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)> { static const bool value = true; }; template <typename R, class T0> struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)> { static const bool value = true; }; */ #endif template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (*)(T0, T1)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (*)(T0, T1...)> { static const bool value = true; }; /* #ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1...)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1...)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)> { static const bool value = true; }; template <typename R, class T0, class T1> struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)> { static const bool value = true; }; #endif */ template <typename T> struct is_unary_or_binary_function_impl<T&> { static const bool value = false; }; template<typename T> struct is_unary_or_binary_function { static const bool value = is_unary_or_binary_function_impl<T>::value; }; //boost::alignment_of yields to 10K lines of preprocessed code, so we //need an alternative template <typename T> struct alignment_of; template <typename T> struct alignment_of_hack { char c; T t; alignment_of_hack(); }; template <unsigned A, unsigned S> struct alignment_logic { static const std::size_t value = A < S ? A : S; }; template< typename T > struct alignment_of { static const std::size_t value = alignment_logic < sizeof(alignment_of_hack<T>) - sizeof(T) , sizeof(T) >::value; }; template <typename T, typename U> struct is_same { typedef char yes_type; struct no_type { char padding[8]; }; template <typename V> static yes_type is_same_tester(V*, V*); static no_type is_same_tester(...); static T *t; static U *u; static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u)); }; template<typename T> struct add_const { typedef const T type; }; template<typename T> struct remove_const { typedef T type; }; template<typename T> struct remove_const<const T> { typedef T type; }; template<class T> struct remove_reference { typedef T type; }; template<class T> struct remove_reference<T&> { typedef T type; }; template<class Class> class is_empty_class { template <typename T> struct empty_helper_t1 : public T { empty_helper_t1(); int i[256]; }; struct empty_helper_t2 { int i[256]; }; public: static const bool value = sizeof(empty_helper_t1<Class>) == sizeof(empty_helper_t2); }; template<std::size_t S> struct ls_zeros { static const std::size_t value = (S & std::size_t(1)) ? 0 : (1 + ls_zeros<(S>>1u)>::value); }; template<> struct ls_zeros<0> { static const std::size_t value = 0; }; template<> struct ls_zeros<1> { static const std::size_t value = 0; }; } //namespace detail } //namespace intrusive } //namespace boost #include <boost/intrusive/detail/config_end.hpp> #endif //BOOST_INTRUSIVE_DETAIL_MPL_HPP