Classes
struct	_Big_storage_t

struct	_Small_storage_t

struct	_Storage_t

Public Member Functions
constexpr	any () _NOEXCEPT

	any (const any &_That)

	any (any &&_That) _NOEXCEPT

template<class _ValueType , enable_if_t<!is_same< decay_t< _ValueType >, any >::value &&!_Is_specialization< decay_t< _ValueType >, in_place_type_t >::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
	any (_ValueType &&_Value)

template<class _ValueType , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
	any (in_place_type_t< _ValueType >, _Types &&..._Args)

template<class _ValueType , class _Elem , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, initializer_list< _Elem > &, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
	any (in_place_type_t< _ValueType >, initializer_list< _Elem > _Ilist, _Types &&..._Args)

	~any () _NOEXCEPT

any &	operator= (const any &_That)

any &	operator= (any &&_That) _NOEXCEPT

template<class _ValueType , enable_if_t<!is_same< decay_t< _ValueType >, any >::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
any &	operator= (_ValueType &&_Value)

template<class _ValueType , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
void	emplace (_Types &&..._Args)

template<class _ValueType , class _Elem , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, initializer_list< _Elem > &, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>
void	emplace (initializer_list< _Elem > _Ilist, _Types &&..._Args)

void	reset () _NOEXCEPT

void	swap (any &_That) _NOEXCEPT

bool	has_value () const _NOEXCEPT

const type_info &	type () const _NOEXCEPT

template<class _Decayed >
const _Decayed *	_Cast () const _NOEXCEPT

template<class _Decayed >
_Decayed *	_Cast () _NOEXCEPT

Private Member Functions
_Any_representation	_Rep () const

const type_info *	_TypeInfo () const

void	_Move_from (any &_That)

template<class _Decayed , class... _Types>
void	_Emplace (_Types &&..._Args)

template<class _Decayed , class... _Types>
void	_Emplace1 (false_type, false_type, _Types &&..._Args)

template<class _Decayed , class... _Types>
void	_Emplace1 (true_type, false_type, _Types &&..._Args)

template<class _Decayed , class... _Types>
void	_Emplace1 (_Any_tag, true_type, _Types &&..._Args)

template<class _Decayed >
const _Decayed *	_Cast1 (false_type, false_type) const _NOEXCEPT

template<class _Decayed >
const _Decayed *	_Cast1 (true_type, false_type) const _NOEXCEPT

template<class _Decayed >
const _Decayed *	_Cast1 (_Any_tag, true_type) const _NOEXCEPT

uintptr_t &	_TypeData ()&

const uintptr_t &	_TypeData () const &

void *&	_BigPointer ()&

void *const &	_BigPointer () const &

const _Any_big_RTTI *&	_BigRTTI ()&

const _Any_big_RTTI *const &	_BigRTTI () const &

void *	_SmallData ()&

const void *	_SmallData () const &

const _Any_small_RTTI *&	_SmallRTTI ()&

const _Any_small_RTTI *const &	_SmallRTTI () const &

Private Attributes
union {
_Storage_t _Storage

max_align_t _Dummy

};

Static Private Attributes
static constexpr uintptr_t	_Rep_mask = 3

Constructor & Destructor Documentation

constexpr any::any ( )

inline

         : _Storage{}
         {   // initialize to the empty state
         }

any::any ( const any & _That )

inline

         {   // copy _That's value
         _TypeData() = _That._TypeData();
         switch (_Rep())
             {
             case _Any_representation::_Small:
                 _SmallRTTI() = _That._SmallRTTI();
                 _SmallRTTI()->_Copy(_SmallData(), _That._SmallData());
                 break;
             case _Any_representation::_Big:
                 _BigRTTI() = _That._BigRTTI();
                 _BigPointer() = _BigRTTI()->_Copy(_That._BigPointer());
                 break;
             case _Any_representation::_Trivial:
             default:
                 _Storage._TrivialData = _That._Storage._TrivialData;
                 break;
             }
         }

any::any ( any && _That )

inline

         {   // steal _That's value
         _Move_from(_That);
         }

template<class _ValueType , enable_if_t<!is_same< decay_t< _ValueType >, any >::value &&!_Is_specialization< decay_t< _ValueType >, in_place_type_t >::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

any::any ( _ValueType && _Value )

inline

         {   // initialize with _Value
         _Emplace<decay_t<_ValueType>>(_STD forward<_ValueType>(_Value));
         }

template<class _ValueType , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

any::any	(	in_place_type_t< _ValueType >	,
		_Types &&...	_Args
	)

