scoped_allocator File Reference

#include <tuple>
#include <xmemory0>

Classes
class	scoped_allocator_adaptor< _Outer, _Inner >
struct	_Scoped_propagate_on_container_copy< _Outer, _Inner >
struct	_Scoped_propagate_on_container_copy< _Outer >
struct	_Scoped_propagate_on_container_move< _Outer, _Inner >
struct	_Scoped_propagate_on_container_move< _Outer >
struct	_Scoped_propagate_on_container_swap< _Outer, _Inner >
struct	_Scoped_propagate_on_container_swap< _Outer >
struct	_Scoped_is_always_equal< _Outer, _Inner >
struct	_Scoped_is_always_equal< _Outer >
struct	_Scoped_outermost_allocator< _Outer >
struct	_Scoped_base< _Outer, _Inner >
struct	_Scoped_base< _Outer, _Inner0, _Inner...>
struct	_Scoped_base< _Outer >
class	scoped_allocator_adaptor< _Outer, _Inner >
struct	scoped_allocator_adaptor< _Outer, _Inner >::rebind< _Other >

Macros
#define	_SCOPED_ALLOCATOR_

Functions
template<class _Outermost , class _Inner , class _Ty , class... _Types, class _Dont_care >
void	_Scoped_construct (_Outermost, _Inner, false_type, _Dont_care, _Ty *_Ptr, _Types &&..._Args)
template<class _Outermost , class _Inner , class _Ty , class... _Types>
void	_Scoped_construct (_Outermost _Alval, _Inner _Inner_alval, true_type, false_type, _Ty *_Ptr, _Types &&..._Args)
template<class _Outermost , class _Inner , class _Ty , class... _Types>
void	_Scoped_construct (_Outermost _Alval, _Inner _Inner_alval, true_type, true_type, _Ty *_Ptr, _Types &&..._Args)
template<class _Alloc , class _Ty , class... _Atypes, class _Dont_care >
tuple< _Atypes...>	_Scoped_construct_tuple (_Alloc &, false_type, _Dont_care, tuple< _Atypes...> _Val)
template<class _Alloc , class _Ty , class... _Atypes>
tuple< allocator_arg_t, _Alloc &, _Atypes...>	_Scoped_construct_tuple (_Alloc &_Alty, true_type, false_type, tuple< _Atypes...> _Val)
template<class _Alloc , class _Ty , class... _Atypes>
tuple< _Atypes..., _Alloc & >	_Scoped_construct_tuple (_Alloc &_Alty, true_type, true_type, tuple< _Atypes...> _Val)
template<class _Inner , class _Ty1 , class _Ty2 , class... _Uy1, class... _Uy2>
void	_Scoped_construct_pair (_Inner _Inner_alval, pair< _Ty1, _Ty2 > *_Ptr, tuple< _Uy1...> _Val1, tuple< _Uy2...> _Val2)
template<class _Outer1 , class _Outer2 , class _Inner1 , class... _Inner>
bool	operator== (const scoped_allocator_adaptor< _Outer1, _Inner1, _Inner...> &_Left, const scoped_allocator_adaptor< _Outer2, _Inner1, _Inner...> &_Right) _NOEXCEPT
template<class _Outer1 , class _Outer2 >
bool	operator== (const scoped_allocator_adaptor< _Outer1 > &_Left, const scoped_allocator_adaptor< _Outer2 > &_Right) _NOEXCEPT
template<class _Outer1 , class _Outer2 , class... _Inner>
bool	operator!= (const scoped_allocator_adaptor< _Outer1, _Inner...> &_Left, const scoped_allocator_adaptor< _Outer2, _Inner...> &_Right) _NOEXCEPT

Macro Definition Documentation

#define _SCOPED_ALLOCATOR_

Function Documentation

template<class _Outermost , class _Inner , class _Ty , class... _Types, class _Dont_care >

void _Scoped_construct	(	_Outermost	,
		_Inner	,
		false_type	,
		_Dont_care	,
		_Ty *	_Ptr,
		_Types &&...	_Args
	)

    {   // construct with optional arguments, no allocator
    ::new (static_cast<void *>(_Ptr)) _Ty(_STD forward<_Types>(_Args)...);
    }

template<class _Outermost , class _Inner , class _Ty , class... _Types>

