functional File Reference

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

Classes
class	_Mem_fn< _Memptr >
class	bad_function_call
class	function< _Fty >
class	_Func_base< _Rx, _Types >
union	_Storage
struct	_Get_function_impl< _Tx >
class	function< _Fty >
struct	_Ph< _Nx >
struct	is_placeholder< _Tx >
struct	is_placeholder< _Ph< _Nx > >
struct	is_placeholder< const _Tx >
struct	is_placeholder< volatile _Tx >
struct	is_placeholder< const volatile _Tx >
class	_Binder< _Ret, _Fx, _Types >
struct	is_bind_expression< _Tx >
struct	is_bind_expression< _Binder< _Ret, _Fx, _Types...> >
struct	is_bind_expression< const _Tx >
struct	is_bind_expression< volatile _Tx >
struct	is_bind_expression< const volatile _Tx >
struct	_Select_fixer< _Cv_TiD, bool, bool, int >
struct	_Select_fixer< _Cv_TiD, true, false, 0 >
struct	_Select_fixer< _Cv_TiD, false, true, 0 >
struct	_Select_fixer< _Cv_TiD, false, false, 0 >
struct	_Select_fixer< _Cv_TiD, false, false, _Jx >
struct	_Forced_result_type< _Ret >
struct	_Binder_result_type< _Ret, _Fx >
class	_Binder< _Ret, _Fx, _Types >
struct	std::uses_allocator< function< _Fty >, _Alloc >

Namespaces
	placeholders

Macros
#define	_FUNCTIONAL_
#define	_GET_FUNCTION_IMPL(CALL_OPT, X1, X2)
#define	_BINDER_OPERATOR(CONST_OPT)

Enumerations
enum	{ _EEN_IMPL = _Num_ptrs - 1 }

Functions
template<class _Rx , class _Ty >
_Mem_fn< _Rx _Ty::* >	mem_fn (_Rx _Ty::*_Pm) _NOEXCEPT
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xbad_function_call ()
template<class _Ty >
bool	_Test_callable (const _Ty &_Arg, true_type) _NOEXCEPT
template<class _Ty >
bool	_Test_callable (const _Ty &, false_type) _NOEXCEPT
template<class _Ty >
bool	_Test_callable (const _Ty &_Arg) _NOEXCEPT
template<class _Fty >
bool	_Test_callable (const function< _Fty > &_Arg) _NOEXCEPT
template<class _Impl >
	_Set (0)
void	_Swap (_Myt &_Right) _NOEXCEPT
const _XSTD2 type_info &	_Target_type () const _NOEXCEPT
const void *	_Target (const _XSTD2 type_info &_Info) const _NOEXCEPT
bool	_Local () const _NOEXCEPT
_Ptrt *	_Getimpl () const _NOEXCEPT
void	_Set (_Ptrt *_Ptr) _NOEXCEPT
void *	_Getspace () _NOEXCEPT
template<class _Fty >
void	swap (function< _Fty > &_Left, function< _Fty > &_Right) _NOEXCEPT
template<class _Fty >
bool	operator== (const function< _Fty > &_Other, nullptr_t) _NOEXCEPT
template<class _Fty >
bool	operator== (nullptr_t, const function< _Fty > &_Other) _NOEXCEPT
template<class _Fty >
bool	operator!= (const function< _Fty > &_Other, nullptr_t) _NOEXCEPT
template<class _Fty >
bool	operator!= (nullptr_t, const function< _Fty > &_Other) _NOEXCEPT
template<class _Cv_TiD , class _Untuple >
auto	_Fix_arg (_Cv_TiD &_Tid, _Untuple &&_Ut) -> decltype(_Select_fixer< _Cv_TiD >::_Fix(_Tid, _STD move(_Ut)))
template<class _Ret , size_t... _Ix, class _Cv_FD , class _Cv_tuple_TiD , class _Untuple >
auto	_Call_binder (_Forced< _Ret > _Fr, integer_sequence< size_t, _Ix...>, _Cv_FD &_Obj, _Cv_tuple_TiD &_Tpl, _Untuple &&_Ut) -> decltype(_Invoke_ret(_Fr, _Obj, _Fix_arg(_STD get< _Ix >(_Tpl), _STD move(_Ut))...))
template<class _Fx , class... _Types>
_Binder< _Unforced, _Fx, _Types...>	bind (_Fx &&_Func, _Types &&..._Args)
template<class _Ret , class _Fx , class... _Types>
_Binder< _Ret, _Fx, _Types...>	bind (_Fx &&_Func, _Types &&..._Args)

