function< _Fty > Class Template Reference

Inheritance diagram for function< _Fty >:

Public Types
typedef function< _Fty >	_Myt

Public Member Functions
	function () _NOEXCEPT
	function (nullptr_t) _NOEXCEPT
	function (const _Myt &_Right)
template<class _Fx , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<_Fx&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>
	function (_Fx _Func)
template<class _Alloc >
	function (allocator_arg_t, const _Alloc &) _NOEXCEPT
template<class _Alloc >
	function (allocator_arg_t, const _Alloc &, nullptr_t) _NOEXCEPT
template<class _Alloc >
	function (allocator_arg_t, const _Alloc &_Ax, const _Myt &_Right)
template<class _Fx , class _Alloc , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<_Fx&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>
	function (allocator_arg_t, const _Alloc &_Ax, _Fx _Func)
	~function () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
	function (_Myt &&_Right)
template<class _Alloc >
	function (allocator_arg_t, const _Alloc &_Al, _Myt &&_Right)
_Myt &	operator= (_Myt &&_Right)
template<class _Fx , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<decay_t<_Fx>&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>
_Myt &	operator= (_Fx &&_Func)
_Myt &	operator= (nullptr_t) _NOEXCEPT
template<class _Fx >
_Myt &	operator= (reference_wrapper< _Fx > _Func) _NOEXCEPT
void	swap (_Myt &_Right) _NOEXCEPT
	operator bool () const _NOEXCEPT
const _XSTD2 type_info &	target_type () const _NOEXCEPT
template<class _Fx >
_Fx *	target () _NOEXCEPT
template<class _Fx >
const _Fx *	target () const _NOEXCEPT

Private Types
typedef _Get_function_impl< _Fty >::type	_Mybase

Member Typedef Documentation

template<class _Fty>

typedef _Get_function_impl<_Fty>::type function< _Fty >::_Mybase

private

template<class _Fty>

typedef function<_Fty> function< _Fty >::_Myt

Constructor & Destructor Documentation

template<class _Fty>

function< _Fty >::function ( )

inline

        {   // construct empty function wrapper
        }

template<class _Fty>

function< _Fty >::function ( nullptr_t  )

inline

        {   // construct empty function wrapper from null pointer
        }

template<class _Fty>

function< _Fty >::function ( const _Myt &  _Right )

inline

        {   // construct holding copy of _Right
        this->_Reset_copy(_Right);
        }

template<class _Fty>

template<class _Fx , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<_Fx&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>

function< _Fty >::function ( _Fx  _Func )

inline

        {   // construct wrapper holding copy of _Func
        this->_Reset(_STD move(_Func));
        }

template<class _Fty>

template<class _Alloc >

function< _Fty >::function ( allocator_arg_t  , const _Alloc &    )

inline

        {   // construct empty function wrapper, allocator
        }

template<class _Fty>

template<class _Alloc >

function< _Fty >::function ( allocator_arg_t  , const _Alloc &  , nullptr_t    )

inline

        {   // construct empty function wrapper from null pointer, allocator
        }

template<class _Fty>

template<class _Alloc >

function< _Fty >::function ( allocator_arg_t  , const _Alloc &  _Ax, const _Myt &  _Right  )

inline

        {   // construct wrapper holding copy of _Right, allocator
        this->_Reset_alloc(_Right, _Ax);
        }

template<class _Fty>

template<class _Fx , class _Alloc , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<_Fx&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>

function< _Fty >::function ( allocator_arg_t  , const _Alloc &  _Ax, _Fx  _Func  )

inline

        {   // construct wrapper holding copy of _Func, allocator
        this->_Reset_alloc(_STD move(_Func), _Ax);
        }

template<class _Fty>

function< _Fty >::~function ( )

inline

        {   // destroy the object
        }

template<class _Fty>

function< _Fty >::function ( _Myt &&  _Right )

inline

        {   // construct holding moved copy of _Right
        this->_Reset_move(_STD move(_Right));
        }

template<class _Fty>

template<class _Alloc >

function< _Fty >::function ( allocator_arg_t  , const _Alloc &  _Al, _Myt &&  _Right  )

inline

        {   // construct wrapper holding moved copy of _Right, allocator
        this->_Reset_alloc(_STD move(_Right), _Al);
        }

Member Function Documentation

template<class _Fty>

function< _Fty >::operator bool ( ) const

inlineexplicit

        {   // test if wrapper holds function object
        return (!this->_Empty());
        }

template<class _Fty>

_Myt& function< _Fty >::operator= ( const _Myt &  _Right )

inline

        {   // assign _Right
        _Myt(_Right).swap(*this);
        return (*this);
        }

template<class _Fty>

_Myt& function< _Fty >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // clean up and copy
            this->_Tidy();
            this->_Reset_move(_STD move(_Right));
            }
        return (*this);
        }

template<class _Fty>

template<class _Fx , class _Inv_res = typename _Mybase::template _Result_of_invoking_t<decay_t<_Fx>&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res>>

_Myt& function< _Fty >::operator= ( _Fx &&  _Func )

inline

        {   // assign function object _Func
        _Myt(_STD forward<_Fx>(_Func)).swap(*this);
        return (*this);
        }

template<class _Fty>

_Myt& function< _Fty >::operator= ( nullptr_t  )

inline

        {   // clear function object
        this->_Tidy();
        return (*this);
        }

template<class _Fty>

template<class _Fx >

_Myt& function< _Fty >::operator= ( reference_wrapper< _Fx >  _Func )

inline

        {   // assign wrapper holding reference_wrapper to function object
        this->_Tidy();
        this->_Reset(_Func);
        return (*this);
        }

template<class _Fty>

void function< _Fty >::swap ( _Myt &  _Right )

inline

        {   // swap with _Right
        this->_Swap(_Right);
        }

template<class _Fty>

template<class _Fx >

_Fx* function< _Fty >::target ( )

inline

        {   // return pointer to target object
        return (static_cast<_Fx *>(const_cast<void *>(
            this->_Target(typeid(_Fx)))));
        }

template<class _Fty>

template<class _Fx >

const _Fx* function< _Fty >::target ( ) const

inline

        {   // return pointer to target object
        return (static_cast<const _Fx *>(this->_Target(typeid(_Fx))));
        }

template<class _Fty>

const _XSTD2 type_info& function< _Fty >::target_type ( ) const

inline

        {   // return type_info object for target type
        return (this->_Target_type());
        }

---

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

• VS2015/inc/functional