void _Scoped_construct	(	_Outermost	_Alval,
		_Inner	_Inner_alval,
		true_type	,
		false_type	,
		_Ty *	_Ptr,
		_Types &&...	_Args
	)

    {   // construct with optional arguments, leading allocator
    allocator_traits<_Outermost>::construct(_Alval, _Ptr,
        allocator_arg, _Inner_alval,
            _STD forward<_Types>(_Args)...);
    }

template<class _Outermost , class _Inner , class _Ty , class... _Types>

void _Scoped_construct	(	_Outermost	_Alval,
		_Inner	_Inner_alval,
		true_type	,
		true_type	,
		_Ty *	_Ptr,
		_Types &&...	_Args
	)

    {   // construct with optional arguments, trailing allocator
    allocator_traits<_Outermost>::construct(_Alval, _Ptr,
        _STD forward<_Types>(_Args)...,
            _Inner_alval);
    }

template<class _Inner , class _Ty1 , class _Ty2 , class... _Uy1, class... _Uy2>

void _Scoped_construct_pair	(	_Inner	_Inner_alval,
		pair< _Ty1, _Ty2 > *	_Ptr,
		tuple< _Uy1...>	_Val1,
		tuple< _Uy2...>	_Val2
	)

    {   // construct pair from tuples
    ::new (static_cast<void *>(_Ptr)) pair<_Ty1, _Ty2>(piecewise_construct,
        _Scoped_construct_tuple<_Inner, _Ty1, _Uy1...>(
            _Inner_alval,
            uses_allocator<_Ty1, _Inner>(),
            is_constructible<_Ty1, _Uy1..., _Inner>(),
            _STD move(_Val1)),
        _Scoped_construct_tuple<_Inner, _Ty2, _Uy2...>(
            _Inner_alval,
            uses_allocator<_Ty2, _Inner>(),
            is_constructible<_Ty2, _Uy2..., _Inner>(),
            _STD move(_Val2)));
    }

template<class _Alloc , class _Ty , class... _Atypes, class _Dont_care >

tuple<_Atypes...> _Scoped_construct_tuple	(	_Alloc &	,
		false_type	,
		_Dont_care	,
		tuple< _Atypes...>	_Val
	)

    {   // construct tuple from tuple argument, no allocator
    return (_STD move(_Val));
    }

template<class _Alloc , class _Ty , class... _Atypes>

tuple<allocator_arg_t, _Alloc&, _Atypes...> _Scoped_construct_tuple	(	_Alloc &	_Alty,
		true_type	,
		false_type	,
		tuple< _Atypes...>	_Val
	)

    {   // construct tuple from tuple argument, leading allocator
    return (_STD tuple_cat(tuple<allocator_arg_t>(allocator_arg),
        tuple<_Alloc&>(_Alty), _STD move(_Val)));
    }

template<class _Alloc , class _Ty , class... _Atypes>

tuple<_Atypes..., _Alloc&> _Scoped_construct_tuple	(	_Alloc &	_Alty,
		true_type	,
		true_type	,
		tuple< _Atypes...>	_Val
	)

    {   // construct tuple from tuple argument, trailing allocator
    return (_STD tuple_cat(_STD move(_Val),
        tuple<_Alloc&>(_Alty)));
    }

template<class _Outer1 , class _Outer2 , class... _Inner>

bool operator!= ( const scoped_allocator_adaptor< _Outer1, _Inner...> &  _Left, const scoped_allocator_adaptor< _Outer2, _Inner...> &  _Right  )

inline

        {   // compare scoped_allocator_adaptors for equality
        return (!(_Left == _Right));
        }

template<class _Outer1 , class _Outer2 , class _Inner1 , class... _Inner>

bool operator== ( const scoped_allocator_adaptor< _Outer1, _Inner1, _Inner...> &  _Left, const scoped_allocator_adaptor< _Outer2, _Inner1, _Inner...> &  _Right  )

inline

        {   // compare scoped_allocator_adaptors for equality
        return (_Left.outer_allocator() == _Right.outer_allocator()
            && _Left.inner_allocator() == _Right.inner_allocator());
        }

template<class _Outer1 , class _Outer2 >

bool operator== ( const scoped_allocator_adaptor< _Outer1 > &  _Left, const scoped_allocator_adaptor< _Outer2 > &  _Right  )

inline

        {   // compare scoped_allocator_adaptors for equality
        return (_Left.outer_allocator() == _Right.outer_allocator());
        }