memory File Reference

#include <xmemory>
#include <exception>
#include <typeinfo>
#include <type_traits>

Classes
class	raw_storage_iterator< _OutIt, _Ty >
struct	_No_bad_weak_ptr
struct	default_delete< _Ty >
class	unique_ptr< _Ty, _Dx >
class	bad_weak_ptr
class	_Ref_count_base
class	_Ref_count< _Ty >
class	_Ref_count_del< _Ty, _Dx >
class	_Ref_count_del_alloc< _Ty, _Dx, _Alloc >
class	weak_ptr< _Ty >
class	shared_ptr< _Ty >
class	enable_shared_from_this< _Ty >
class	_Ptr_base< _Ty >
class	shared_ptr< _Ty >
class	_Ref_count_obj< _Ty >
class	_Ref_count_obj_alloc< _Ty, _Alloc >
class	weak_ptr< _Ty >
class	enable_shared_from_this< _Ty >
struct	default_delete< _Ty >
struct	default_delete< _Ty[]>
struct	_Get_deleter_pointer_type< _Ty, _Dx_noref, class >
struct	_Get_deleter_pointer_type< _Ty, _Dx_noref, void_t< typename _Dx_noref::pointer > >
class	_Unique_ptr_base< _Ty, _Dx >
class	unique_ptr< _Ty, _Dx >
class	unique_ptr< _Ty[], _Dx >
struct	owner_less< _Ty >
struct	owner_less< shared_ptr< _Ty > >
struct	owner_less< weak_ptr< _Ty > >
struct	owner_less< void >
struct	hash< unique_ptr< _Ty, _Dx > >
struct	hash< shared_ptr< _Ty > >
struct	_Shared_ptr_spin_lock

Macros
#define	_MEMORY_

Typedefs
typedef pointer_safety	_Pointer_safety

Enumerations
enum	pointer_safety { pointer_safety::relaxed, pointer_safety::preferred, pointer_safety::strict }

