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> #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/fold.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> namespace boost { namespace type_erasure { template<class Sig> struct constructible; template<class T> struct destructible; template<class T, class U> struct assignable; namespace detail { template<class Derived, class Concept, class T> struct compute_bases { typedef typename ::boost::mpl::fold< typename ::boost::type_erasure::detail::collect_concepts< Concept >::type, ::boost::type_erasure::any_base<Derived>, ::boost::type_erasure::concept_interface< ::boost::mpl::_2, ::boost::mpl::_1, T > >::type type; }; 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 {}; 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; } 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_MSVC #pragma warning(push) #pragma warning(disable:4355) #pragma warning(disable:4521) #endif /** * 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 : 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) : 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::map< ::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::map< ::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::map< ::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<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::map< ::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<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<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::map< ::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::map< ::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) 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)... ) ) {} // disambiguate 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 /** * 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, * throws @c std::bad_alloc or whatever the copy * constructor of the contained type throws. 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. */ 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, * throws @c std::bad_alloc or whatever the copy * constructor of the contained type throws. In * this case assignment provides the strong exception * guarantee. When calling an assignment operator * of the contained type, the exception guarantee is * whatever the contained type provides. */ template<class U> any& operator=(const U& other) { _boost_type_erasure_resolve_assign(other); return *this; } /** * \pre @c Concept includes @ref destructible "destructible<T>". */ ~any() { table.template find<destructible<T> >()(data); } #ifndef BOOST_NO_FUNCTION_REFERENCE_QUALIFIERS /** INTERNAL ONLY */ operator param<Concept, T&>() & { return param<Concept, T&>(data, table); } /** INTERNAL ONLY */ operator param<Concept, T&&>() && { 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(const 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( const 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( const 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( const Other& other, const void*, ::boost::mpl::true_) { any temp(other); _boost_type_erasure_swap(temp); } /** INTERNAL ONLY */ template<class Concept2, class Tag2> void _boost_type_erasure_resolve_assign(const any<Concept2, Tag2>& 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( const 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( const 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( const 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( const 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); } } friend struct ::boost::type_erasure::detail::access; // The table has to be initialized first for exception // safety in some constructors. table_type table; ::boost::type_erasure::detail::storage data; }; 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::map< ::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::map< ::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::map< ::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) {} /** * 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, * throws @c std::bad_alloc. 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. */ 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, * throws @c std::bad_alloc. 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(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, * throws @c std::bad_alloc. 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=(const U& other) { _boost_type_erasure_resolve_assign(other); return *this; } #ifndef BOOST_NO_FUNCTION_REFERENCE_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( 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_) { 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); } 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::map< ::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::map< ::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_FUNCTION_REFERENCE_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::map< ::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::map< ::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::map< ::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) {} /** * 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, * throws @c std::bad_alloc. 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. */ 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, * throws @c std::bad_alloc. 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(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, * throws @c std::bad_alloc. 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=(const U& other) { _boost_type_erasure_resolve_assign(other); return *this; } #ifndef BOOST_NO_FUNCTION_REFERENCE_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( 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_) { 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); } friend struct ::boost::type_erasure::detail::access; ::boost::type_erasure::detail::storage data; table_type table; }; #endif } } #endif