Variables
const int	_Num_ptrs = 6 + 16 / sizeof (void *)
const size_t	_Space_size = (_Num_ptrs - 1) * sizeof (void *)
_Storage	_Mystorage
constexpr _Ph< 1 >	placeholders::_1
constexpr _Ph< 2 >	placeholders::_2 {}
constexpr _Ph< 3 >	placeholders::_3 {}
constexpr _Ph< 4 >	placeholders::_4 {}
constexpr _Ph< 5 >	placeholders::_5 {}
constexpr _Ph< 6 >	placeholders::_6 {}
constexpr _Ph< 7 >	placeholders::_7 {}
constexpr _Ph< 8 >	placeholders::_8 {}
constexpr _Ph< 9 >	placeholders::_9 {}
constexpr _Ph< 10 >	placeholders::_10 {}
constexpr _Ph< 11 >	placeholders::_11 {}
constexpr _Ph< 12 >	placeholders::_12 {}
constexpr _Ph< 13 >	placeholders::_13 {}
constexpr _Ph< 14 >	placeholders::_14 {}
constexpr _Ph< 15 >	placeholders::_15 {}
constexpr _Ph< 16 >	placeholders::_16 {}
constexpr _Ph< 17 >	placeholders::_17 {}
constexpr _Ph< 18 >	placeholders::_18 {}
constexpr _Ph< 19 >	placeholders::_19 {}
constexpr _Ph< 20 >	placeholders::_20 {}

Macro Definition Documentation

#define _BINDER_OPERATOR

(

CONST_OPT

)

Value:

template<class... _Unbound> \
        auto operator()(_Unbound&&... _Unbargs) CONST_OPT \
        -> decltype(_Call_binder(_Forced<_Ret>(), _Seq(), \
            _Mypair._Get_first(), _Mypair._Get_second(), \
            _STD forward_as_tuple(_STD forward<_Unbound>(_Unbargs)...))) \
        {   /* invoke bound callable object with bound/unbound arguments */ \
		return (_Call_binder(_Forced<_Ret>(), _Seq(), \
            _Mypair._Get_first(), _Mypair._Get_second(), \
			_STD forward_as_tuple(_STD forward<_Unbound>(_Unbargs)...))); \
        }

#define _FUNCTIONAL_

#define _GET_FUNCTION_IMPL	(		CALL_OPT,
			X1,
			X2
	)

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; \
    };

Enumeration Type Documentation

anonymous enum

private

Enumerator
_EEN_IMPL

{_EEN_IMPL = _Num_ptrs - 1};    // helper for expression evaluator

Function Documentation

template<class _Ret , size_t... _Ix, class _Cv_FD , class _Cv_tuple_TiD , class _Untuple >

auto _Call_binder ( _Forced< _Ret >  _Fr, integer_sequence< size_t, _Ix...>  , _Cv_FD &  _Obj, _Cv_tuple_TiD &  _Tpl, _Untuple &&  _Ut  ) -> decltype(_Invoke_ret(_Fr, _Obj, _Fix_arg( _STD get<_Ix>(_Tpl), _STD move(_Ut))...))

inlineprivate

    {   // bind() and bind<R>() invocation
    (void) _Tpl;    // TRANSITION, VSO#181496
    (void) _Ut;
    return (_Invoke_ret(_Fr, _Obj, _Fix_arg(
        _STD get<_Ix>(_Tpl), _STD move(_Ut))...));
    }

template<class _Cv_TiD , class _Untuple >