Functions
template<class _InIt , class _FwdIt >
_STD_BEGIN _FwdIt	_Uninitialized_copy_unchecked (_InIt _First, _InIt _Last, _FwdIt _Dest, _General_ptr_iterator_tag)
template<class _InIt , class _FwdIt >
_FwdIt	_Uninitialized_copy_unchecked (_InIt _First, _InIt _Last, _FwdIt _Dest, _Really_trivial_ptr_iterator_tag)
template<class _InIt , class _FwdIt >
_FwdIt	uninitialized_copy (_InIt _First, _InIt _Last, _FwdIt _Dest)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n_unchecked1 (_InIt _First, _Diff _Count, _FwdIt _Dest, _General_ptr_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n_unchecked1 (_InIt _First, _Diff _Count, _FwdIt _Dest, _Really_trivial_ptr_iterator_tag)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	_Uninitialized_copy_n_unchecked (_InIt _First, _Diff _Count, _FwdIt _Dest)
template<class _InIt , class _Diff , class _FwdIt >
_FwdIt	uninitialized_copy_n (_InIt _First, _Diff _Count, _FwdIt _Dest)
template<class _FwdIt , class _Tval >
void	_Uninitialized_fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Tval &_Val, false_type)
template<class _FwdIt , class _Tval >
void	_Uninitialized_fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Tval &_Val, true_type)
template<class _FwdIt , class _Tval >
void	uninitialized_fill (_FwdIt _First, _FwdIt _Last, const _Tval &_Val)
template<class _FwdIt , class _Diff , class _Tval >
_FwdIt	_Uninitialized_fill_n_unchecked (_FwdIt _First, _Diff _Count, const _Tval &_Val, false_type)
template<class _FwdIt , class _Diff , class _Tval >
_FwdIt	_Uninitialized_fill_n_unchecked (_FwdIt _First, _Diff _Count, const _Tval &_Val, true_type)
template<class _FwdIt , class _Diff , class _Tval >
_FwdIt	uninitialized_fill_n (_FwdIt _First, _Diff _Count, const _Tval &_Val)
template<class _Ty1 , class _Ty2 >
void	_Do_enable (_Ty1 *, enable_shared_from_this< _Ty2 > *, _Ref_count_base *)
template<class _Ty >
void	_Enable_shared (_Ty *_Ptr, _Ref_count_base *_Refptr, typename _Ty::_EStype *=0)
void	_Enable_shared (const volatile void *, const volatile void *)
template<class _Ty1 , class _Ty2 >
bool	operator== (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
bool	operator!= (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
bool	operator< (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
bool	operator>= (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
bool	operator> (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
bool	operator<= (const shared_ptr< _Ty1 > &_Left, const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator== (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator== (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator!= (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator!= (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator< (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator< (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator>= (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator>= (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator> (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator> (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator<= (const shared_ptr< _Ty > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty >
bool	operator<= (nullptr_t, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Out, const shared_ptr< _Ty > &_Px)
template<class _Ty >
void	swap (shared_ptr< _Ty > &_Left, shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
shared_ptr< _Ty1 >	static_pointer_cast (const shared_ptr< _Ty2 > &_Other) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
shared_ptr< _Ty1 >	const_pointer_cast (const shared_ptr< _Ty2 > &_Other) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
shared_ptr< _Ty1 >	dynamic_pointer_cast (const shared_ptr< _Ty2 > &_Other) _NOEXCEPT
template<class _Dx , class _Ty >
_Dx *	get_deleter (const shared_ptr< _Ty > &_Sx) _NOEXCEPT
template<class _Ty , class... _Types>
shared_ptr< _Ty >	make_shared (_Types &&..._Args)
template<class _Ty , class _Alloc , class... _Types>
shared_ptr< _Ty >	allocate_shared (const _Alloc &_Al_arg, _Types &&..._Args)
template<class _Ty >
void	swap (weak_ptr< _Ty > &_W1, weak_ptr< _Ty > &_W2) _NOEXCEPT
template<class _Ty , class... _Types>
enable_if<!is_array< _Ty >::value, unique_ptr< _Ty > >::type	make_unique (_Types &&..._Args)
template<class _Ty >
enable_if< is_array< _Ty >::value &&extent< _Ty >::value==0, unique_ptr< _Ty > >::type	make_unique (size_t _Size)
template<class _Ty , class... _Types>
enable_if< extent< _Ty >::value!=0, void >::type	make_unique (_Types &&...)=delete
template<class _Ty , class _Dx , class = enable_if_t<_Is_swappable<_Dx>::value>>
void	swap (unique_ptr< _Ty, _Dx > &_Left, unique_ptr< _Ty, _Dx > &_Right) _NOEXCEPT
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator== (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator!= (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator< (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator>= (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator> (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >
bool	operator<= (const unique_ptr< _Ty1, _Dx1 > &_Left, const unique_ptr< _Ty2, _Dx2 > &_Right)
template<class _Ty , class _Dx >
bool	operator== (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t) _NOEXCEPT
template<class _Ty , class _Dx >
bool	operator== (nullptr_t, const unique_ptr< _Ty, _Dx > &_Right) _NOEXCEPT
template<class _Ty , class _Dx >
bool	operator!= (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t _Right) _NOEXCEPT
template<class _Ty , class _Dx >
bool	operator!= (nullptr_t _Left, const unique_ptr< _Ty, _Dx > &_Right) _NOEXCEPT
template<class _Ty , class _Dx >
bool	operator< (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t _Right)
template<class _Ty , class _Dx >
bool	operator< (nullptr_t _Left, const unique_ptr< _Ty, _Dx > &_Right)
template<class _Ty , class _Dx >
bool	operator>= (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t _Right)
template<class _Ty , class _Dx >
bool	operator>= (nullptr_t _Left, const unique_ptr< _Ty, _Dx > &_Right)
template<class _Ty , class _Dx >
bool	operator> (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t _Right)
template<class _Ty , class _Dx >
bool	operator> (nullptr_t _Left, const unique_ptr< _Ty, _Dx > &_Right)
template<class _Ty , class _Dx >
bool	operator<= (const unique_ptr< _Ty, _Dx > &_Left, nullptr_t _Right)
template<class _Ty , class _Dx >
bool	operator<= (nullptr_t _Left, const unique_ptr< _Ty, _Dx > &_Right)
void	declare_reachable (void *)
template<class _Ty >
_Ty *	undeclare_reachable (_Ty *_Ptr)
void	declare_no_pointers (char *, size_t)
void	undeclare_no_pointers (char *, size_t)
_Pointer_safety	get_pointer_safety () _NOEXCEPT
void *	align (size_t _Bound, size_t _Size, void *&_Ptr, size_t &_Space) _NOEXCEPT
_EXTERN_C _CRTIMP2_PURE void __cdecl	_Lock_shared_ptr_spin_lock ()
_CRTIMP2_PURE void __cdecl	_Unlock_shared_ptr_spin_lock ()
template<class _Ty >
bool	atomic_is_lock_free (const shared_ptr< _Ty > *)
template<class _Ty >
shared_ptr< _Ty >	atomic_load_explicit (const shared_ptr< _Ty > *_Ptr, memory_order)
template<class _Ty >
shared_ptr< _Ty >	atomic_load (const shared_ptr< _Ty > *_Ptr)
template<class _Ty >
void	atomic_store_explicit (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > _Other, memory_order)
template<class _Ty >
void	atomic_store (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > _Other)
template<class _Ty >
shared_ptr< _Ty >	atomic_exchange_explicit (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > _Other, memory_order)
template<class _Ty >
shared_ptr< _Ty >	atomic_exchange (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > _Other)
template<class _Ty >
bool	atomic_compare_exchange_weak_explicit (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > *_Exp, shared_ptr< _Ty > _Value, memory_order, memory_order)
template<class _Ty >
bool	atomic_compare_exchange_weak (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > *_Exp, shared_ptr< _Ty > _Value)
template<class _Ty >
bool	atomic_compare_exchange_strong_explicit (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > *_Exp, shared_ptr< _Ty > _Value, memory_order, memory_order)
template<class _Ty >
bool	atomic_compare_exchange_strong (shared_ptr< _Ty > *_Ptr, shared_ptr< _Ty > *_Exp, shared_ptr< _Ty > _Value)

Macro Definition Documentation

#define _MEMORY_

Typedef Documentation

typedef pointer_safety _Pointer_safety

Enumeration Type Documentation

enum pointer_safety

strong

Enumerator
relaxed
preferred
strict

                          { // return codes for get_pointer_safety
    relaxed,
    preferred,
    strict
    };

Function Documentation

template<class _Ty1 , class _Ty2 >

void _Do_enable ( _Ty1 *  _Ptr, enable_shared_from_this< _Ty2 > *  _Es, _Ref_count_base *  _Refptr  )

inline

    {   // reset internal weak pointer
    _Es->_Wptr._Resetw(_Ptr, _Refptr);
    }

template<class _Ty >

void _Enable_shared ( _Ty *  _Ptr, _Ref_count_base *  _Refptr, typename _Ty::_EStype *  = 0  )

inline

    {   // reset internal weak pointer
    if (_Ptr)
        _Do_enable(_Ptr,
            (enable_shared_from_this<typename _Ty::_EStype>*)_Ptr, _Refptr);
    }

void _Enable_shared ( const volatile void *  , const volatile void *    )

inline

    {   // not derived from enable_shared_from_this; do nothing
    }

_EXTERN_C _CRTIMP2_PURE void __cdecl _Lock_shared_ptr_spin_lock

(

)

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n_unchecked ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), choose optimization
    return (_Uninitialized_copy_n_unchecked1(_First, _Count,
        _Dest, _Ptr_copy_cat(_First, _Dest)));
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n_unchecked1 ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, _General_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), no special optimization
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, (void)++_Dest, ++_First)
        {
        _Construct_in_place(*_Dest, *_First);
        }

    _CATCH_ALL
    _Destroy_range(_Next, _Dest);
    _RERAISE;
    _CATCH_END

    return (_Dest);
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt _Uninitialized_copy_n_unchecked1 ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest, _Really_trivial_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), memmove optimization
    if (0 < _Count)
        {
        return (_Copy_memmove(_First, _First + _Count, _Dest));
        }

    return (_Dest);
    }

template<class _InIt , class _FwdIt >

_STD_BEGIN _FwdIt _Uninitialized_copy_unchecked ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _General_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...), no special optimization
    _FwdIt _Next = _Dest;

    _TRY_BEGIN
    for (; _First != _Last; ++_Dest, (void)++_First)
        {
        _Construct_in_place(*_Dest, *_First);
        }

    _CATCH_ALL
    _Destroy_range(_Next, _Dest);
    _RERAISE;
    _CATCH_END

    return (_Dest);
    }

template<class _InIt , class _FwdIt >

_FwdIt _Uninitialized_copy_unchecked ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Really_trivial_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...), memmove optimization
    return (_Copy_memmove(_First, _Last, _Dest));
    }

template<class _FwdIt , class _Diff , class _Tval >

_FwdIt _Uninitialized_fill_n_unchecked ( _FwdIt  _First, _Diff  _Count, const _Tval &  _Val, false_type    )

inline

    {   // copy _Count copies of _Val to raw _First, no special optimization
    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; 0 < _Count; --_Count, (void)++_First)
        {
        _Construct_in_place(*_First, _Val);
        }

    _CATCH_ALL
    _Destroy_range(_Next, _First);
    _RERAISE;
    _CATCH_END

    return (_First);
    }

template<class _FwdIt , class _Diff , class _Tval >

_FwdIt _Uninitialized_fill_n_unchecked ( _FwdIt  _First, _Diff  _Count, const _Tval &  _Val, true_type    )

inline

    {   // copy _Count copies of _Val to raw _First, memset optimization
    if (0 < _Count)
        {
        _CSTD memset(_First, _Val, _Count);
        return (_First + _Count);
        }

    return (_First);
    }

template<class _FwdIt , class _Tval >

void _Uninitialized_fill_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Tval &  _Val, false_type    )

inline

    {   // copy _Val throughout raw [_First, _Last), no special optimization
    _FwdIt _Next = _First;

    _TRY_BEGIN
    for (; _First != _Last; ++_First)
        {
        _Construct_in_place(*_First, _Val);
        }

    _CATCH_ALL
    _Destroy_range(_Next, _First);
    _RERAISE;
    _CATCH_END
    }

template<class _FwdIt , class _Tval >

void _Uninitialized_fill_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Tval &  _Val, true_type    )

inline

    {   // copy _Val throughout raw [_First, _Last), memset optimization
    _CSTD memset(_First, _Val, _Last - _First);
    }

_CRTIMP2_PURE void __cdecl _Unlock_shared_ptr_spin_lock

(

)

void* align ( size_t  _Bound, size_t  _Size, void *&  _Ptr, size_t &  _Space  )

inline

    {   // try to carve out _Size bytes on boundary _Bound
    size_t _Off = (size_t)((uintptr_t)_Ptr & (_Bound - 1));
    if (0 < _Off)
        _Off = _Bound - _Off;   // number of bytes to skip
    if (_Space < _Off || _Space - _Off < _Size)
        return (0);
    else
        {   // enough room, update
        _Ptr = (char *)_Ptr + _Off;
        _Space -= _Off;
        return (_Ptr);
        }
    }

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

shared_ptr<_Ty> allocate_shared ( const _Alloc &  _Al_arg, _Types &&...  _Args  )

inline

    {   // make a shared_ptr
    typedef _Ref_count_obj_alloc<_Ty, _Alloc> _Refoa;
    typedef _Wrap_alloc<_Alloc> _Alref0;
    typename _Alref0::template rebind<_Refoa>::other _Alref(_Al_arg);

    const auto _Rx = _Alref.allocate(1);

    _TRY_BEGIN
        _Alref.construct(_Unfancy(_Rx), _Al_arg, _STD forward<_Types>(_Args)...);
    _CATCH_ALL
        _Alref.deallocate(_Rx, 1);
    _RERAISE;
    _CATCH_END

    shared_ptr<_Ty> _Ret;
    _Ret._Resetp0(_Rx->_Getptr(), _Unfancy(_Rx));
    return (_Ret);
    }

template<class _Ty >

bool atomic_compare_exchange_strong ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty > *  _Exp, shared_ptr< _Ty >  _Value  )

inline

    {   // atomically compare and exchange
    return (_STD atomic_compare_exchange_strong_explicit(_Ptr, _Exp, _STD move(_Value),
        memory_order_seq_cst, memory_order_seq_cst));
    }

template<class _Ty >

bool atomic_compare_exchange_strong_explicit ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty > *  _Exp, shared_ptr< _Ty >  _Value, memory_order  , memory_order    )

inline

    {   // atomically compare and exchange
    return (_STD atomic_compare_exchange_weak_explicit(_Ptr, _Exp, _STD move(_Value),
        memory_order_seq_cst, memory_order_seq_cst));
    }

template<class _Ty >

bool atomic_compare_exchange_weak ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty > *  _Exp, shared_ptr< _Ty >  _Value  )

inline

    {   // atomically compare and exchange
    return (_STD atomic_compare_exchange_weak_explicit(_Ptr, _Exp, _STD move(_Value),
        memory_order_seq_cst, memory_order_seq_cst));
    }

template<class _Ty >

bool atomic_compare_exchange_weak_explicit ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty > *  _Exp, shared_ptr< _Ty >  _Value, memory_order  , memory_order    )

inline

    {   // atomically compare and exchange
    shared_ptr<_Ty> _Old_exp;   // destroyed outside spin lock
    _Shared_ptr_spin_lock _Lock;
    bool _Success = _Ptr->get() == _Exp->get()
        && !_Ptr->owner_before(*_Exp)
        && !_Exp->owner_before(*_Ptr);
    if (_Success)
        _Ptr->swap(_Value);
    else
        {   // match failed
        _Exp->swap(_Old_exp);
        *_Exp = *_Ptr;
        }
    return (_Success);
    }

template<class _Ty >

shared_ptr<_Ty> atomic_exchange ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty >  _Other  )

inline

    {   // copy _Other to *_Ptr and return previous value of *_Ptr atomically
    return (_STD atomic_exchange_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst));
    }

template<class _Ty >

shared_ptr<_Ty> atomic_exchange_explicit ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty >  _Other, memory_order    )

inline

    {   // copy _Other to *_Ptr and return previous value of *_Ptr atomically
    _Shared_ptr_spin_lock _Lock;
    _Ptr->swap(_Other);
    return (_Other);
    }

template<class _Ty >

bool atomic_is_lock_free ( const shared_ptr< _Ty > *  )

inline

    {   // return true if atomic operations on shared_ptr<_Ty> are lock-free
    return (false);
    }

template<class _Ty >

shared_ptr<_Ty> atomic_load ( const shared_ptr< _Ty > *  _Ptr )

inline

    {   // load *_Ptr atomically
    return (_STD atomic_load_explicit(_Ptr, memory_order_seq_cst));
    }

template<class _Ty >

shared_ptr<_Ty> atomic_load_explicit ( const shared_ptr< _Ty > *  _Ptr, memory_order    )

inline

    {   // load *_Ptr atomically
    _Shared_ptr_spin_lock _Lock;
    shared_ptr<_Ty> _Result = *_Ptr;
    return (_Result);
    }

template<class _Ty >

void atomic_store ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty >  _Other  )

inline

    {   // store _Other to *_Ptr atomically
    _STD atomic_store_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst);
    }

template<class _Ty >

void atomic_store_explicit ( shared_ptr< _Ty > *  _Ptr, shared_ptr< _Ty >  _Other, memory_order    )

inline

    {   // store _Other to *_Ptr atomically
    _Shared_ptr_spin_lock _Lock;
    _Ptr->swap(_Other);
    }

template<class _Ty1 , class _Ty2 >

shared_ptr<_Ty1> const_pointer_cast

(

const shared_ptr< _Ty2 > &

_Other

)

    {   // return shared_ptr object holding const_cast<_Ty1 *>(_Other.get())
    typedef typename shared_ptr<_Ty1>::element_type _Elem1;
    _Elem1 *_Ptr = const_cast<_Elem1 *>(_Other.get());
    return (shared_ptr<_Ty1>(_Other, _Ptr));
    }

void declare_no_pointers ( char *  , size_t    )

inline

    {   // declare region to be pointer free
    }

void declare_reachable ( void *  )

inline

    {   // increment pointer reachable count
    }

template<class _Ty1 , class _Ty2 >

shared_ptr<_Ty1> dynamic_pointer_cast

(

const shared_ptr< _Ty2 > &

_Other

)

    {   // return shared_ptr object holding dynamic_cast<_Ty1 *>(_Other.get())
    typedef typename shared_ptr<_Ty1>::element_type _Elem1;
    _Elem1 *_Ptr = dynamic_cast<_Elem1 *>(_Other.get());
    if (_Ptr)
        return (shared_ptr<_Ty1>(_Other, _Ptr));
    else
        return (shared_ptr<_Ty1>());
    }

template<class _Dx , class _Ty >

_Dx* get_deleter

(

const shared_ptr< _Ty > &

_Sx

)

    {   // return pointer to shared_ptr's deleter object if its type is _Ty
    return ((_Dx *)_Sx._Get_deleter(typeid(_Dx)));
    }

_Pointer_safety get_pointer_safety ( )

inline

    {   // get pointer safety status
    return (pointer_safety::relaxed);
    }

template<class _Ty , class... _Types>

shared_ptr<_Ty> make_shared ( _Types &&...  _Args )

inline

    {   // make a shared_ptr
    _Ref_count_obj<_Ty> *_Rx =
        new _Ref_count_obj<_Ty>(_STD forward<_Types>(_Args)...);

    shared_ptr<_Ty> _Ret;
    _Ret._Resetp0(_Rx->_Getptr(), _Rx);
    return (_Ret);
    }

template<class _Ty , class... _Types>

enable_if<!is_array<_Ty>::value, unique_ptr<_Ty> >::type make_unique ( _Types &&...  _Args )

inline

    {   // make a unique_ptr
    return (unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...)));
    }