inlineexplicit

         {   // in-place initialize a value of type decay_t<_ValueType> with _Args...
         _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);
         }

template<class _ValueType , class _Elem , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, initializer_list< _Elem > &, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

any::any	(	in_place_type_t< _ValueType >	,
		initializer_list< _Elem >	_Ilist,
		_Types &&...	_Args
	)

inlineexplicit

         {   // in-place initialize a value of type decay_t<_ValueType> with _Ilist and _Args...
         _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);
         }

any::~any ( )

inline

         {   // destroy the contained value, if any (pun intended)
         reset();
         }

Member Function Documentation

void*& any::_BigPointer ( )

inlineprivate

         {
         return (_Storage._BigStorage._Ptr);
         }

void* const& any::_BigPointer ( ) const

inlineprivate

         {
         return (_Storage._BigStorage._Ptr);
         }

const _Any_big_RTTI*& any::_BigRTTI ( )

inlineprivate

         {
         return (_Storage._BigStorage._RTTI);
         }

const _Any_big_RTTI* const& any::_BigRTTI ( ) const

inlineprivate

         {
         return (_Storage._BigStorage._RTTI);
         }

template<class _Decayed >

const _Decayed* any::_Cast ( ) const

inline

         {   //  if *this contains a value of type _Decayed, return a pointer to it
         const type_info * const _Info = _TypeInfo();
         if (_Info && *_Info == typeid(_Decayed))
             {
             return (_Cast1<_Decayed>(_Any_is_small<_Decayed>{}, _Any_is_trivial<_Decayed>{}));
             }
 
         return (nullptr_t{});
         }

template<class _Decayed >

_Decayed* any::_Cast ( )

inline

         {   //  if *this contains a value of type _Decayed, return a pointer to it
         return (const_cast<_Decayed *>(const_cast<const any *>(this)->_Cast<_Decayed>()));
         }

template<class _Decayed >

const _Decayed* any::_Cast1	(	false_type	,
		false_type
	)		const

inlineprivate

         {   // get a pointer to the contained _Big value of type _Decayed
         return (static_cast<const _Decayed *>(_BigPointer()));
         }

template<class _Decayed >

const _Decayed* any::_Cast1	(	true_type	,
		false_type
	)		const

inlineprivate

         {   // get a pointer to the contained _Small value of type _Decayed
         return (static_cast<const _Decayed *>(_SmallData()));
         }

template<class _Decayed >

const _Decayed* any::_Cast1	(	_Any_tag	,
		true_type
	)		const

inlineprivate

         {   // get a pointer to the contained _Trivial value of type _Decayed
         return (reinterpret_cast<const _Decayed *>(&_Storage._TrivialData));
         }

template<class _Decayed , class... _Types>

void any::_Emplace ( _Types &&... _Args )

inlineprivate

         {
         static_assert(alignof(_Decayed) <= alignof(max_align_t),
             "Sorry: std::any doesn't support over-aligned types at this time.");
         _Emplace1<_Decayed>(_Any_is_small<_Decayed>{}, _Any_is_trivial<_Decayed>{},
             _STD forward<_Types>(_Args)...);
         }

template<class _Decayed , class... _Types>

void any::_Emplace1	(	false_type	,
		false_type	,
		_Types &&...	_Args
	)

inlineprivate

         {   // emplace construct _Decayed using the _Big representation
         _BigPointer() = ::new _Decayed(_STD forward<_Types>(_Args)...);
         _BigRTTI() = &_Any_big_RTTI_obj<_Decayed>;
         _TypeData() = reinterpret_cast<uintptr_t>(&typeid(_Decayed))
             | static_cast<uintptr_t>(_Any_representation::_Big);
         }

template<class _Decayed , class... _Types>

void any::_Emplace1	(	true_type	,
		false_type	,
		_Types &&...	_Args
	)

inlineprivate

         {   // emplace construct _Decayed using the _Small representation
         _Construct_in_place(reinterpret_cast<_Decayed&>(_Storage._SmallStorage._Data),
             _STD forward<_Types>(_Args)...);
         _SmallRTTI() = &_Any_small_RTTI_obj<_Decayed>;
         _TypeData() = reinterpret_cast<uintptr_t>(&typeid(_Decayed))
             | static_cast<uintptr_t>(_Any_representation::_Small);
         }

template<class _Decayed , class... _Types>

void any::_Emplace1	(	_Any_tag	,
		true_type	,
		_Types &&...	_Args
	)

