memory File Reference

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

Classes
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[]>
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_
#define	_XSTD2

Typedefs
typedef pointer_safety	_Pointer_safety

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

Functions
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 _Right) _NOEXCEPT
template<class _Ty >
bool	operator!= (nullptr_t _Left, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator< (const shared_ptr< _Ty > &_Left, nullptr_t _Right) _NOEXCEPT
template<class _Ty >
bool	operator< (nullptr_t _Left, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator>= (const shared_ptr< _Ty > &_Left, nullptr_t _Right) _NOEXCEPT
template<class _Ty >
bool	operator>= (nullptr_t _Left, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator> (const shared_ptr< _Ty > &_Left, nullptr_t _Right) _NOEXCEPT
template<class _Ty >
bool	operator> (nullptr_t _Left, const shared_ptr< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
bool	operator<= (const shared_ptr< _Ty > &_Left, nullptr_t _Right) _NOEXCEPT
template<class _Ty >
bool	operator<= (nullptr_t _Left, 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 _Val , class _Ty >
struct _Get_deleter_pointer_type	_GET_TYPE_OR_DEFAULT (pointer, _Val *)
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
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_

#define _XSTD2

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
    }

template<class _Val , class _Ty >

struct _Get_deleter_pointer_type _GET_TYPE_OR_DEFAULT	(	pointer	,
		_Val *
	)

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);

    _Refoa *_Rx = _Alref.allocate(1);

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

    shared_ptr<_Ty> _Ret;
    _Ret._Resetp0(_Rx->_Getptr(), _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	_Right
	)

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

template<class _Ty >

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

    {   // test if nullptr != shared_ptr
    return (!(_Left == _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	_Right
	)

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

template<class _Ty >

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

    {   // test if nullptr < shared_ptr
    return (less<_Ty *>()((_Ty *)0, _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	_Right
	)

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

template<class _Ty >

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

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

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() == (_Ty *)0);
    }

template<class _Ty >

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

    {   // test if nullptr == shared_ptr
    return ((_Ty *)0 == _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	_Right
	)

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

template<class _Ty >

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

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

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	_Right
	)

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

template<class _Ty >

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

    {   // test if nullptr >= shared_ptr
    return (!(_Left < _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);
    }