template<class _Ty >

enable_if<is_array<_Ty>::value && extent<_Ty>::value == 0, unique_ptr<_Ty> >::type make_unique ( size_t  _Size )

inline

    {   // make a unique_ptr
    typedef typename remove_extent<_Ty>::type _Elem;
    return (unique_ptr<_Ty>(new _Elem[_Size]()));
    }

template<class _Ty , class... _Types>

enable_if<extent<_Ty>::value != 0, void>::type make_unique ( _Types &&  ... )

delete

template<class _Ty1 , class _Ty2 >

bool operator!=	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // test if shared_ptr != shared_ptr
    return (!(_Left == _Right));
    }

template<class _Ty >

bool operator!=	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr != nullptr
    return (!(_Left == nullptr_t{}));
    }

template<class _Ty >

bool operator!=	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr != shared_ptr
    return (!(nullptr_t{} == _Right));
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator!=	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Left doesn't equal _Right
    return (!(_Left == _Right));
    }

template<class _Ty , class _Dx >

bool operator!=	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t	_Right
	)

    {   // test if unique_ptr != nullptr
    return (!(_Left == _Right));
    }

template<class _Ty , class _Dx >

bool operator!=	(	nullptr_t	_Left,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr != unique_ptr
    return (!(_Left == _Right));
    }