inlineprivate

         {   // emplace construct _Decayed using the _Trivial representation
         _Construct_in_place(reinterpret_cast<_Decayed&>(_Storage._TrivialData),
             _STD forward<_Types>(_Args)...);
         _TypeData() = reinterpret_cast<uintptr_t>(&typeid(_Decayed))
             | static_cast<uintptr_t>(_Any_representation::_Trivial);
         }

void any::_Move_from ( any & _That )

inlineprivate

         {
         _TypeData() = _That._TypeData();
         switch (_Rep())
             {
             case _Any_representation::_Small:
                 _SmallRTTI() = _That._SmallRTTI();
                 _SmallRTTI()->_Move(_SmallData(), _That._SmallData());
                 break;
             case _Any_representation::_Big:
                 _BigRTTI() = _That._BigRTTI();
                 _BigPointer() = _That._BigPointer();
                 _That._TypeData() = 0;
                 break;
             case _Any_representation::_Trivial:
             default:
                 _Storage._TrivialData = _That._Storage._TrivialData;
                 break;
             }
         }

_Any_representation any::_Rep ( ) const

inlineprivate

         {   // extract the representation format from _TypeData
         return (static_cast<_Any_representation>(_TypeData() & _Rep_mask));
         }

void* any::_SmallData ( )

inlineprivate

         {
         return (&_Storage._SmallStorage._Data);
         }

const void* any::_SmallData ( ) const

inlineprivate

         {
         return (&_Storage._SmallStorage._Data);
         }

const _Any_small_RTTI*& any::_SmallRTTI ( )

inlineprivate

         {
         return (_Storage._SmallStorage._RTTI);
         }

const _Any_small_RTTI* const& any::_SmallRTTI ( ) const

inlineprivate

         {
         return (_Storage._SmallStorage._RTTI);
         }

uintptr_t& any::_TypeData ( )

inlineprivate

         {
         return (_Storage._TypeData);
         }

const uintptr_t& any::_TypeData ( ) const

inlineprivate

         {
         return (_Storage._TypeData);
         }

const type_info* any::_TypeInfo ( ) const

inlineprivate

         {   // extract the type_info from _TypeData
         return (reinterpret_cast<const type_info *>(_TypeData() & ~_Rep_mask));
         }

template<class _ValueType , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

void any::emplace ( _Types &&... _Args )

inline

         {   // replace contained value with an object of type decay_t<_ValueType> initialized from _Args...
         reset();
         _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);
         }

template<class _ValueType , class _Elem , class... _Types, enable_if_t< is_constructible< decay_t< _ValueType >, initializer_list< _Elem > &, _Types...>::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

void any::emplace	(	initializer_list< _Elem >	_Ilist,
		_Types &&...	_Args
	)

inline

         {   // replace contained value with an object of type decay_t<_ValueType> initialized from _Ilist and _Args...
         reset();
         _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);
         }

bool any::has_value ( ) const

inline

         {   // return true iff *this contains a value
         return (_TypeData() != 0);
         }

any& any::operator= ( const any & _That )

inline

         {   // copy _That's value to *this, if any
         *this = any{_That};
         return (*this);
         }

any& any::operator= ( any && _That )

inline

         {   // move _That's value to *this, if any
         reset();
         _Move_from(_That);
         return (*this);
         }

template<class _ValueType , enable_if_t<!is_same< decay_t< _ValueType >, any >::value &&is_copy_constructible< decay_t< _ValueType >>::value, int > = 0>

any& any::operator= ( _ValueType && _Value )

inline

         {   // replace contained value with an object of type decay_t<_ValueType> initialized from _Value
         *this = any{_STD forward<_ValueType>(_Value)};
         return (*this);
         }

void any::reset ( )

inline

         {   // transition to the empty state
         switch (_Rep())
             {
             case _Any_representation::_Small:
                 _SmallRTTI()->_Destroy(_SmallData());
                 break;
             case _Any_representation::_Big:
                 _BigRTTI()->_Destroy(_BigPointer());
                 break;
             case _Any_representation::_Trivial:
             default:
                 break;
             }
         _TypeData() = 0;
         }

void any::swap ( any & _That )

inline

         {   // exchange the values of *this and _That
         _That = _STD exchange(*this, _STD move(_That));
         }

const type_info& any::type ( ) const

inline

         {   // if *this contains a value of type T, return typeid(T); otherwise typeid(void)
         const type_info * const _Info = _TypeInfo();
         if (_Info)
             {
             return (*_Info);
             }
 
         return (typeid(void));
         }

Member Data Documentation

union { ... }

max_align_t any::_Dummy

constexpr uintptr_t any::_Rep_mask = 3

staticprivate

_Storage_t any::_Storage

The documentation for this class was generated from the following file:

VS2017/inc/any

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation