boost/type_erasure/any.hpp
// Boost.TypeErasure library // // Copyright 2011 Steven Watanabe // // 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) // // $Id$ #ifndef BOOST_TYPE_ERASURE_ANY_HPP_INCLUDED #define BOOST_TYPE_ERASURE_ANY_HPP_INCLUDED #include <algorithm> #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES # include <utility> // std::forward, std::move #endif #include <boost/config.hpp> #include <boost/utility/enable_if.hpp> #include <boost/utility/addressof.hpp> #include <boost/utility/declval.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/or.hpp> #include <boost/mpl/pair.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/reverse_fold.hpp> #include <boost/type_traits/decay.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/type_erasure/detail/access.hpp> #include <boost/type_erasure/detail/any_base.hpp> #include <boost/type_erasure/detail/normalize.hpp> #include <boost/type_erasure/detail/storage.hpp> #include <boost/type_erasure/detail/instantiate.hpp> #include <boost/type_erasure/config.hpp> #include <boost/type_erasure/binding.hpp> #include <boost/type_erasure/static_binding.hpp> #include <boost/type_erasure/concept_interface.hpp> #include <boost/type_erasure/call.hpp> #include <boost/type_erasure/relaxed.hpp> #include <boost/type_erasure/param.hpp> #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable:4355) #pragma warning(disable:4521) #pragma warning(disable:4522) // multiple assignment operators specified #endif namespace boost { namespace type_erasure { #ifndef BOOST_TYPE_ERASURE_DOXYGEN template<class Sig> struct constructible; template<class T> struct destructible; template<class T, class U> struct assignable; #endif namespace detail { #if defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) template<class Concept, class Base, class ID> struct choose_concept_interface { typedef ::boost::type_erasure::concept_interface<Concept, Base, ID> type; }; #else struct default_concept_interface { template<class Concept, class Base, class ID> using apply = ::boost::type_erasure::concept_interface<Concept, Base, ID>; }; default_concept_interface boost_type_erasure_find_interface(...); template<class Concept, class Base, class ID> struct choose_concept_interface { typedef decltype(boost_type_erasure_find_interface(::boost::declval<Concept>())) finder; typedef typename finder::template apply<Concept, Base, ID> type; }; #endif #ifndef BOOST_TYPE_ERASURE_USE_MP11 template<class Derived, class Concept, class T> struct compute_bases { typedef typename ::boost::mpl::reverse_fold< typename ::boost::type_erasure::detail::collect_concepts< Concept >::type, ::boost::type_erasure::any_base<Derived>, ::boost::type_erasure::detail::choose_concept_interface< ::boost::mpl::_2, ::boost::mpl::_1, T > >::type type; }; #else template<class ID> struct compute_bases_f { template<class Concept, class Base> using apply = typename ::boost::type_erasure::detail::choose_concept_interface<Concept, Base, ID>::type; }; template<class Derived, class Concept, class T> using compute_bases_t = ::boost::mp11::mp_reverse_fold< typename ::boost::type_erasure::detail::collect_concepts_t< Concept >, ::boost::type_erasure::any_base<Derived>, ::boost::type_erasure::detail::compute_bases_f<T>::template apply >; template<class Derived, class Concept, class T> using compute_bases = ::boost::mpl::identity< ::boost::type_erasure::detail::compute_bases_t<Derived, Concept, T> >; #endif template<class T> T make(T*) { return T(); } // This dance is necessary to avoid errors calling // an ellipsis function with a non-trivially-copyable // argument. typedef char no; struct yes { no dummy[2]; }; template<class Op> yes check_overload(const Op*); no check_overload(const void*); struct fallback {}; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class T> fallback make_fallback(T&&, boost::mpl::false_) { return fallback(); } template<class T> T&& make_fallback(T&& arg, boost::mpl::true_) { return std::forward<T>(arg); } #else template<class T> fallback make_fallback(const T&, boost::mpl::false_) { return fallback(); } template<class T> const T& make_fallback(const T& arg, boost::mpl::true_) { return arg; } #endif template<class T> struct is_any : ::boost::mpl::false_ {}; template<class Concept, class T> struct is_any<any<Concept, T> > : ::boost::mpl::true_ {}; #ifdef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS template<class Any, class... U> struct has_constructor : ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<Any&>(). _boost_type_erasure_deduce_constructor(::boost::declval<U>()...) ) ) == sizeof(::boost::type_erasure::detail::yes) > {}; template<class Any> using has_copy_constructor = ::boost::type_erasure::is_subconcept< ::boost::type_erasure::constructible< typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type const&) >, typename ::boost::type_erasure::concept_of<Any>::type >; template<class Any> using has_move_constructor = ::boost::type_erasure::is_subconcept< ::boost::type_erasure::constructible< typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type &&) >, typename ::boost::type_erasure::concept_of<Any>::type >; template<class Any> using has_mutable_copy_constructor = ::boost::type_erasure::is_subconcept< ::boost::type_erasure::constructible< typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type &) >, typename ::boost::type_erasure::concept_of<Any>::type >; struct empty {}; template<class T> struct is_binding_arg : ::boost::mpl::false_ {}; template<class T> struct is_binding_arg<binding<T> > : ::boost::mpl::true_ {}; template<class T> struct is_binding_arg<binding<T>&&> : ::boost::mpl::true_ {}; template<class T> struct is_binding_arg<binding<T>&> : ::boost::mpl::true_ {}; template<class T> struct is_binding_arg<binding<T> const&> : ::boost::mpl::true_ {}; template<class T> struct is_static_binding_arg : ::boost::mpl::false_ {}; template<class T> struct is_static_binding_arg<static_binding<T> > : ::boost::mpl::true_ {}; template<class T> struct is_static_binding_arg<static_binding<T>&&> : ::boost::mpl::true_ {}; template<class T> struct is_static_binding_arg<static_binding<T>&> : ::boost::mpl::true_ {}; template<class T> struct is_static_binding_arg<static_binding<T> const&> : ::boost::mpl::true_ {}; template<class T> struct is_any_arg : ::boost::mpl::false_ {}; template<class Concept, class T> struct is_any_arg<any<Concept, T> > : ::boost::mpl::true_ {}; template<class Concept, class T> struct is_any_arg<any<Concept, T>&&> : ::boost::mpl::true_ {}; template<class Concept, class T> struct is_any_arg<any<Concept, T>&> : ::boost::mpl::true_ {}; template<class Concept, class T> struct is_any_arg<any<Concept, T> const&> : ::boost::mpl::true_ {}; template<class T> struct safe_concept_of; template<class Concept, class T> struct safe_concept_of<any<Concept, T> > { typedef Concept type; }; template<class Concept, class T> struct safe_concept_of<any<Concept, T>&&> { typedef Concept type; }; template<class Concept, class T> struct safe_concept_of<any<Concept, T>&> { typedef Concept type; }; template<class Concept, class T> struct safe_concept_of<any<Concept, T> const&> { typedef Concept type; }; template<class T> struct safe_placeholder_of; template<class Concept, class T> struct safe_placeholder_of<any<Concept, T> > { typedef T type; }; template<class Concept, class T> struct safe_placeholder_of<any<Concept, T>&&> { typedef T type; }; template<class Concept, class T> struct safe_placeholder_of<any<Concept, T>&> { typedef T type; }; template<class Concept, class T> struct safe_placeholder_of<any<Concept, T> const&> { typedef T type; }; template<class T> using safe_placeholder_t = ::boost::remove_cv_t< ::boost::remove_reference_t<typename safe_placeholder_of<T>::type> >; } // Enables or deletes the copy/move constructors depending on the Concept. template<class Base, class Enable = void> struct any_constructor_control : Base { using Base::Base; }; template<class Base> struct any_constructor_control< Base, typename boost::enable_if_c< !::boost::type_erasure::detail::has_copy_constructor<Base>::value && ::boost::type_erasure::detail::has_move_constructor<Base>::value && ::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value >::type > : Base { using Base::Base; any_constructor_control() = default; any_constructor_control(any_constructor_control&) = default; any_constructor_control(any_constructor_control&&) = default; any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; } any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; } any_constructor_control& operator=(any_constructor_control &&) = default; }; template<class Base> struct any_constructor_control< Base, typename boost::enable_if_c< !::boost::type_erasure::detail::has_copy_constructor<Base>::value && !::boost::type_erasure::detail::has_move_constructor<Base>::value && ::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value >::type > : Base { using Base::Base; any_constructor_control() = default; any_constructor_control(any_constructor_control&) = default; any_constructor_control(any_constructor_control&&) = delete; any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; } any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; } any_constructor_control& operator=(any_constructor_control &&) = default; }; template<class Base> struct any_constructor_control< Base, typename boost::enable_if_c< !::boost::type_erasure::detail::has_copy_constructor<Base>::value && ::boost::type_erasure::detail::has_move_constructor<Base>::value && !::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value >::type > : Base { using Base::Base; any_constructor_control() = default; any_constructor_control(any_constructor_control const&) = delete; any_constructor_control(any_constructor_control&&) = default; any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; } any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; } any_constructor_control& operator=(any_constructor_control &&) = default; }; template<class Base> struct any_constructor_control< Base, typename boost::enable_if_c< !::boost::type_erasure::detail::has_copy_constructor<Base>::value && !::boost::type_erasure::detail::has_move_constructor<Base>::value && !::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value >::type > : Base { using Base::Base; any_constructor_control() = default; any_constructor_control(any_constructor_control const&) = delete; any_constructor_control(any_constructor_control&&) = delete; any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; } any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; } any_constructor_control& operator=(any_constructor_control &&) = default; }; template<class Concept, class T> struct any_constructor_impl : ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, T>, Concept, T >::type { typedef typename ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, T>, Concept, T >::type _boost_type_erasure_base; // Internal constructors typedef ::boost::type_erasure::binding<Concept> _boost_type_erasure_table_type; any_constructor_impl(const ::boost::type_erasure::detail::storage& data_arg, const _boost_type_erasure_table_type& table_arg) : _boost_type_erasure_table(table_arg), _boost_type_erasure_data(data_arg) {} any_constructor_impl(::boost::type_erasure::detail::storage&& data_arg, const _boost_type_erasure_table_type& table_arg) : _boost_type_erasure_table(table_arg), _boost_type_erasure_data(data_arg) {} // default constructor any_constructor_impl() { BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>)); _boost_type_erasure_data.data = 0; } // capturing constructor template<class U, typename ::boost::enable_if_c< !::boost::type_erasure::detail::is_any_arg<U>::value && !::boost::type_erasure::detail::is_binding_arg<U>::value && !::boost::type_erasure::detail::is_static_binding_arg<U>::value >::type* = nullptr > any_constructor_impl(U&& data_arg) : _boost_type_erasure_table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, ::boost::decay_t<U>), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, ::boost::decay_t<U> > > >() )), _boost_type_erasure_data(std::forward<U>(data_arg)) {} template<class U, class Map, typename ::boost::enable_if_c< !::boost::type_erasure::detail::is_any_arg<U>::value && !::boost::type_erasure::detail::is_binding_arg<U>::value && !::boost::type_erasure::detail::is_static_binding_arg<U>::value >::type* = nullptr > any_constructor_impl(U&& data_arg, const static_binding<Map>& b) : _boost_type_erasure_table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), b )), _boost_type_erasure_data(std::forward<U>(data_arg)) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, ::boost::decay_t<U> >)); } // converting constructor template<class U, typename ::boost::enable_if_c< ::boost::type_erasure::is_subconcept< Concept, typename ::boost::type_erasure::detail::safe_concept_of<U>::type, typename ::boost::mpl::if_c< ::boost::is_same<T, ::boost::type_erasure::detail::safe_placeholder_t<U> >::value, void, ::boost::mpl::map1< ::boost::mpl::pair<T, ::boost::type_erasure::detail::safe_placeholder_t<U> > > >::type >::value >::type* = nullptr > any_constructor_impl(U&& other) : _boost_type_erasure_table( ::boost::type_erasure::detail::access::table(other), typename ::boost::mpl::if_c< ::boost::is_same<T, ::boost::type_erasure::detail::safe_placeholder_t<U> >::value, #ifndef BOOST_TYPE_ERASURE_USE_MP11 ::boost::type_erasure::detail::substitution_map< ::boost::mpl::map0<> >, #else ::boost::type_erasure::detail::make_identity_placeholder_map<Concept>, #endif ::boost::mpl::map1< ::boost::mpl::pair< T, ::boost::type_erasure::detail::safe_placeholder_t<U> > > >::type() ), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0 ), std::forward<U>(other)) ) {} template<class U, typename ::boost::enable_if_c< ::boost::type_erasure::detail::is_any_arg<U>::value >::type* = nullptr > any_constructor_impl(U&& other, const binding<Concept>& binding_arg) : _boost_type_erasure_table(binding_arg), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0 ), std::forward<U>(other)) ) {} template<class U, class Map, typename ::boost::enable_if_c< ::boost::type_erasure::is_subconcept< Concept, typename ::boost::type_erasure::detail::safe_concept_of<U>::type, Map >::value >::type* = nullptr > any_constructor_impl(U&& other, const static_binding<Map>& binding_arg) : _boost_type_erasure_table(::boost::type_erasure::detail::access::table(other), binding_arg), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0 ), std::forward<U>(other)) ) {} // copy and move constructors are a special case of the converting // constructors, but must be defined separately to keep C++ happy. any_constructor_impl(const any_constructor_impl& other) : _boost_type_erasure_table( ::boost::type_erasure::detail::access::table(other) ), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor( static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type const&>(other)) : 0 ), other) ) {} any_constructor_impl(any_constructor_impl& other) : _boost_type_erasure_table( ::boost::type_erasure::detail::access::table(other) ), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor( static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type &>(other)) : 0 ), other) ) {} any_constructor_impl(any_constructor_impl&& other) : _boost_type_erasure_table( ::boost::type_erasure::detail::access::table(other) ), _boost_type_erasure_data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor( static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type &&>(other)) : 0 ), std::move(other)) ) {} template<class R, class... A, class... U> const _boost_type_erasure_table_type& _boost_type_erasure_extract_table( ::boost::type_erasure::constructible<R(A...)>*, U&&... u) { return *::boost::type_erasure::detail::extract_table(static_cast<void(*)(A...)>(0), u...); } // forwarding constructor template<class... U, typename ::boost::enable_if_c< ::boost::type_erasure::detail::has_constructor<any_constructor_impl, U...>::value >::type* = nullptr > explicit any_constructor_impl(U&&... u) : _boost_type_erasure_table( _boost_type_erasure_extract_table( false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0, std::forward<U>(u)... ) ), _boost_type_erasure_data( ::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0 ), std::forward<U>(u)... ) ) {} template<class... U, typename ::boost::enable_if_c< ::boost::type_erasure::detail::has_constructor<any_constructor_impl, U...>::value >::type* = nullptr > explicit any_constructor_impl(const binding<Concept>& binding_arg, U&&... u) : _boost_type_erasure_table(binding_arg), _boost_type_erasure_data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0 ), std::forward<U>(u)... ) ) {} // The assignment operator and destructor must be defined here rather // than in any to avoid implicitly deleting the move constructor. any_constructor_impl& operator=(const any_constructor_impl& other) { static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign( static_cast<const typename _boost_type_erasure_base::_boost_type_erasure_derived_type&>(other)); return *this; } any_constructor_impl& operator=(any_constructor_impl& other) { static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign( static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type&>(other)); return *this; } any_constructor_impl& operator=(any_constructor_impl&& other) { static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign( static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type&&>(other)); return *this; } ~any_constructor_impl() { _boost_type_erasure_table.template find< ::boost::type_erasure::destructible<T> >()(_boost_type_erasure_data); } protected: friend struct ::boost::type_erasure::detail::access; _boost_type_erasure_table_type _boost_type_erasure_table; ::boost::type_erasure::detail::storage _boost_type_erasure_data; }; namespace detail { #endif template<class T> struct is_rvalue_for_any : ::boost::mpl::not_< ::boost::is_lvalue_reference<T> > {}; template<class C, class P> struct is_rvalue_for_any<any<C, P> > : ::boost::mpl::not_< ::boost::is_lvalue_reference<P> > {}; } /** * The class template @ref any can store any object that * models a specific \Concept. It dispatches all * the functions defined by the \Concept to the contained type * at runtime. * * \tparam Concept The \Concept that the stored type should model. * \tparam T A @ref placeholder specifying which type this is. * * \see concept_of, placeholder_of, \any_cast, \is_empty, \binding_of, \typeid_of */ template<class Concept, class T = _self> class any : #ifdef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS public ::boost::type_erasure::any_constructor_control< ::boost::type_erasure::any_constructor_impl< Concept, T > > #else public ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, T>, Concept, T >::type #endif { typedef ::boost::type_erasure::binding<Concept> table_type; public: /** INTERNAL ONLY */ typedef Concept _boost_type_erasure_concept_type; #if defined(BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS) using _boost_type_erasure_base = ::boost::type_erasure::any_constructor_control< ::boost::type_erasure::any_constructor_impl< Concept, T > >; using _boost_type_erasure_base::_boost_type_erasure_base; #else /** INTERNAL ONLY */ any(const ::boost::type_erasure::detail::storage& data_arg, const table_type& table_arg) : table(table_arg), data(data_arg) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** INTERNAL ONLY */ any(::boost::type_erasure::detail::storage&& data_arg, const table_type& table_arg) : table(table_arg), data(data_arg) {} #endif /** * Constructs an empty @ref any. * * Except as otherwise noted, all operations on an * empty @ref any result in a @ref bad_function_call exception. * The copy-constructor of an empty @ref any creates another * null @ref any. The destructor of an empty @ref any is a no-op. * Comparison operators treat all empty @ref any "anys" as equal. * \typeid_of applied to an empty @ref any returns @c typeid(void). * * An @ref any which does not include @ref relaxed in its * \Concept can never be null. * * \pre @ref relaxed must be in @c Concept. * * \throws Nothing. * * @see \is_empty */ any() { BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>)); data.data = 0; } #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) template<class U> any(const U& data_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, U> > >() )), data(data_arg) {} template<class U, class Map> any(const U& data_arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); } #else /** * Constructs an @ref any to hold a copy of @c data. * The @c Concept will be instantiated with the * placeholder @c T bound to U. * * \param data The object to store in the @ref any. * * \pre @c U is a model of @c Concept. * \pre @c U must be \CopyConstructible. * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * * \throws std::bad_alloc or whatever that the copy * constructor of @c U throws. * * \note This constructor never matches if the argument is * an @ref any, @ref binding, or @ref static_binding. */ template<class U> any(U&& data_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type> > >() )), data(std::forward<U>(data_arg)) {} /** * Constructs an @ref any to hold a copy of @c data * with explicitly specified placeholder bindings. * * \param data The object to store in the @ref any. * \param binding Specifies the types that * all the placeholders should bind to. * * \pre @c U is a model of @c Concept. * \pre @c U must be \CopyConstructible. * \pre @c Map is an MPL map with an entry for every * non-deduced placeholder referred to by @c Concept. * \pre @c @c T must map to @c U in @c Map. * * \throws std::bad_alloc or whatever that the copy * constructor of @c U throws. * * \note This constructor never matches if the argument is an @ref any. */ template<class U, class Map> any(U&& data_arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(std::forward<U>(data_arg)) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>)); } #endif // Handle array/function-to-pointer decay /** INTERNAL ONLY */ template<class U> any(U* data_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U*), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, U*> > >() )), data(data_arg) {} /** INTERNAL ONLY */ template<class U, class Map> any(U* data_arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U*>)); } /** * Copies an @ref any. * * \param other The object to make a copy of. * * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>". * (This is included in @ref copy_constructible "copy_constructible<T>") * * \throws std::bad_alloc or whatever that the copy * constructor of the contained type throws. */ any(const any& other) : table(other.table), data(::boost::type_erasure::call(constructible<T(const T&)>(), other)) {} /** * Upcasts from an @ref any with stricter requirements to * an @ref any with weaker requirements. * * \param other The object to make a copy of. * * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>". * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc or whatever that the copy * constructor of the contained type throws. */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other) : table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_const< typename ::boost::remove_reference<Tag2>::type >::type > >() ), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to make a copy of. * \param binding Specifies the mapping between the placeholders * used by the two concepts. * * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>". * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc or whatever that the copy * constructor of the contained type throws. */ template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to make a copy of. * \param binding Specifies the bindings of placeholders to actual types. * * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>". * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws std::bad_alloc or whatever that the copy * constructor of the contained type throws. * * \warning This constructor is potentially dangerous, as it cannot * check at compile time whether the arguments match. */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other, const binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} #ifdef BOOST_TYPE_ERASURE_DOXYGEN /** * Calls a constructor of the contained type. The bindings * will be deduced from the arguments. * * \param arg The arguments to be passed to the underlying constructor. * * \pre @c Concept must contain an instance of @ref constructible which * can be called with these arguments. * \pre At least one of the arguments must by an @ref any with the * same @c Concept as this. * \pre The bindings of all the arguments that are @ref any's, must * be the same. * * \throws std::bad_alloc or whatever that the * constructor of the contained type throws. * * \note This constructor is never chosen if any other constructor * can be called instead. */ template<class... U> explicit any(U&&... arg); /** * Calls a constructor of the contained type. * * \param binding Specifies the bindings of placeholders to actual types. * \param arg The arguments to be passed to the underlying constructor. * * \pre @c Concept must contain a matching instance of @ref constructible. * \pre The contained type of every argument that is an @ref any, must * be the same as that specified by @c binding. * * \post binding_of(*this) == @c binding * * \throws std::bad_alloc or whatever that the * constructor of the contained type throws. */ template<class... U> explicit any(const binding<Concept>& binding_arg, U&&... arg) : table(binding_arg), data( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(arg...) : 0 )(arg...) ) {} #else #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES any(any&& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::move(other)) : 0 ), std::move(other)) ) {} any(any& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other) : table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_const< typename ::boost::remove_reference<Tag2>::type >::type > >() ), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other) : table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_const< typename ::boost::remove_reference<Tag2>::type >::type > >() ), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? other._boost_type_erasure_deduce_constructor(std::move(other)) : 0 ), std::move(other)) ) {} #endif // construction from a reference any(const any<Concept, T&>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} any(any<Concept, T&>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES any(any<Concept, T&>&& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} #endif any(const any<Concept, const T&>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} any(any<Concept, const T&>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES any(any<Concept, const T&>&& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} #endif // disambiguating overloads template<class U, class Map> any(U* data_arg, static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U*>)); } #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template<class U, class Map> any(U& data_arg, static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); } template<class U, class Map> any(const U& data_arg, static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); } template<class U, class Map> any(U& data_arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); } #endif #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class U, class Map> any(U* data_arg, static_binding<Map>&& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U*>)); } template<class U, class Map> any(U&& data_arg, static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>)); } template<class U, class Map> any(U&& data_arg, static_binding<Map>&& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )), data(data_arg) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>)); } #endif template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>& other, static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2>& other, static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other, binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other, const binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other, binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>& other, static_binding<Map>&& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2>& other, static_binding<Map>&& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>&& other, static_binding<Map>&& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>&& other, static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>&& other, const static_binding<Map>& binding_arg) : table(::boost::type_erasure::detail::access::table(other), binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other, binding<Concept>&& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other, binding<Concept>&& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), other) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other, binding<Concept>&& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other, binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other, const binding<Concept>& binding_arg) : table(binding_arg), data(::boost::type_erasure::call( constructible< typename ::boost::remove_const< typename boost::remove_reference<Tag2>::type >::type(const typename boost::remove_reference<Tag2>::type&) >(), std::move(other)) ) {} #endif // One argument is a special case. The argument must be an any // and the constructor must be explicit. template<class Tag2> explicit any(const any<Concept, Tag2>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} template<class Tag2> explicit any(any<Concept, Tag2>& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(other) : 0 ), other) ) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class Tag2> explicit any(any<Concept, Tag2>&& other) : table(::boost::type_erasure::detail::access::table(other)), data(::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::move(other)) : 0 ), std::move(other)) ) {} #endif explicit any(const binding<Concept>& binding_arg) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::constructible<T()>() ) ) {} explicit any(binding<Concept>& binding_arg) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::constructible<T()>() ) ) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES explicit any(binding<Concept>&& binding_arg) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::constructible<T()>() ) ) {} #endif #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) template<class R, class... A, class... U> const table_type& _boost_type_erasure_extract_table( ::boost::type_erasure::constructible<R(A...)>*, U&&... u) { return *::boost::type_erasure::detail::extract_table(static_cast<void(*)(A...)>(0), u...); } template<class U0, class U1, class... U> any(U0&& u0, U1&& u1, U&&... u) : table( _boost_type_erasure_extract_table( false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...) : 0, std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)... ) ), data( ::boost::type_erasure::call( ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...) : 0 ), std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)... ) ) {} template<class U0, class... U> any(const binding<Concept>& binding_arg, U0&& u0, U&&... u) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0 ), std::forward<U0>(u0), std::forward<U>(u)... ) ) {} // disambiguating overloads template<class U0, class... U> any(binding<Concept>& binding_arg, U0&& u0, U&&... u) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0 ), std::forward<U0>(u0), std::forward<U>(u)... ) ) {} template<class U0, class... U> any(binding<Concept>&& binding_arg, U0&& u0, U&&... u) : table(binding_arg), data( ::boost::type_erasure::call( binding_arg, ::boost::type_erasure::detail::make( false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0 ), std::forward<U0>(u0), std::forward<U>(u)... ) ) {} #else #include <boost/type_erasure/detail/construct.hpp> #endif #endif /** INTERNAL ONLY */ any& operator=(const any& other) { _boost_type_erasure_resolve_assign(other); return *this; } /** INTERNAL ONLY */ any& operator=(any& other) { _boost_type_erasure_resolve_assign(other); return *this; } #endif // BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template<class U> any& operator=(U& other) { _boost_type_erasure_resolve_assign(other); return *this; } template<class U> any& operator=(const U& other) { _boost_type_erasure_resolve_assign(other); return *this; } #else #ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS /** INTERNAL ONLY */ any& operator=(any&& other) { _boost_type_erasure_resolve_assign(std::move(other)); return *this; } #endif /** * Assigns to an @ref any. * * If an appropriate overload of @ref assignable is not available * and @ref relaxed is in @c Concept, falls back on * constructing from @c other. * * \note If @c U is an @ref any, then this can decide dynamically * whether to use construction based on the type stored in other. * * \throws Whatever the assignment operator of the contained * type throws. When falling back on construction, * throws @c std::bad_alloc or whatever the move (or copy) * constructor of the contained type throws. In * this case move assignment provides the strong exception * guarantee. When calling a (move) assignment operator * of the contained type, the exception guarantee is * whatever the contained type provides. */ template<class U> any& operator=(U&& other) { _boost_type_erasure_resolve_assign(std::forward<U>(other)); return *this; } #endif #ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS /** * \pre @c Concept includes @ref destructible "destructible<T>". */ ~any() { ::boost::type_erasure::detail::access::table(*this).template find< ::boost::type_erasure::destructible<T> >()(::boost::type_erasure::detail::access::data(*this)); } #endif #ifndef BOOST_NO_CXX11_REF_QUALIFIERS /** INTERNAL ONLY */ operator param<Concept, T&>() & { return param<Concept, T&>( boost::type_erasure::detail::access::data(*this), boost::type_erasure::detail::access::table(*this)); } /** INTERNAL ONLY */ operator param<Concept, T&&>() && { return param<Concept, T&&>( boost::type_erasure::detail::access::data(*this), boost::type_erasure::detail::access::table(*this)); } #endif private: #ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS /** INTERNAL ONLY */ void _boost_type_erasure_swap(any& other) { ::std::swap(data, other.data); ::std::swap(table, other.table); } #else void _boost_type_erasure_swap(any& other) { ::std::swap(this->_boost_type_erasure_data, other._boost_type_erasure_data); ::std::swap(this->_boost_type_erasure_table, other._boost_type_erasure_table); } #endif #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign(Other&& other) { _boost_type_erasure_assign_impl( std::forward<Other>(other), false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( std::forward<Other>(other), ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(std::forward<Other>(other)) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::type_erasure::is_relaxed<Concept>() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::true_) { ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_assign_impl( Other&& other, const void*, ::boost::mpl::true_) { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } #else /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign(Other& other) { _boost_type_erasure_assign_impl( other, false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( other, ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(other) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::type_erasure::is_relaxed<Concept>() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, other); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, ::boost::mpl::true_) { ::boost::type_erasure::call(assignable<T, U>(), *this, other); } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_assign_impl( Other& other, const void*, ::boost::mpl::true_) { any temp(other); _boost_type_erasure_swap(temp); } #endif /** INTERNAL ONLY */ template<class Concept2, class Tag2> void _boost_type_erasure_resolve_assign(const any<Concept2, Tag2>& other) { _boost_type_erasure_resolve_assign_any(other); } /** INTERNAL ONLY */ template<class Concept2, class Tag2> void _boost_type_erasure_resolve_assign(any<Concept2, Tag2>& other) { _boost_type_erasure_resolve_assign_any(other); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** INTERNAL ONLY */ template<class Concept2, class Tag2> void _boost_type_erasure_resolve_assign(any<Concept2, Tag2>&& other) { _boost_type_erasure_resolve_assign_any(std::move(other)); } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign_any(Other&& other) { _boost_type_erasure_assign_impl( std::forward<Other>(other), false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( std::forward<Other>(other), ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(std::forward<Other>(other)) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, false? this->_boost_type_erasure_deduce_constructor( ::boost::type_erasure::detail::make_fallback( std::forward<Other>(other), ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_constructor(std::forward<Other>(other)) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::type_erasure::is_relaxed<Concept>() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, const void*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, const void*, ::boost::mpl::true_) { ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other, class Sig> void _boost_type_erasure_assign_impl( Other&& other, const void*, const constructible<Sig>*, ::boost::mpl::true_) { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } /** INTERNAL ONLY */ template<class Other, class U, class Sig> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, const constructible<Sig>*, ::boost::mpl::true_) { if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) // const reference to other is enough! { ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, std::forward<Other>(other)); } else { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } } #else /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign_any(Other& other) { _boost_type_erasure_assign_impl( other, false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( other, ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(other) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, false? this->_boost_type_erasure_deduce_constructor( ::boost::type_erasure::detail::make_fallback( other, ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_constructor(other) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::type_erasure::is_relaxed<Concept>() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, const void*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, other); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, const void*, ::boost::mpl::true_) { ::boost::type_erasure::call(assignable<T, U>(), *this, other); } /** INTERNAL ONLY */ template<class Other, class Sig> void _boost_type_erasure_assign_impl( Other& other, const void*, const constructible<Sig>*, ::boost::mpl::true_) { any temp(other); _boost_type_erasure_swap(temp); } /** INTERNAL ONLY */ template<class Other, class U, class Sig> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, const constructible<Sig>*, ::boost::mpl::true_) { if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) { ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, other); } else { any temp(other); _boost_type_erasure_swap(temp); } } #endif friend struct ::boost::type_erasure::detail::access; #ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS // The table has to be initialized first for exception // safety in some constructors. table_type table; ::boost::type_erasure::detail::storage data; #else template<class Concept2, class T2> friend struct ::boost::type_erasure::any_constructor_impl; #endif }; template<class Concept, class T> class any<Concept, T&> : public ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, T&>, Concept, T >::type { typedef ::boost::type_erasure::binding<Concept> table_type; public: /** INTERNAL ONLY */ typedef Concept _boost_type_erasure_concept_type; /** INTERNAL ONLY */ any(const ::boost::type_erasure::detail::storage& data_arg, const table_type& table_arg) : data(data_arg), table(table_arg) {} /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * * \pre @c U is a model of @c Concept. * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * * \throws Nothing. */ template<class U> any(U& arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_const<U>, ::boost::type_erasure::detail::is_any<U> > >::type* = 0 #endif ) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, U> > >() )) { data.data = ::boost::addressof(arg); } /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * \param binding Specifies the actual types that * all the placeholders should bind to. * * \pre @c U is a model of @c Concept. * \pre @c Map is an MPL map with an entry for every * non-deduced placeholder referred to by @c Concept. * * \throws Nothing. */ template<class U, class Map> any(U& arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); data.data = ::boost::addressof(arg); } /** * Constructs an @ref any from another reference. * * \param other The reference to copy. * * \throws Nothing. */ any(const any& other) : data(other.data), table(other.table) {} #ifndef BOOST_TYPE_ERASURE_DOXYGEN any(any& other) : data(other.data), table(other.table) {} #endif /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \throws Nothing. */ any(any<Concept, T>& other) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other)) {} /** * Constructs an @ref any from another reference. * * \param other The reference to copy. * * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2&>& other #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_same<Concept, Concept2>, ::boost::is_const<Tag2> > >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, Tag2 > >()) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_same<Concept, Concept2>, ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> > >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_reference<Tag2>::type > >()) {} /** * Constructs an @ref any from another reference. * * \param other The reference to copy. * \param binding Specifies the mapping between the two concepts. * * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2&>& other, const static_binding<Map>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other), binding_arg) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the mapping between the two concepts. * * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other), binding_arg) {} /** * Constructs an @ref any from another reference. * * \param other The reference to copy. * \param binding Specifies the bindings of placeholders to actual types. * * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws Nothing. */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2&>& other, const binding<Concept>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(binding_arg) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the bindings of placeholders to actual types. * * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws Nothing. */ template<class Concept2, class Tag2> any(any<Concept2, Tag2>& other, const binding<Concept>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(binding_arg) {} /** INTERNAL ONLY */ any& operator=(const any& other) { _boost_type_erasure_resolve_assign(other); return *this; } /** INTERNAL ONLY */ any& operator=(any& other) { _boost_type_erasure_resolve_assign(other); return *this; } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** INTERNAL ONLY */ any& operator=(any&& other) { _boost_type_erasure_resolve_assign(std::move(other)); return *this; } /** * Assigns to an @ref any. * * If an appropriate overload of @ref assignable is not available * and @ref relaxed is in @c Concept, falls back on * constructing from @c other. * * \throws Whatever the assignment operator of the contained * type throws. When falling back on construction, * can only throw @c std::bad_alloc if @c U is an @ref any * that uses a different @c Concept. In this case assignment * provides the strong exception guarantee. When * calling the assignment operator of the contained type, * the exception guarantee is whatever the contained type provides. */ template<class U> any& operator=(U&& other) { _boost_type_erasure_resolve_assign(std::forward<U>(other)); return *this; } #else template<class U> any& operator=(U& other) { _boost_type_erasure_resolve_assign(other); return *this; } template<class U> any& operator=(const U& other) { _boost_type_erasure_resolve_assign(other); return *this; } #endif #ifndef BOOST_NO_CXX11_REF_QUALIFIERS /** INTERNAL ONLY */ operator param<Concept, T&>() const { return param<Concept, T&>(data, table); } #endif private: /** INTERNAL ONLY */ void _boost_type_erasure_swap(any& other) { ::std::swap(data, other.data); ::std::swap(table, other.table); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign(Other&& other) { _boost_type_erasure_assign_impl( std::forward<Other>(other), false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( std::forward<Other>(other), ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(std::forward<Other>(other)) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::mpl::and_< ::boost::type_erasure::is_relaxed<Concept>, ::boost::is_convertible<Other, any> #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1900)) , ::boost::mpl::not_< ::boost::type_erasure::detail::is_rvalue_for_any<Other> > #endif >() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::true_) { if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) { ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, std::forward<Other>(other)); } else { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_assign_impl( Other&& other, const void*, ::boost::mpl::true_) { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } #else /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign(Other& other) { _boost_type_erasure_assign_impl( other, false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( other, ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(other) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::mpl::and_< ::boost::type_erasure::is_relaxed<Concept>, ::boost::is_convertible<Other&, any> >() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, ::boost::mpl::false_) { ::boost::type_erasure::call(assignable<T, U>(), *this, other); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other& other, const assignable<T, U>*, ::boost::mpl::true_) { if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) { ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, other); } else { any temp(other); _boost_type_erasure_swap(temp); } } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_assign_impl( Other& other, const void*, ::boost::mpl::true_) { any temp(other); _boost_type_erasure_swap(temp); } #endif friend struct ::boost::type_erasure::detail::access; ::boost::type_erasure::detail::storage data; table_type table; }; #ifdef BOOST_MSVC #pragma warning(pop) #endif template<class Concept, class T> class any<Concept, const T&> : public ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, const T&>, Concept, T >::type { typedef ::boost::type_erasure::binding<Concept> table_type; public: /** INTERNAL ONLY */ typedef Concept _boost_type_erasure_concept_type; /** INTERNAL ONLY */ any(const ::boost::type_erasure::detail::storage& data_arg, const table_type& table_arg) : data(data_arg), table(table_arg) {} /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * * \pre @c U is a model of @c Concept. * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * * \throws Nothing. */ template<class U> any(const U& arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, U> > >() )) { data.data = const_cast<void*>(static_cast<const void*>(::boost::addressof(arg))); } /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * \param binding Specifies the actual types that * all the placeholders should bind to. * * \pre @c U is a model of @c Concept. * \pre @c Map is an MPL map with an entry for every * non-deduced placeholder referred to by @c Concept. * * \throws Nothing. */ template<class U, class Map> any(const U& arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); data.data = const_cast<void*>(static_cast<const void*>(::boost::addressof(arg))); } /** * Constructs an @ref any from another @ref any. * * \param other The reference to copy. * * \throws Nothing. */ any(const any& other) : data(other.data), table(other.table) {} /** * Constructs an @ref any from another @ref any. * * \param other The reference to copy. * * \throws Nothing. */ any(const any<Concept, T&>& other) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other)) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \throws Nothing. */ any(const any<Concept, T>& other) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other)) {} #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \throws Nothing. */ any(const any<Concept, T&&>& other) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other)) {} #endif /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_same<Concept, Concept2> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table( ::boost::type_erasure::detail::access::table(other), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_const< typename ::boost::remove_reference<Tag2>::type >::type > >()) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the mapping between the two concepts. * * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other), binding_arg) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the bindings of placeholders to actual types. * * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws Nothing. */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2>& other, const binding<Concept>& binding_arg) : data(::boost::type_erasure::detail::access::data(other)), table(binding_arg) {} /** * Assigns to an @ref any. * * \pre @ref relaxed is in @c Concept. * * \throws Nothing. */ any& operator=(const any& other) { BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>)); any temp(other); _boost_type_erasure_swap(temp); return *this; } /** * Assigns to an @ref any. * * \pre @ref relaxed is in @c Concept. * * \throws std::bad_alloc. Provides the strong exception guarantee. */ template<class U> any& operator=(const U& other) { BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>)); any temp(other); _boost_type_erasure_swap(temp); return *this; } #ifndef BOOST_NO_CXX11_REF_QUALIFIERS /** INTERNAL ONLY */ operator param<Concept, const T&>() const { return param<Concept, const T&>(data, table); } #endif private: /** INTERNAL ONLY */ void _boost_type_erasure_swap(any& other) { ::std::swap(data, other.data); ::std::swap(table, other.table); } friend struct ::boost::type_erasure::detail::access; ::boost::type_erasure::detail::storage data; table_type table; }; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class Concept, class T> class any<Concept, T&&> : public ::boost::type_erasure::detail::compute_bases< ::boost::type_erasure::any<Concept, T&&>, Concept, T >::type { typedef ::boost::type_erasure::binding<Concept> table_type; public: /** INTERNAL ONLY */ typedef Concept _boost_type_erasure_concept_type; /** INTERNAL ONLY */ any(const ::boost::type_erasure::detail::storage& data_arg, const table_type& table_arg) : data(data_arg), table(table_arg) {} /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * * \pre @c U is a model of @c Concept. * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * * \throws Nothing. */ template<class U> any(U&& arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_reference<U>, ::boost::is_const<U>, ::boost::type_erasure::detail::is_any<U> > >::type* = 0 #endif ) : table(( BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U), ::boost::type_erasure::make_binding< ::boost::mpl::map1< ::boost::mpl::pair<T, U> > >() )) { data.data = ::boost::addressof(arg); } /** * Constructs an @ref any from a reference. * * \param arg The object to bind the reference to. * \param binding Specifies the actual types that * all the placeholders should bind to. * * \pre @c U is a model of @c Concept. * \pre @c Map is an MPL map with an entry for every * non-deduced placeholder referred to by @c Concept. * * \throws Nothing. */ template<class U, class Map> any(U&& arg, const static_binding<Map>& binding_arg) : table(( BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map), binding_arg )) { BOOST_MPL_ASSERT((::boost::is_same< typename ::boost::mpl::at<Map, T>::type, U>)); data.data = ::boost::addressof(arg); } /** * Constructs an @ref any from another rvalue reference. * * \param other The reference to copy. * * \throws Nothing. */ #ifndef BOOST_TYPE_ERASURE_DOXYGEN any(any&& other) : data(other.data), table(std::move(other.table)) {} any(const any& other) : data(other.data), table(other.table) {} #endif /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \throws Nothing. */ any(any<Concept, T>&& other) : data(::boost::type_erasure::detail::access::data(other)), table(std::move(::boost::type_erasure::detail::access::table(other))) {} /** * Constructs an @ref any from another rvalue reference. * * \param other The reference to copy. * * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2> any(any<Concept2, Tag2&&>&& other #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_reference<Tag2>, ::boost::is_same<Concept, Concept2>, ::boost::is_const<Tag2> > >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table( std::move(::boost::type_erasure::detail::access::table(other)), ::boost::mpl::map1< ::boost::mpl::pair< T, Tag2 > >()) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * * \pre @c Concept must not refer to any non-deduced placeholder besides @c T. * \pre After substituting @c T for @c Tag2, the requirements of * @c Concept2 must be a superset of the requirements of * @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::mpl::or_< ::boost::is_same<Concept, Concept2>, ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> > >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table( std::move(::boost::type_erasure::detail::access::table(other)), ::boost::mpl::map1< ::boost::mpl::pair< T, typename ::boost::remove_reference<Tag2>::type > >()) {} /** * Constructs an @ref any from another reference. * * \param other The reference to copy. * \param binding Specifies the mapping between the two concepts. * * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2, class Map> any(const any<Concept2, Tag2&&>& other, const static_binding<Map>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(std::move(::boost::type_erasure::detail::access::table(other)), binding_arg) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the mapping between the two concepts. * * \pre @c Map must be an MPL map with keys for all the non-deduced * placeholders used by @c Concept and values for the corresponding * placeholders in @c Concept2. * \pre After substituting placeholders according to @c Map, the * requirements of @c Concept2 must be a superset of the * requirements of @c Concept. * * \throws std::bad_alloc */ template<class Concept2, class Tag2, class Map> any(any<Concept2, Tag2>&& other, const static_binding<Map>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(::boost::type_erasure::detail::access::table(other), binding_arg) {} /** * Constructs an @ref any from another rvalue reference. * * \param other The reference to copy. * \param binding Specifies the bindings of placeholders to actual types. * * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws Nothing. */ template<class Concept2, class Tag2> any(const any<Concept2, Tag2&&>& other, const binding<Concept>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(binding_arg) {} /** * Constructs an @ref any from another @ref any. * * \param other The object to bind the reference to. * \param binding Specifies the bindings of placeholders to actual types. * * \pre The type stored in @c other must match the type expected by * @c binding. * * \post binding_of(*this) == @c binding * * \throws Nothing. */ template<class Concept2, class Tag2> any(any<Concept2, Tag2>&& other, const binding<Concept>& binding_arg #ifndef BOOST_TYPE_ERASURE_DOXYGEN , typename ::boost::disable_if< ::boost::is_const<typename ::boost::remove_reference<Tag2>::type> >::type* = 0 #endif ) : data(::boost::type_erasure::detail::access::data(other)), table(binding_arg) {} /** INTERNAL ONLY */ any& operator=(const any& other) { _boost_type_erasure_resolve_assign(other); return *this; } /** * Assigns to an @ref any. * * If an appropriate overload of @ref assignable is not available * and @ref relaxed is in @c Concept, falls back on * constructing from @c other. * * \throws Whatever the assignment operator of the contained * type throws. When falling back on construction, * can only throw @c std::bad_alloc if @c U is an @ref any * that uses a different @c Concept. In this case assignment * provides the strong exception guarantee. When * calling the assignment operator of the contained type, * the exception guarantee is whatever the contained type provides. */ template<class U> any& operator=(U&& other) { _boost_type_erasure_resolve_assign(std::forward<U>(other)); return *this; } #ifndef BOOST_NO_CXX11_REF_QUALIFIERS /** INTERNAL ONLY */ operator param<Concept, T&&>() const { return param<Concept, T&&>(data, table); } #endif private: /** INTERNAL ONLY */ void _boost_type_erasure_swap(any& other) { ::std::swap(data, other.data); ::std::swap(table, other.table); } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_resolve_assign(Other&& other) { _boost_type_erasure_assign_impl( std::forward<Other>(other), false? this->_boost_type_erasure_deduce_assign( ::boost::type_erasure::detail::make_fallback( std::forward<Other>(other), ::boost::mpl::bool_< sizeof( ::boost::type_erasure::detail::check_overload( ::boost::declval<any&>(). _boost_type_erasure_deduce_assign(std::forward<Other>(other)) ) ) == sizeof(::boost::type_erasure::detail::yes) >() ) ) : 0, ::boost::mpl::and_< ::boost::type_erasure::is_relaxed<Concept>, ::boost::is_convertible<Other, any> >() ); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::false_) { ::boost::type_erasure::call( assignable<T, U>(), // lose rvalueness of this ::boost::type_erasure::param<Concept, T&>(data, table), std::forward<Other>(other)); } /** INTERNAL ONLY */ template<class Other, class U> void _boost_type_erasure_assign_impl( Other&& other, const assignable<T, U>*, ::boost::mpl::true_) { if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) { ::boost::type_erasure::unchecked_call( assignable<T, U>(), // lose rvalueness of this ::boost::type_erasure::param<Concept, T&>(data, table), std::forward<Other>(other)); } else { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } } /** INTERNAL ONLY */ template<class Other> void _boost_type_erasure_assign_impl( Other&& other, const void*, ::boost::mpl::true_) { any temp(std::forward<Other>(other)); _boost_type_erasure_swap(temp); } friend struct ::boost::type_erasure::detail::access; ::boost::type_erasure::detail::storage data; table_type table; }; #endif #ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES template<class Concept, class T> using any_ref = any<Concept, T&>; template<class Concept, class T> using any_cref = any<Concept, const T&>; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<class Concept, class T> using any_rvref = any<Concept, T&&>; #endif #endif } } #endif