template<class _Ty1 , class _Ty2 >

bool operator<	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // test if shared_ptr < shared_ptr
    return (less<decltype(_Always_false<_Ty1>::value
        ? _Left.get() : _Right.get())>()(
            _Left.get(), _Right.get()));
    }

template<class _Ty >

bool operator<	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr < nullptr
    return (less<_Ty *>()(_Left.get(), nullptr_t{}));
    }

template<class _Ty >

bool operator<	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr < shared_ptr
    return (less<_Ty *>()(nullptr_t{}, _Right.get()));
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator<	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Left precedes _Right
    typedef typename unique_ptr<_Ty1, _Dx1>::pointer _Ptr1;
    typedef typename unique_ptr<_Ty2, _Dx2>::pointer _Ptr2;
    typedef typename common_type<_Ptr1, _Ptr2>::type _Common;
    return (less<_Common>()(_Left.get(), _Right.get()));

    }

template<class _Ty , class _Dx >

bool operator<	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t	_Right
	)

    {   // test if unique_ptr < nullptr
    typedef typename unique_ptr<_Ty, _Dx>::pointer _Ptr;
    return (less<_Ptr>()(_Left.get(), _Right));
    }

template<class _Ty , class _Dx >

bool operator<	(	nullptr_t	_Left,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr < unique_ptr
    typedef typename unique_ptr<_Ty, _Dx>::pointer _Ptr;
    return (less<_Ptr>()(_Left, _Right.get()));
    }

