functional File Reference

#include <xfunctional>
#include <exception>
#include <typeinfo>
#include <tuple>

Classes
class	_Mem_fn_wrap< _Rx, _Pmf, _Arg0, _Types >
class	_Mem_fn_wrap< _Rx, _Pmf, _Arg0, _Arg1 >
class	bad_function_call
class	_Func_base< _Rx, _Types >
class	_Func_impl< _Callable, _Alloc, _Rx, _Types >
class	function< _Fty >
struct	_Testable_callable1< _Ty >
struct	_Testable_callable1< function< _Fty > >
struct	_Testable_callable< _Ty >
class	_Func_class< _Ret, _Types >
struct	_Get_function_impl< _Tx >
class	function< _Fty >
class	_Ph< _Nx >
struct	is_placeholder< _Tx >
struct	is_placeholder< _Ph< _Nx > >
struct	is_bind_expression< _Tx >
struct	_Notforced
class	_Bind< _Forced, _Ret, _Fun, _Types >
struct	_Is_reference_wrapper0< _Barg >
struct	_Is_reference_wrapper0< reference_wrapper< _Barg > >
struct	_Is_reference_wrapper< _Barg >

Macros
#define	_FUNCTIONAL_
#define	_MEM_FN_WRAP(CALL_OPT, X1, CV_OPT)
#define	_FUNC_CLASS_RESET_PF(CALL_OPT, X1)
#define	_FUNC_CLASS_RESET_PMF(CALL_OPT, X1, CV_OPT)
#define	_GET_FUNCTION_IMPL(CALL_OPT, X1)
#define	_IS_BIND_EXPRESSION(CV_OPT)
#define	_REFWRAP_IMPL_PMD(CV_OPT)
#define	_IMPLICIT_PMF_WRAP(CALL_OPT, X1, CV_OPT)
#define	_EXPLICIT_PMF_WRAP(CALL_OPT, X1, CV_OPT)

Enumerations
enum	_Barg_type { _Reference_wrapper, _Placeholder, _Bind_expression, _UDT }

Functions
template<class _Rx , class _Arg0 >
_STD_BEGIN _Call_wrapper< _Callable_pmd< _Rx _Arg0::*const, _Arg0 > >	mem_fn (_Rx _Arg0::*const _Pmd)
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Xbad_function_call())
template<class _Ty >
bool	_Test_callable (_Ty &_Arg, true_type)
template<class _Ty >
bool	_Test_callable (_Ty &, false_type)
template<class _Ty >
bool	_Test_callable (_Ty &_Arg)
template<class _Fty >
void	swap (function< _Fty > &_Left, function< _Fty > &_Right)
template<class _Fty >
bool	operator== (const function< _Fty > &_Other, nullptr_t) _NOEXCEPT
template<class _Fty >
bool	operator== (nullptr_t _Npc, const function< _Fty > &_Other) _NOEXCEPT
template<class _Fty >
bool	operator!= (const function< _Fty > &_Other, nullptr_t _Npc) _NOEXCEPT
template<class _Fty >
bool	operator!= (nullptr_t _Npc, const function< _Fty > &_Other) _NOEXCEPT

Macro Definition Documentation

#define _EXPLICIT_PMF_WRAP	(		CALL_OPT,
			X1,
			CV_OPT
	)

Value:

template<class _Ret, \
    class _Rx, \
    class _Farg0, \
    class... _Ftypes, \
    class... _Types> inline \
    typename enable_if<!is_same<_Ret, _Rx>::value, \
        _Bind<true, _Ret, \
            _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
                _Rx, _Farg0, _Ftypes...>, \
                    _Types...> >::type \
        bind(_Rx (CALL_OPT _Farg0::* const _Pmf)(_Ftypes...) CV_OPT, \
            _Types&&... _Args) \
    {   /* bind a wrapped CV_OPT member function pointer */ \
	return (_Bind<true, _Ret, \
        _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
            _Rx, _Farg0, _Ftypes...>, \
        _Types...>( \
        _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
            _Rx, _Farg0, _Ftypes...>(_Pmf), \
                _STD forward<_Types>(_Args)...)); \
    }

#define _FUNC_CLASS_RESET_PF	(		CALL_OPT,
			X1
	)

Value:

template<class _Fret, \
        class... _Ftypes> \
		void _Reset(_Fret (CALL_OPT *const _Val)(_Ftypes&&... _Fargs)) \
        {   /* store copy of _Val */ \
        _Reset_alloc(_Val, allocator<_Myt>()); \
        } \
    template<class _Fret, \
        class... _Ftypes, \
        class _Alloc> \
        void _Reset_alloc(_Fret (CALL_OPT *const _Val)(_Ftypes&&... _Fargs), \
            _Alloc _Ax) \
        {   /* store copy of _Val with allocator */ \
        typedef _Callable_fun<_Fret (CALL_OPT *const)(_Ftypes&&...)> \
            _MyWrapper; \
        typedef _Func_impl<_MyWrapper, _Alloc, _Ret, _Types...> _Myimpl; \
        _Do_alloc<_Myimpl>(_Val, _Ax); \
        }

#define _FUNC_CLASS_RESET_PMF	(		CALL_OPT,
			X1,
			CV_OPT
	)

Value:

