diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/function_types/components.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/function_types/components.hpp | 431 |
1 files changed, 0 insertions, 431 deletions
diff --git a/src/third_party/boost-1.56.0/boost/function_types/components.hpp b/src/third_party/boost-1.56.0/boost/function_types/components.hpp deleted file mode 100644 index 53d81b60dc7..00000000000 --- a/src/third_party/boost-1.56.0/boost/function_types/components.hpp +++ /dev/null @@ -1,431 +0,0 @@ - -// (C) Copyright Tobias Schwinger -// -// Use modification and distribution are subject to the boost Software License, -// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt). - -//------------------------------------------------------------------------------ - -#ifndef BOOST_FT_COMPONENTS_HPP_INCLUDED -#define BOOST_FT_COMPONENTS_HPP_INCLUDED - -#include <cstddef> - -#include <boost/config.hpp> - -#include <boost/detail/workaround.hpp> -#include <boost/mpl/aux_/lambda_support.hpp> -#include <boost/type_traits/detail/template_arity_spec.hpp> - -#include <boost/type_traits/integral_constant.hpp> - -#include <boost/mpl/if.hpp> -#include <boost/mpl/integral_c.hpp> -#include <boost/mpl/vector/vector0.hpp> - -#if BOOST_WORKAROUND(__BORLANDC__, <= 0x565) -# include <boost/type_traits/remove_cv.hpp> - -# include <boost/mpl/identity.hpp> -# include <boost/mpl/bitand.hpp> -# include <boost/mpl/vector/vector10.hpp> -# include <boost/mpl/front.hpp> -# include <boost/mpl/begin.hpp> -# include <boost/mpl/advance.hpp> -# include <boost/mpl/iterator_range.hpp> -# include <boost/mpl/joint_view.hpp> -# include <boost/mpl/equal_to.hpp> -# include <boost/mpl/copy.hpp> -# include <boost/mpl/front_inserter.hpp> - -# include <boost/function_types/detail/classifier.hpp> -#endif - -#ifndef BOOST_FT_NO_CV_FUNC_SUPPORT -# include <boost/mpl/remove.hpp> -#endif - -#include <boost/function_types/config/config.hpp> - -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -# if BOOST_FT_MAX_ARITY < 10 -# include <boost/mpl/vector/vector10.hpp> -# elif BOOST_FT_MAX_ARITY < 20 -# include <boost/mpl/vector/vector20.hpp> -# elif BOOST_FT_MAX_ARITY < 30 -# include <boost/mpl/vector/vector30.hpp> -# elif BOOST_FT_MAX_ARITY < 40 -# include <boost/mpl/vector/vector40.hpp> -# elif BOOST_FT_MAX_ARITY < 50 -# include <boost/mpl/vector/vector50.hpp> -# endif -#else -# include <boost/function_types/detail/classifier.hpp> -#endif - -#include <boost/function_types/detail/class_transform.hpp> -#include <boost/function_types/property_tags.hpp> - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -namespace boost -{ - namespace function_types - { - - using mpl::placeholders::_; - - template< typename T, typename ClassTypeTransform = add_reference<_> > - struct components; - - namespace detail - { - template<typename T, typename L> struct components_impl; -#if BOOST_WORKAROUND(__BORLANDC__, <= 0x565) - template<typename T, typename OrigT, typename L> struct components_bcc; -#endif - } - - template<typename T, typename ClassTypeTransform> - struct components -#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x565) - : detail::components_impl<T, ClassTypeTransform> -#else - : detail::components_bcc<typename remove_cv<T>::type,T, - ClassTypeTransform> -#endif - { - typedef components<T,ClassTypeTransform> type; - - BOOST_MPL_AUX_LAMBDA_SUPPORT(2,components,(T,ClassTypeTransform)) - }; - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - namespace detail { - - struct components_mpl_sequence_tag; - - struct components_non_func_base - { - typedef mpl::vector0<> types; - typedef void function_arity; - - typedef detail::constant<0> bits; - typedef detail::constant<0> mask; - - typedef components_mpl_sequence_tag tag; - }; - - template - < typename Components - , typename IfTagged - , typename ThenTag - , typename DefaultBase = components_non_func_base - > - struct retagged_if - : mpl::if_ - < detail::represents_impl<Components, IfTagged> - , detail::changed_tag<Components,IfTagged,ThenTag> - , DefaultBase - >::type - { }; - - // We detect plain function types and function references as function - // pointers by recursive instantiation of components_impl. - // The third specialization of components_impl makes sure the recursion - // terminates (when adding pointers). - template<typename T, typename L> - struct components_impl - : detail::retagged_if - < detail::components_impl<T*,L> - , pointer_tag, /* --> */ function_tag > - { }; - template<typename T, typename L> - struct components_impl<T&, L> - : detail::retagged_if - < detail::components_impl<T*,L> - , pointer_tag, /* --> */ reference_tag > - { }; - -#if !BOOST_FT_NO_CV_FUNC_SUPPORT - // Retry the type with a member pointer attached to detect cv functions - class a_class; - - template<typename Base, typename T, typename L> - struct cv_func_base - : detail::retagged_if<Base,member_pointer_tag,function_tag> - { - typedef typename - mpl::remove - < typename Base::types - , typename detail::class_transform<a_class,L>::type>::type - types; - }; - - template<typename T, typename L> - struct components_impl<T*, L> - : mpl::if_ - < detail::represents_impl< detail::components_impl<T a_class::*, L> - , member_pointer_tag > - , detail::cv_func_base< detail::components_impl<T a_class::*, L>, T, L> - , components_non_func_base - >::type - { }; - - template<typename T, typename L> - struct components_impl<T a_class::*, L> - : components_non_func_base - { }; -#else - template<typename T, typename L> - struct components_impl<T*, L> - : components_non_func_base - { }; -#endif - - template<typename T, typename L> - struct components_impl<T* const, L> - : components_impl<T*,L> - { }; - - template<typename T, typename L> - struct components_impl<T* volatile, L> - : components_impl<T*,L> - { }; - - template<typename T, typename L> - struct components_impl<T* const volatile, L> - : components_impl<T*,L> - { }; - - template<typename T, typename L> - struct components_impl<T const, L> - : components_impl<T,L> - { }; - - template<typename T, typename L> - struct components_impl<T volatile, L> - : components_impl<T,L> - { }; - - template<typename T, typename L> - struct components_impl<T const volatile, L> - : components_impl<T,L> - { }; - - - template<typename T, class C> - struct member_obj_ptr_result - { typedef T & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T, C const> - { typedef T const & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T, C volatile> - { typedef T volatile & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T, C const volatile> - { typedef T const volatile & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T &, C> - { typedef T & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T &, C const> - { typedef T & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T &, C volatile> - { typedef T & type; }; - - template<typename T, class C> - struct member_obj_ptr_result<T &, C const volatile> - { typedef T & type; }; - - template<typename T, class C, typename L> - struct member_obj_ptr_components - : member_object_pointer_base - { - typedef function_types::components<T C::*, L> type; - typedef components_mpl_sequence_tag tag; - - typedef mpl::integral_c<std::size_t,1> function_arity; - - typedef mpl::vector2< typename detail::member_obj_ptr_result<T,C>::type, - typename detail::class_transform<C,L>::type > types; - }; - -#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x565) -# define BOOST_FT_variations BOOST_FT_pointer|BOOST_FT_member_pointer - - template<typename T, class C, typename L> - struct components_impl<T C::*, L> - : member_obj_ptr_components<T,C,L> - { }; - -#else -# define BOOST_FT_variations BOOST_FT_pointer - - // This workaround removes the member pointer from the type to allow - // detection of member function pointers with BCC. - template<typename T, typename C, typename L> - struct components_impl<T C::*, L> - : detail::retagged_if - < detail::components_impl<typename boost::remove_cv<T>::type *, L> - , pointer_tag, /* --> */ member_function_pointer_tag - , member_obj_ptr_components<T,C,L> > - { }; - - // BCC lets us test the cv-qualification of a function type by template - // partial specialization - so we use this bug feature to find out the - // member function's cv-qualification (unfortunately there are some - // invisible modifiers that impose some limitations on these types even if - // we remove the qualifiers, So we cannot exploit the same bug to make the - // library work for cv-qualified function types). - template<typename T> struct encode_cv - { typedef char (& type)[1]; BOOST_STATIC_CONSTANT(std::size_t, value = 1); }; - template<typename T> struct encode_cv<T const *> - { typedef char (& type)[2]; BOOST_STATIC_CONSTANT(std::size_t, value = 2); }; - template<typename T> struct encode_cv<T volatile *> - { typedef char (& type)[3]; BOOST_STATIC_CONSTANT(std::size_t, value = 3); }; - template<typename T> struct encode_cv<T const volatile *> - { typedef char (& type)[4]; BOOST_STATIC_CONSTANT(std::size_t, value = 4); }; - - // For member function pointers we have to use a function template (partial - // template specialization for a member pointer drops the cv qualification - // of the function type). - template<typename T, typename C> - typename encode_cv<T *>::type mfp_cv_tester(T C::*); - - template<typename T> struct encode_mfp_cv - { - BOOST_STATIC_CONSTANT(std::size_t, value = - sizeof(detail::mfp_cv_tester((T)0L))); - }; - - // Associate bits with the CV codes above. - template<std::size_t> struct cv_tag_mfp_impl; - - template<typename T> struct cv_tag_mfp - : detail::cv_tag_mfp_impl - < ::boost::function_types::detail::encode_mfp_cv<T>::value > - { }; - - template<> struct cv_tag_mfp_impl<1> : non_cv { }; - template<> struct cv_tag_mfp_impl<2> : const_non_volatile { }; - template<> struct cv_tag_mfp_impl<3> : volatile_non_const { }; - template<> struct cv_tag_mfp_impl<4> : cv_qualified { }; - - // Metafunction to decode the cv code and apply it to a type. - // We add a pointer, because otherwise cv-qualifiers won't stick (another bug). - template<typename T, std::size_t CV> struct decode_cv; - - template<typename T> struct decode_cv<T,1> : mpl::identity<T *> {}; - template<typename T> struct decode_cv<T,2> : mpl::identity<T const *> {}; - template<typename T> struct decode_cv<T,3> : mpl::identity<T volatile *> {}; - template<typename T> struct decode_cv<T,4> - : mpl::identity<T const volatile *> {}; - - // The class type transformation comes after adding cv-qualifiers. We have - // wrap it to remove the pointer added in decode_cv_impl. - template<typename T, typename L> struct bcc_class_transform_impl; - template<typename T, typename L> struct bcc_class_transform_impl<T *, L> - : class_transform<T,L> - { }; - - template<typename T, typename D, typename L> struct bcc_class_transform - : bcc_class_transform_impl - < typename decode_cv - < T - , ::boost::function_types::detail::encode_mfp_cv<D>::value - >::type - , L - > - { }; - - // After extracting the member pointee from the type the class type is still - // in the type (somewhere -- you won't see with RTTI, that is) and that type - // is flagged unusable and *not* identical to the nonmember function type. - // We can, however, decompose this type via components_impl but surprisingly - // a pointer to the const qualified class type pops up again as the first - // parameter type. - // We have to replace this type with the properly cv-qualified and - // transformed class type, integrate the cv qualification into the bits. - template<typename Base, typename MFP, typename OrigT, typename L> - struct mfp_components; - - - template<typename Base, typename T, typename C, typename OrigT, typename L> - struct mfp_components<Base,T C::*,OrigT,L> - { - private: - typedef typename mpl::front<typename Base::types>::type result_type; - typedef typename detail::bcc_class_transform<C,OrigT,L>::type class_type; - - typedef mpl::vector2<result_type, class_type> result_and_class_type; - - typedef typename - mpl::advance - < typename mpl::begin<typename Base::types>::type - , typename mpl::if_ - < mpl::equal_to< typename detail::classifier<OrigT>::function_arity - , typename Base::function_arity > - , mpl::integral_c<int,2> , mpl::integral_c<int,1> - >::type - >::type - from; - typedef typename mpl::end<typename Base::types>::type to; - - typedef mpl::iterator_range<from,to> param_types; - - typedef mpl::joint_view< result_and_class_type, param_types> types_view; - public: - - typedef typename - mpl::reverse_copy<types_view, mpl::front_inserter< mpl::vector0<> > >::type - types; - - typedef typename - function_types::tag< Base, detail::cv_tag_mfp<OrigT> >::bits - bits; - - typedef typename Base::mask mask; - - typedef typename detail::classifier<OrigT>::function_arity function_arity; - - typedef components_mpl_sequence_tag tag; - }; - - // Now put it all together: detect cv-qualification of function types and do - // the weird transformations above for member function pointers. - template<typename T, typename OrigT, typename L> - struct components_bcc - : mpl::if_ - < detail::represents_impl< detail::components_impl<T,L> - , member_function_pointer_tag> - , detail::mfp_components<detail::components_impl<T,L>,T,OrigT,L> - , detail::components_impl<T,L> - >::type - { }; - -#endif // end of BORLAND WORKAROUND - -#define BOOST_FT_al_path boost/function_types/detail/components_impl -#include <boost/function_types/detail/pp_loop.hpp> - - } } // namespace function_types::detail - - BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,function_types::components) - -} // namespace ::boost - -#include <boost/function_types/detail/components_as_mpl_sequence.hpp> -#include <boost/function_types/detail/retag_default_cc.hpp> - -#endif - |