template<class _Elem , class _Traits , class _Ty >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Out,
		const shared_ptr< _Ty > &	_Px
	)

    {   // write contained pointer to stream
    return (_Out << _Px.get());
    }

template<class _Ty1 , class _Ty2 >

bool operator<=	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // test if shared_ptr <= shared_ptr
    return (!(_Right < _Left));
    }

template<class _Ty >

bool operator<=	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr <= nullptr
    return (!(nullptr_t{} < _Left));
    }

template<class _Ty >

bool operator<=	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr <= shared_ptr
    return (!(_Right < nullptr_t{}));
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator<=	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Right doesn't precede _Left
    return (!(_Right < _Left));
    }

template<class _Ty , class _Dx >

bool operator<=	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t	_Right
	)

    {   // test if unique_ptr <= nullptr
    return (!(_Right < _Left));
    }

template<class _Ty , class _Dx >

bool operator<=	(	nullptr_t	_Left,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr <= unique_ptr
    return (!(_Right < _Left));
    }

template<class _Ty1 , class _Ty2 >

bool operator==	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // test if shared_ptr == shared_ptr
    return (_Left.get() == _Right.get());
    }

template<class _Ty >

bool operator==	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr == nullptr
    return (_Left.get() == nullptr_t{});
    }

template<class _Ty >

