boost/any.hpp
// See http://www.boost.org/libs/any for Documentation. #ifndef BOOST_ANY_INCLUDED #define BOOST_ANY_INCLUDED #if defined(_MSC_VER) # pragma once #endif // what: variant type boost::any // who: contributed by Kevlin Henney, // with features contributed and bugs found by // Antony Polukhin, Ed Brey, Mark Rodgers, // Peter Dimov, and James Curran // when: July 2001, April 2013 - May 2013 #include <algorithm> #include <boost/config.hpp> #include <boost/type_index.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/decay.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/is_reference.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/throw_exception.hpp> #include <boost/static_assert.hpp> #include <boost/utility/enable_if.hpp> #include <boost/core/addressof.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/mpl/if.hpp> namespace boost { class any { public: // structors any() BOOST_NOEXCEPT : content(0) { } template<typename ValueType> any(const ValueType & value) : content(new holder< BOOST_DEDUCED_TYPENAME remove_cv<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>::type >(value)) { } any(const any & other) : content(other.content ? other.content->clone() : 0) { } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES // Move constructor any(any&& other) BOOST_NOEXCEPT : content(other.content) { other.content = 0; } // Perfect forwarding of ValueType template<typename ValueType> any(ValueType&& value , typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0 // disable if value has type `any&` , typename boost::disable_if<boost::is_const<ValueType> >::type* = 0) // disable if value has type `const ValueType&&` : content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value))) { } #endif ~any() BOOST_NOEXCEPT { delete content; } public: // modifiers any & swap(any & rhs) BOOST_NOEXCEPT { std::swap(content, rhs.content); return *this; } #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template<typename ValueType> any & operator=(const ValueType & rhs) { any(rhs).swap(*this); return *this; } any & operator=(any rhs) { any(rhs).swap(*this); return *this; } #else any & operator=(const any& rhs) { any(rhs).swap(*this); return *this; } // move assignement any & operator=(any&& rhs) BOOST_NOEXCEPT { rhs.swap(*this); any().swap(rhs); return *this; } // Perfect forwarding of ValueType template <class ValueType> any & operator=(ValueType&& rhs) { any(static_cast<ValueType&&>(rhs)).swap(*this); return *this; } #endif public: // queries bool empty() const BOOST_NOEXCEPT { return !content; } void clear() BOOST_NOEXCEPT { any().swap(*this); } const boost::typeindex::type_info& type() const BOOST_NOEXCEPT { return content ? content->type() : boost::typeindex::type_id<void>().type_info(); } #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: // types #else public: // types (public so any_cast can be non-friend) #endif class placeholder { public: // structors virtual ~placeholder() { } public: // queries virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT = 0; virtual placeholder * clone() const = 0; }; template<typename ValueType> class holder : public placeholder { public: // structors holder(const ValueType & value) : held(value) { } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES holder(ValueType&& value) : held(static_cast< ValueType&& >(value)) { } #endif public: // queries virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT { return boost::typeindex::type_id<ValueType>().type_info(); } virtual placeholder * clone() const { return new holder(held); } public: // representation ValueType held; private: // intentionally left unimplemented holder & operator=(const holder &); }; #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: // representation template<typename ValueType> friend ValueType * any_cast(any *) BOOST_NOEXCEPT; template<typename ValueType> friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT; #else public: // representation (public so any_cast can be non-friend) #endif placeholder * content; }; inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT { lhs.swap(rhs); } class BOOST_SYMBOL_VISIBLE bad_any_cast : #ifndef BOOST_NO_RTTI public std::bad_cast #else public std::exception #endif { public: virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW { return "boost::bad_any_cast: " "failed conversion using boost::any_cast"; } }; template<typename ValueType> ValueType * any_cast(any * operand) BOOST_NOEXCEPT { return operand && operand->type() == boost::typeindex::type_id<ValueType>() ? boost::addressof( static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held ) : 0; } template<typename ValueType> inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT { return any_cast<ValueType>(const_cast<any *>(operand)); } template<typename ValueType> ValueType any_cast(any & operand) { typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref; nonref * result = any_cast<nonref>(boost::addressof(operand)); if(!result) boost::throw_exception(bad_any_cast()); // Attempt to avoid construction of a temporary object in cases when // `ValueType` is not a reference. Example: // `static_cast<std::string>(*result);` // which is equal to `std::string(*result);` typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< boost::is_reference<ValueType>, ValueType, BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type >::type ref_type; #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local! #endif return static_cast<ref_type>(*result); #ifdef BOOST_MSVC # pragma warning(pop) #endif } template<typename ValueType> inline ValueType any_cast(const any & operand) { typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref; return any_cast<const nonref &>(const_cast<any &>(operand)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template<typename ValueType> inline ValueType any_cast(any&& operand) { BOOST_STATIC_ASSERT_MSG( boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/ || boost::is_const< typename boost::remove_reference<ValueType>::type >::value, "boost::any_cast shall not be used for getting nonconst references to temporary objects" ); return any_cast<ValueType>(operand); } #endif // Note: The "unsafe" versions of any_cast are not part of the // public interface and may be removed at any time. They are // required where we know what type is stored in the any and can't // use typeid() comparison, e.g., when our types may travel across // different shared libraries. template<typename ValueType> inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT { return boost::addressof( static_cast<any::holder<ValueType> *>(operand->content)->held ); } template<typename ValueType> inline const ValueType * unsafe_any_cast(const any * operand) BOOST_NOEXCEPT { return unsafe_any_cast<ValueType>(const_cast<any *>(operand)); } } // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved. // // 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) #endif