_Func_class< _Ret, _Types > Class Template Reference

Inheritance diagram for _Func_class< _Ret, _Types >:

Public Types
typedef _Func_class< _Ret, _Types...>	_Myt
typedef _Func_base< _Ret, _Types...>	_Ptrt
typedef _Ret	result_type

Public Member Functions
	_Func_class ()
_Ret	operator() (_Types..._Args) const
bool	_Empty () const
	~_Func_class () _NOEXCEPT

Protected Member Functions
void	_Reset ()
void	_Reset (const _Myt &_Right)
void	_Resetm (_Myt &&_Right)
template<class _Fty >
void	_Reset (_Fty &&_Val)
template<class _Fty , class _Alloc >
void	_Reset_alloc (_Fty &&_Val, _Alloc _Ax)
template<class _Fret , class _Farg0 >
void	_Reset (_Fret _Farg0::*const _Val)
template<class _Fret , class _Farg0 , class _Alloc >
void	_Reset_alloc (_Fret _Farg0::*const _Val, _Alloc _Ax)
void	_Tidy ()
void	_Swap (_Myt &_Right)
const _XSTD2 type_info &	_Target_type () const
const void *	_Target (const _XSTD2 type_info &_Info) const

Private Types
typedef void(*	_Pfnty) ()

Private Member Functions
template<class _Myimpl , class _Fty , class _Alloc >
void	_Do_alloc (_Fty &&_Val, _Alloc _Ax)
void	_Set (_Ptrt *_Ptr)
bool	_Local () const

Private Attributes
union {
_Pfnty   _Pfn [3]
void *   _Pobj [3]
long double   _Ldbl
char   _Alias [3 *sizeof(void *)]
}	_Space
_Ptrt *	_Impl

Member Typedef Documentation

template<class _Ret , class... _Types>

typedef _Func_class<_Ret, _Types...> _Func_class< _Ret, _Types >::_Myt

template<class _Ret , class... _Types>

typedef void(* _Func_class< _Ret, _Types >::_Pfnty) ()

private

template<class _Ret , class... _Types>

typedef _Func_base<_Ret, _Types...> _Func_class< _Ret, _Types >::_Ptrt

template<class _Ret , class... _Types>

typedef _Ret _Func_class< _Ret, _Types >::result_type

Constructor & Destructor Documentation

template<class _Ret , class... _Types>

_Func_class< _Ret, _Types >::_Func_class ( )

inline

        : _Impl(0)
        {   // construct without stored object
        }

template<class _Ret , class... _Types>

_Func_class< _Ret, _Types >::~_Func_class ( )

inline

        {   // destroy the object
        _Tidy();
        }

Member Function Documentation

template<class _Ret , class... _Types>

template<class _Myimpl , class _Fty , class _Alloc >

void _Func_class< _Ret, _Types >::_Do_alloc ( _Fty &&  _Val, _Alloc  _Ax  )

inlineprivate

        {   // store copy of _Val with allocator
        if (!_Test_callable(_Val))
            {   // null member pointer/function pointer/std::function
            _Set(0);
            return;
            }
        void *_Vptr = 0;
        _Myimpl *_Ptr = 0;
        if (sizeof (_Myimpl) <= sizeof (_Space))
            {   // small enough, allocate locally
            _Vptr = &_Space;
            _Ptr = ::new (_Vptr) _Myimpl(_STD forward<_Fty>(_Val));
            }
        else
            {   // use allocator
            typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
            _Vptr = _Al.allocate(1);
            _Ptr = ::new (_Vptr) _Myimpl(_STD forward<_Fty>(_Val), _Al);
            }
        _Set(_Ptr);
        }

template<class _Ret , class... _Types>

bool _Func_class< _Ret, _Types >::_Empty ( ) const

inline

        {   // return true if no stored object
        return (_Impl == 0);
        }

template<class _Ret , class... _Types>

bool _Func_class< _Ret, _Types >::_Local ( ) const