bool operator==	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr == shared_ptr
    return (nullptr_t{} == _Right.get());
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator==	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Left equals _Right
    return (_Left.get() == _Right.get());
    }

template<class _Ty , class _Dx >

bool operator==	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t
	)

    {   // test if unique_ptr == nullptr
    return (!_Left);
    }

template<class _Ty , class _Dx >

bool operator==	(	nullptr_t	,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr == unique_ptr
    return (!_Right);
    }

template<class _Ty1 , class _Ty2 >

bool operator>	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // test if shared_ptr > shared_ptr
    return (_Right < _Left);
    }

template<class _Ty >

bool operator>	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr > nullptr
    return (nullptr_t{} < _Left);
    }

template<class _Ty >

bool operator>	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr > shared_ptr
    return (_Right < nullptr_t{});
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator>	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Right precedes _Left
    return (_Right < _Left);
    }

template<class _Ty , class _Dx >

bool operator>	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t	_Right
	)

    {   // test if unique_ptr > nullptr
    return (_Right < _Left);
    }

template<class _Ty , class _Dx >

bool operator>	(	nullptr_t	_Left,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr > unique_ptr
    return (_Right < _Left);
    }

template<class _Ty1 , class _Ty2 >

bool operator>=	(	const shared_ptr< _Ty1 > &	_Left,
		const shared_ptr< _Ty2 > &	_Right
	)

    {   // shared_ptr >= shared_ptr
    return (!(_Left < _Right));
    }