template<class _Fret, \
        class _Farg0, \
        class... _Ftypes> \
		void _Reset(_Fret (CALL_OPT _Farg0::*const _Val)(_Ftypes...) CV_OPT) \
        {   /* store copy of _Val */ \
        _Reset_alloc(_Val, allocator<_Myt>()); \
        } \
    template<class _Fret, \
        class _Farg0, \
        class... _Ftypes, \
        class _Alloc> \
        void _Reset_alloc(_Fret (CALL_OPT _Farg0::*const _Val)(_Ftypes...) \
            CV_OPT, _Alloc _Ax) \
        {   /* store copy of _Val with allocator */ \
        typedef _Callable_pmf< \
            _Fret (CALL_OPT _Farg0::*const)(_Ftypes...) CV_OPT, _Farg0> \
                _MyWrapper; \
        typedef _Func_impl<_MyWrapper, _Alloc, _Ret, _Farg0, _Ftypes...> \
            _Myimpl; \
        _Do_alloc<_Myimpl>(_Val, _Ax); \
        }

#define _FUNCTIONAL_

#define _GET_FUNCTION_IMPL	(		CALL_OPT,
			X1
	)

Value:

template<class _Ret, \
    class... _Types> \
    struct _Get_function_impl<_Ret CALL_OPT (_Types...)> \
    {   /* determine type from argument list */ \
    typedef _Func_class<_Ret, _Types...> type; \
    };

#define _IMPLICIT_PMF_WRAP	(		CALL_OPT,
			X1,
			CV_OPT
	)

Value:

template<class _Rx, \
    class _Farg0, \
    class... _Ftypes, \
    class... _Types> inline \
    _Bind<true, _Rx, \
        _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
            _Rx, _Farg0, _Ftypes...>, \
        _Types...> \
        bind(_Rx (CALL_OPT _Farg0::* const _Pmf)(_Ftypes...) CV_OPT, \
            _Types&&... _Args) \
    {   /* bind a wrapped CV_OPT member function pointer */ \
	return (_Bind<true, _Rx, \
        _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
            _Rx, _Farg0, _Ftypes...>, \
        _Types...>( \
        _Pmf_wrap<_Rx (CALL_OPT _Farg0::*)(_Ftypes...) CV_OPT, \
            _Rx, _Farg0, _Ftypes...>(_Pmf), \
                _STD forward<_Types>(_Args)...)); \
    }

#define _IS_BIND_EXPRESSION

(

CV_OPT

)

Value:

template<bool _Forced, \
    class _Ret, \
    class _Fun, \
    class... _Types> \
    struct is_bind_expression<CV_OPT \
        _Bind<_Forced, _Ret, _Fun, _Types...> > \
        : true_type \
    {   /* specialization to indicate a bind expression */ \
    };

#define _MEM_FN_WRAP	(		CALL_OPT,
			X1,
			CV_OPT
	)

Value:

template<class _Rx, \
    class _Arg0, \
    class... _Types> \
    _Mem_fn_wrap<_Rx, _Rx(CALL_OPT _Arg0::*)(_Types...) CV_OPT, \
        CV_OPT _Arg0, _Types...> \
			mem_fn(_Rx(CALL_OPT _Arg0::*_Pm)(_Types...) CV_OPT) \
    {   /* bind to pointer to member function */ \
	return (_Mem_fn_wrap<_Rx, _Rx(CALL_OPT _Arg0::*)(_Types...) CV_OPT, \
        CV_OPT _Arg0, _Types...>(_Pm)); \
    }

#define _REFWRAP_IMPL_PMD

(

CV_OPT

)

Value:

CV_OPT _Rx& operator()(CV_OPT _Farg0& _Fnobj) const \
        {   /* get the data */ \
		return (_Fnobj.*_Mypmd); \
        }

Enumeration Type Documentation

enum _Barg_type

Enumerator
_Reference_wrapper
_Placeholder
_Bind_expression
_UDT

    {   // classifications
    _Reference_wrapper,
    _Placeholder,
    _Bind_expression,
    _UDT
    };

Function Documentation

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Xbad_function_call()

)

template<class _Ty >

bool _Test_callable ( _Ty &  _Arg, true_type    )

inline

    {   // std::function must store non-null testable callable objects
    return (!!_Arg);
    }

template<class _Ty >

bool _Test_callable ( _Ty &  , false_type    )

inline

    {   // std::function must store arbitrary callable objects
    return (true);
    }

template<class _Ty >

bool _Test_callable ( _Ty &  _Arg )

inline

    {   // determine whether std::function must store _Arg
    return (_Test_callable(_Arg, _Testable_callable<_Ty>()));
    }

template<class _Rx , class _Arg0 >

_STD_BEGIN _Call_wrapper<_Callable_pmd<_Rx _Arg0::*const, _Arg0> > mem_fn

(

_Rx _Arg0::*const

_Pmd

)

    {   // return data object wrapper
    return (_Call_wrapper<_Callable_pmd<_Rx _Arg0::*const, _Arg0> >(_Pmd));
    }

template<class _Fty >

bool operator!=	(	const function< _Fty > &	_Other,
		nullptr_t	_Npc
	)

    {   // compare to null pointer
    return (!operator==(_Other, _Npc));
    }

template<class _Fty >

bool operator!=	(	nullptr_t	_Npc,
		const function< _Fty > &	_Other
	)

    {   // compare to null pointer
    return (!operator==(_Other, _Npc));
    }

template<class _Fty >

bool operator==	(	const function< _Fty > &	_Other,
		nullptr_t
	)

    {   // compare to null pointer
    return (!_Other);
    }

template<class _Fty >

bool operator==	(	nullptr_t	_Npc,
		const function< _Fty > &	_Other
	)

    {   // compare to null pointer
    return (operator==(_Other, _Npc));
    }

template<class _Fty >

void swap	(	function< _Fty > &	_Left,
		function< _Fty > &	_Right
	)

    {   // swap contents of _Left with contents of _Right
    _Left.swap(_Right);
    }