auto _Fix_arg ( _Cv_TiD &  _Tid, _Untuple &&  _Ut  ) -> decltype(_Select_fixer<_Cv_TiD>::_Fix(_Tid, _STD move(_Ut)))

inlineprivate

    {   // translate an argument for bind
    return (_Select_fixer<_Cv_TiD>::_Fix(_Tid, _STD move(_Ut)));
    }

_Ptrt* _Getimpl ( ) const

private

        {   // get pointer to object
        return (_Mystorage._Ptrs[_Num_ptrs - 1]);
        }

const void * _Getspace ( )

private

        {   // get pointer to storage space
        return (&_Mystorage);
        }

bool _Local ( ) const

private

        {   // test for locally stored copy of object
        return (_Getimpl() == _Getspace());
        }

template<class _Impl >

_Set

(

0

)

void _Set ( _Ptrt *  _Ptr )

private

        {   // store pointer to object
        _Mystorage._Ptrs[_Num_ptrs - 1] = _Ptr;
        }

void _Swap

(

_Myt &

_Right

)

        {   // swap contents with contents of _Right
        if (!_Local() && !_Right._Local())
            {   // just swap pointers
            _Ptrt *_Temp = _Getimpl();
            _Set(_Right._Getimpl());
            _Right._Set(_Temp);
            }
        else
            {   // do three-way move
            _Myt _Temp;
            _Temp._Reset_move(_STD move(*this));
            _Reset_move(_STD move(_Right));
            _Right._Reset_move(_STD move(_Temp));
            }
        }

const void* _Target

(

const _XSTD2 type_info &

_Info

)

const

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

const _XSTD2 type_info& _Target_type

(

)

const

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

template<class _Ty >

bool _Test_callable ( const _Ty &  _Arg, true_type    )

inline

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

template<class _Ty >

bool _Test_callable ( const _Ty &  , false_type    )

inline

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

template<class _Ty >

bool _Test_callable ( const _Ty &  _Arg )

inline

    {   // determine whether std::function must store _Arg
    _Cat_base<is_member_pointer<_Ty>::value || (is_pointer<_Ty>::value
        && is_function<typename remove_pointer<_Ty>::type>::value)> _Testable;
    return (_Test_callable(_Arg, _Testable));
    }

template<class _Fty >

bool _Test_callable ( const function< _Fty > &  _Arg )

inline

    {   // determine whether std::function must store _Arg
    return (!!_Arg);
    }

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_function_call

(

)

template<class _Fx , class... _Types>

_Binder<_Unforced, _Fx, _Types...> bind ( _Fx &&  _Func, _Types &&...  _Args  )

inlineprivate

    {   // bind a callable object with an implicit return type
    return (_Binder<_Unforced, _Fx, _Types...>(
        _STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...));
    }

template<class _Ret , class _Fx , class... _Types>

_Binder<_Ret, _Fx, _Types...> bind ( _Fx &&  _Func, _Types &&...  _Args  )

inlineprivate

    {   // bind a callable object with an explicit return type
    return (_Binder<_Ret, _Fx, _Types...>(
        _STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...));
    }

template<class _Rx , class _Ty >

_Mem_fn<_Rx _Ty::*> mem_fn ( _Rx _Ty::*  _Pm )

inline

    {   // wrap a pointer to member function/data
    return (_Mem_fn<_Rx _Ty::*>(_Pm));
    }

template<class _Fty >

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

inlineprivate

    {   // compare to null pointer
    return (static_cast<bool>(_Other));
    }

template<class _Fty >

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

inlineprivate

    {   // compare to null pointer
    return (static_cast<bool>(_Other));
    }

template<class _Fty >

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

inlineprivate

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

template<class _Fty >

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

inlineprivate

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

template<class _Fty >

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

inlineprivate

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

Variable Documentation

_Storage _Mystorage

const int _Num_ptrs = 6 + 16 / sizeof (void *)

const size_t _Space_size = (_Num_ptrs - 1) * sizeof (void *)