template<class _Ty >

bool operator>=	(	const shared_ptr< _Ty > &	_Left,
		nullptr_t
	)

    {   // test if shared_ptr >= nullptr
    return (!(_Left < nullptr_t{}));
    }

template<class _Ty >

bool operator>=	(	nullptr_t	,
		const shared_ptr< _Ty > &	_Right
	)

    {   // test if nullptr >= shared_ptr
    return (!(nullptr_t{} < _Right));
    }

template<class _Ty1 , class _Dx1 , class _Ty2 , class _Dx2 >

bool operator>=	(	const unique_ptr< _Ty1, _Dx1 > &	_Left,
		const unique_ptr< _Ty2, _Dx2 > &	_Right
	)

    {   // test if unique_ptr _Left doesn't precede _Right
    return (!(_Left < _Right));
    }

template<class _Ty , class _Dx >

bool operator>=	(	const unique_ptr< _Ty, _Dx > &	_Left,
		nullptr_t	_Right
	)

    {   // test if unique_ptr >= nullptr
    return (!(_Left < _Right));
    }

template<class _Ty , class _Dx >

bool operator>=	(	nullptr_t	_Left,
		const unique_ptr< _Ty, _Dx > &	_Right
	)

    {   // test if nullptr >= unique_ptr
    return (!(_Left < _Right));
    }