inlineprivate

        {   // test for locally stored copy of object
        return ((void *)_Impl == (void *)&_Space);
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Reset ( )

inlineprotected

        {   // remove stored object
        _Set(0);
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Reset ( const _Myt &  _Right )

inlineprotected

        {   // copy _Right's stored object
        if (_Right._Impl == 0)
            _Set(0);
        else if (_Right._Local())
            _Set(_Right._Impl->_Copy((void *)&_Space));
        else
            _Set(_Right._Impl->_Copy(0));
        }

template<class _Ret , class... _Types>

template<class _Fty >

void _Func_class< _Ret, _Types >::_Reset ( _Fty &&  _Val )

inlineprotected

        {   // store copy of _Val
        _Reset_alloc(_STD forward<_Fty>(_Val), allocator<_Myt>());
        }

template<class _Ret , class... _Types>

template<class _Fret , class _Farg0 >

void _Func_class< _Ret, _Types >::_Reset ( _Fret _Farg0::*const  _Val )

inlineprotected

        {   // store copy of _Val
        _Reset_alloc(_Val, allocator<_Myt>());
        }

template<class _Ret , class... _Types>

template<class _Fty , class _Alloc >

void _Func_class< _Ret, _Types >::_Reset_alloc ( _Fty &&  _Val, _Alloc  _Ax  )

inlineprotected

        {   // store copy of _Val with allocator
        typedef _Callable_obj<typename decay<_Fty>::type>
            _MyWrapper;
        typedef _Func_impl<_MyWrapper, _Alloc, _Ret, _Types...> _Myimpl;

        _Do_alloc<_Myimpl>(_STD forward<_Fty>(_Val), _Ax);
        }

template<class _Ret , class... _Types>

template<class _Fret , class _Farg0 , class _Alloc >

void _Func_class< _Ret, _Types >::_Reset_alloc ( _Fret _Farg0::*const  _Val, _Alloc  _Ax  )

inlineprotected

        {   // store copy of _Val with allocator
        typedef _Callable_pmd<_Fret _Farg0::*const, _Farg0>
            _MyWrapper;
        typedef _Func_impl<_MyWrapper, _Alloc, _Ret, _Farg0>
            _Myimpl;

        _Do_alloc<_Myimpl>(_Val, _Ax);
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Resetm ( _Myt &&  _Right )

inlineprotected

        {   // move _Right's stored object
        if (_Right._Impl == 0)
            _Set(0);
        else if (_Right._Local())
            {   // move and tidy
            _Set(_Right._Impl->_Move((void *)&_Space));
            _Right._Tidy();
            }
        else
            {   // steal from _Right
            _Set(_Right._Impl);
            _Right._Set(0);
            }
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Set ( _Ptrt *  _Ptr )

inlineprivate

        {   // store pointer to object
        _Impl = _Ptr;
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Swap ( _Myt &  _Right )

inlineprotected

        {   // swap contents with contents of _Right
        if (this == &_Right)
            ;   // same object, do nothing
        else if (!_Local() && !_Right._Local())
            _STD swap(_Impl, _Right._Impl); // just swap pointers
        else
            {   // do three-way copy
            _Myt _Temp;
            _Temp._Resetm(_STD forward<_Myt>(*this));
            _Tidy();
            _Resetm(_STD forward<_Myt>(_Right));
            _Right._Tidy();
            _Right._Resetm(_STD forward<_Myt>(_Temp));
            }
        }

template<class _Ret , class... _Types>

const void* _Func_class< _Ret, _Types >::_Target ( const _XSTD2 type_info &  _Info ) const

inlineprotected

        {   // return pointer to stored object
        return (_Impl ? _Impl->_Target(_Info) : 0);
        }

template<class _Ret , class... _Types>

const _XSTD2 type_info& _Func_class< _Ret, _Types >::_Target_type ( ) const

inlineprotected

        {   // return type information for stored object
        return (_Impl ? _Impl->_Target_type() : typeid(void));
        }

template<class _Ret , class... _Types>

void _Func_class< _Ret, _Types >::_Tidy ( )

inlineprotected

        {   // clean up
        if (_Impl != 0)
            {   // destroy callable object and maybe delete it
            _Impl->_Delete_this(!_Local());
            _Impl = 0;
            }
        }

template<class _Ret , class... _Types>

_Ret _Func_class< _Ret, _Types >::operator() ( _Types...  _Args ) const

inline

        {   // call through stored object
        if (_Impl == 0)
            _Xbad_function_call();
        return (_Impl->_Do_call(_STD forward<_Types>(_Args)...));
        }

Member Data Documentation

template<class _Ret , class... _Types>

char _Func_class< _Ret, _Types >::_Alias[3 *sizeof(void *)]

template<class _Ret , class... _Types>

_Ptrt* _Func_class< _Ret, _Types >::_Impl

private

template<class _Ret , class... _Types>

long double _Func_class< _Ret, _Types >::_Ldbl

template<class _Ret , class... _Types>

_Pfnty _Func_class< _Ret, _Types >::_Pfn[3]

template<class _Ret , class... _Types>

void* _Func_class< _Ret, _Types >::_Pobj[3]

union { ... } _Func_class< _Ret, _Types >::_Space

---

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

• VS2013/inc/functional