template<class _Ty1 , class _Ty2 >

shared_ptr<_Ty1> static_pointer_cast

(

const shared_ptr< _Ty2 > &

_Other

)

    {   // return shared_ptr object holding static_cast<_Ty1 *>(_Other.get())
    typedef typename shared_ptr<_Ty1>::element_type _Elem1;
    _Elem1 *_Ptr = static_cast<_Elem1 *>(_Other.get());
    return (shared_ptr<_Ty1>(_Other, _Ptr));
    }

template<class _Ty >

void swap	(	shared_ptr< _Ty > &	_Left,
		shared_ptr< _Ty > &	_Right
	)

    {   // swap _Left and _Right shared_ptrs
    _Left.swap(_Right);
    }

template<class _Ty >

void swap	(	weak_ptr< _Ty > &	_W1,
		weak_ptr< _Ty > &	_W2
	)

    {   // swap contents of _W1 and _W2
    _W1.swap(_W2);
    }

template<class _Ty , class _Dx , class = enable_if_t<_Is_swappable<_Dx>::value>>

void swap	(	unique_ptr< _Ty, _Dx > &	_Left,
		unique_ptr< _Ty, _Dx > &	_Right
	)

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

void undeclare_no_pointers ( char *  , size_t    )

inline

    {   // undeclare region to be pointer free
    }

template<class _Ty >

_Ty* undeclare_reachable ( _Ty *  _Ptr )

inline

    {   // decrement pointer reachable count
    return (_Ptr);
    }

template<class _InIt , class _FwdIt >

_FwdIt uninitialized_copy ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest  )

inline

    {   // copy [_First, _Last) to raw [_Dest, ...)
    _DEPRECATE_UNCHECKED(uninitialized_copy, _Dest);
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    const auto _UDest = _Unchecked_n(_Dest, _Idl_distance(_UFirst, _ULast));
    return (_Rechecked(_Dest,
        _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest, _Ptr_copy_cat(_UFirst, _UDest))));
    }

template<class _InIt , class _Diff , class _FwdIt >

_FwdIt uninitialized_copy_n ( _InIt  _First, _Diff  _Count, _FwdIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...)
        // Note that we _DEPRECATE_UNCHECKED _Dest because _Count logically goes with _First
    _DEPRECATE_UNCHECKED(uninitialized_copy_n, _Dest);
    return (_Rechecked(_Dest,
        _Uninitialized_copy_n_unchecked(_Unchecked_n(_First, _Count), _Count, _Unchecked_n(_Dest, _Count))));
    }

template<class _FwdIt , class _Tval >

void uninitialized_fill ( _FwdIt  _First, _FwdIt  _Last, const _Tval &  _Val  )

inline

    {   // copy _Val throughout raw [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    _Uninitialized_fill_unchecked(_UFirst, _ULast, _Val, _Fill_memset_is_safe(_UFirst, _Val));
    }

template<class _FwdIt , class _Diff , class _Tval >

_FwdIt uninitialized_fill_n ( _FwdIt  _First, _Diff  _Count, const _Tval &  _Val  )

inline

    {   // copy _Count copies of _Val to raw _First
    const auto _UFirst = _Unchecked_n(_First, _Count);
    return (_Rechecked(_First,
        _Uninitialized_fill_n_unchecked(_UFirst, _Count, _Val, _Fill_memset_is_safe(_UFirst, _Val))));
    }