#include <cstdint>
#include <cstdlib>
#include <limits>
#include <new>
#include <xutility>
#include <xatomic0.h>
#include <xatomic.h>

Classes
struct	_Is_simple_alloc< _Alty >

struct	_Simple_types< _Value_type >

struct	_Get_first_parameter< _Ty >

struct	_Get_first_parameter< _Ty< _First, _Rest...> >

struct	_Replace_first_parameter< _Newfirst, _Ty >

struct	_Replace_first_parameter< _Newfirst, _Ty< _First, _Rest...> >

struct	_Get_element_type< _Ty, class >

struct	_Get_element_type< _Ty, void_t< typename _Ty::element_type > >

struct	_Get_ptr_difference_type< _Ty, class >

struct	_Get_ptr_difference_type< _Ty, void_t< typename _Ty::difference_type > >

struct	_Get_rebind_alias< _Ty, _Other, class >

struct	_Get_rebind_alias< _Ty, _Other, void_t< typename _Ty::template rebind< _Other > > >

struct	pointer_traits< _Ty >

struct	pointer_traits< _Ty * >

struct	_Get_pointer_type< _Ty, class >

struct	_Get_pointer_type< _Ty, void_t< typename _Ty::pointer > >

struct	_Get_const_pointer_type< _Ty, class >

struct	_Get_const_pointer_type< _Ty, void_t< typename _Ty::const_pointer > >

struct	_Get_void_pointer_type< _Ty, class >

struct	_Get_void_pointer_type< _Ty, void_t< typename _Ty::void_pointer > >

struct	_Get_const_void_pointer_type< _Ty, class >

struct	_Get_const_void_pointer_type< _Ty, void_t< typename _Ty::const_void_pointer > >

struct	_Get_difference_type< _Ty, class >

struct	_Get_difference_type< _Ty, void_t< typename _Ty::difference_type > >

struct	_Get_size_type< _Ty, class >

struct	_Get_size_type< _Ty, void_t< typename _Ty::size_type > >

struct	_Get_propagate_on_container_copy< _Ty, class >

struct	_Get_propagate_on_container_copy< _Ty, void_t< typename _Ty::propagate_on_container_copy_assignment > >

struct	_Get_propagate_on_container_move< _Ty, class >

struct	_Get_propagate_on_container_move< _Ty, void_t< typename _Ty::propagate_on_container_move_assignment > >

struct	_Get_propagate_on_container_swap< _Ty, class >

struct	_Get_propagate_on_container_swap< _Ty, void_t< typename _Ty::propagate_on_container_swap > >

struct	_Get_is_always_equal< _Ty, class >

struct	_Get_is_always_equal< _Ty, void_t< typename _Ty::is_always_equal > >

struct	_Get_rebind_type< _Ty, _Other, class >

struct	_Get_rebind_type< _Ty, _Other, void_t< typename _Ty::template rebind< _Other >::other > >

class	allocator< _Ty >

struct	_Wrap_alloc< _Alloc >

struct	_Unwrap_alloc< _Alloc >

struct	_Unwrap_alloc< _Wrap_alloc< _Alloc > >

struct	_Is_default_allocator< _Alloc, class >

struct	_Is_default_allocator< allocator< _Ty >, typename allocator< _Ty >::_Not_user_specialized >

struct	_Alloc_allocate

struct	_Has_no_alloc_construct_tag

struct	_Has_no_alloc_construct< _Void, _Types >

struct	_Has_no_alloc_construct< void_t< _Has_no_alloc_construct_tag, decltype(_STD declval< _Alloc & >().construct(_STD declval< _Ptr >(), _STD declval< _Args >()...))>, _Alloc, _Ptr, _Args...>

struct	_Has_no_alloc_destroy_tag

struct	_Has_no_alloc_destroy< _Alloc, _Ptr, class >

struct	_Has_no_alloc_destroy< _Alloc, _Ptr, void_t< _Has_no_alloc_destroy_tag, decltype(_STD declval< _Alloc & >().destroy(_STD declval< _Ptr >()))> >

struct	_Alloc_max_size

struct	_Alloc_select

struct	allocator_traits< _Alloc >

class	allocator< _Ty >

struct	allocator< _Ty >::rebind< _Other >

class	allocator< void >

struct	allocator< void >::rebind< _Other >

struct	allocator_traits< allocator< _Ty > >

struct	_Wrap_alloc< _Alloc >

struct	_Wrap_alloc< _Alloc >::rebind< _Other >

Macros
#define	_XMEMORY0_

#define	_DECLSPEC_ALLOCATOR __declspec(allocator)

#define	_BIG_ALLOCATION_THRESHOLD 4096

#define	_BIG_ALLOCATION_ALIGNMENT 32

#define	_NON_USER_SIZE (sizeof(void *) + _BIG_ALLOCATION_ALIGNMENT - 1)

#define	_MT_INCR(x) _Inc_atomic_counter_explicit(x, memory_order_relaxed)

#define	_MT_DECR(x) _Dec_atomic_counter_explicit(x, memory_order_acq_rel)

Typedefs
template<class _Alloc >
using	_Unwrap_alloc_t = typename _Unwrap_alloc< _Alloc >::type

template<class _Alloc , class _Ptr , class... _Args>
using	_Uses_default_construct = disjunction< _Is_default_allocator< _Alloc >, _Has_no_alloc_construct< void, _Alloc, _Ptr, _Args...>>

template<class _Alloc , class _Ptr , class... _Args>
using	_Uses_default_construct_t = typename _Uses_default_construct< _Alloc, _Ptr, _Args...>::type

template<class _Alloc , class _Ptr >
using	_Uses_default_destroy = disjunction< _Is_default_allocator< _Alloc >, _Has_no_alloc_destroy< _Alloc, _Ptr >>

template<class _Alloc , class _Ptr >
using	_Uses_default_destroy_t = typename _Uses_default_destroy< _Alloc, _Ptr >::type

Functions
_DECLSPEC_ALLOCATOR void *	_Allocate (size_t _Count, size_t _Sz, bool _Try_aligned_allocation=true)

void	_Deallocate (void *_Ptr, size_t _Count, size_t _Sz)

template<class _Ty , class... _Types>
void	_Construct_in_place (_Ty &_Obj, _Types &&..._Args)

template<class _Ty >
void	_Destroy_in_place (_Ty &_Obj) _NOEXCEPT

template<class _Ptrty >
auto	_Const_cast (_Ptrty _Ptr)

template<class _Ty >
auto	_Const_cast (_Ty *_Ptr)

template<class _Ty , class _Other >
bool	operator== (const allocator< _Ty > &, const allocator< _Other > &) _THROW0()

template<class _Ty , class _Other >
bool	operator!= (const allocator< _Ty > &, const allocator< _Other > &) _THROW0()

template<class _Ty , class _Other >
bool	operator== (const _Wrap_alloc< _Ty > &_Left, const _Wrap_alloc< _Other > &_Right) _THROW0()

template<class _Ty , class _Other >
bool	operator!= (const _Wrap_alloc< _Ty > &_Left, const _Wrap_alloc< _Other > &_Right) _THROW0()

template<class _Alty >
void	_Pocca (_Alty &_Left, const _Alty &_Right, true_type) _NOEXCEPT

template<class _Alty >
void	_Pocca (_Alty &, const _Alty &, false_type) _NOEXCEPT

template<class _Alty >
void	_Pocca (_Alty &_Left, const _Alty &_Right) _NOEXCEPT

template<class _Alty >
void	_Pocma (_Alty &_Left, _Alty &_Right, true_type) _NOEXCEPT

template<class _Alty >
void	_Pocma (_Alty &, _Alty &, false_type) _NOEXCEPT

template<class _Alty >
void	_Pocma (_Alty &_Left, _Alty &_Right) _NOEXCEPT

template<class _Alty >
void	_Pocs (_Alty &_Left, _Alty &_Right, true_type) _NOEXCEPT

template<class _Alty >
void	_Pocs (_Alty &_Left, _Alty &_Right, false_type) _NOEXCEPT

template<class _Alty >
void	_Pocs (_Alty &_Left, _Alty &_Right) _NOEXCEPT

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>
void	_Destroy_range1 (_Ptr _First, _Ptr _Last, _Wrap_alloc< _Alloc > &_Al, false_type)

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>
void	_Destroy_range1 (_Ptr, _Ptr, _Wrap_alloc< _Alloc > &, true_type)

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>
void	_Destroy_range (_Ptr _First, _Ptr _Last, _Wrap_alloc< _Alloc > &_Al)

template<class _FwdIt >
void	_Destroy_range1 (_FwdIt _First, _FwdIt _Last, false_type)

template<class _FwdIt >
void	_Destroy_range1 (_FwdIt, _FwdIt, true_type)

template<class _FwdIt >
void	_Destroy_range (_FwdIt _First, _FwdIt _Last)

Macro Definition Documentation

#define _BIG_ALLOCATION_ALIGNMENT 32

#define _BIG_ALLOCATION_THRESHOLD 4096

#define _DECLSPEC_ALLOCATOR __declspec(allocator)

#define _MT_DECR ( x ) _Dec_atomic_counter_explicit(x, memory_order_acq_rel)

#define _MT_INCR ( x ) _Inc_atomic_counter_explicit(x, memory_order_relaxed)

#define _NON_USER_SIZE (sizeof(void *) + _BIG_ALLOCATION_ALIGNMENT - 1)

#define _XMEMORY0_

Typedef Documentation

template<class _Alloc >

using _Unwrap_alloc_t = typename _Unwrap_alloc<_Alloc>::type

template<class _Alloc , class _Ptr , class... _Args>

using _Uses_default_construct = disjunction< _Is_default_allocator<_Alloc>, _Has_no_alloc_construct<void, _Alloc, _Ptr, _Args...>>

template<class _Alloc , class _Ptr , class... _Args>

using _Uses_default_construct_t = typename _Uses_default_construct<_Alloc, _Ptr, _Args...>::type

template<class _Alloc , class _Ptr >

using _Uses_default_destroy = disjunction< _Is_default_allocator<_Alloc>, _Has_no_alloc_destroy<_Alloc, _Ptr>>

template<class _Alloc , class _Ptr >

using _Uses_default_destroy_t = typename _Uses_default_destroy<_Alloc, _Ptr>::type

Function Documentation

_DECLSPEC_ALLOCATOR void* _Allocate	(	size_t	_Count,
		size_t	_Sz,
		bool	_Try_aligned_allocation = `true`
	)

inline

     {   // allocate storage for _Count elements of size _Sz
     void *_Ptr = 0;
 
     if (_Count == 0)
         return (_Ptr);
 
     // check overflow of multiply
     if ((size_t)(-1) / _Sz < _Count)
         _Xbad_alloc();  // report no memory
     const size_t _User_size = _Count * _Sz;
 
  #if defined(_M_IX86) || defined(_M_X64)
     if (_Try_aligned_allocation
         && _BIG_ALLOCATION_THRESHOLD <= _User_size)
         {   // allocate large block
         static_assert(sizeof (void *) < _BIG_ALLOCATION_ALIGNMENT,
             "Big allocations should at least match vector register size");
         const size_t _Block_size = _NON_USER_SIZE + _User_size;
         if (_Block_size <= _User_size)
             _Xbad_alloc();  // report no memory
         const uintptr_t _Ptr_container =
             reinterpret_cast<uintptr_t>(::operator new(_Block_size));
         _SCL_SECURE_ALWAYS_VALIDATE(_Ptr_container != 0);
         _Ptr = reinterpret_cast<void *>((_Ptr_container + _NON_USER_SIZE)
             & ~(_BIG_ALLOCATION_ALIGNMENT - 1));
         static_cast<uintptr_t *>(_Ptr)[-1] = _Ptr_container;
 
  #ifdef _DEBUG
         static_cast<uintptr_t *>(_Ptr)[-2] = _BIG_ALLOCATION_SENTINEL;
  #endif /* _DEBUG */
         }
     else
  #else /* defined(_M_IX86) || defined(_M_X64) */
     static_cast<void>(_Try_aligned_allocation);
  #endif /* defined(_M_IX86) || defined(_M_X64) */
 
         {   // allocate normal block
         _Ptr = ::operator new(_User_size);
         _SCL_SECURE_ALWAYS_VALIDATE(_Ptr != 0);
         }
     return (_Ptr);
     }

template<class _Ptrty >

auto _Const_cast ( _Ptrty _Ptr )

inline

     {   // remove constness from a fancy pointer
     using _Elem = typename pointer_traits<_Ptrty>::element_type;
     using _Modifiable = remove_const_t<_Elem>;
     using _Dest = typename pointer_traits<_Ptrty>::template rebind<_Modifiable>;
 
     return (pointer_traits<_Dest>::pointer_to(const_cast<_Modifiable&>(*_Ptr)));
     }

template<class _Ty >

auto _Const_cast ( _Ty * _Ptr )

inline

     {   // remove constness from a plain pointer
     return (const_cast<remove_const_t<_Ty> *>(_Ptr));
     }

template<class _Ty , class... _Types>

void _Construct_in_place	(	_Ty &	_Obj,
		_Types &&...	_Args
	)

inline

     {   // invoke True Placement New to initialize the referenced object with _Args...
     ::new (const_cast<void *>(static_cast<const volatile void *>(_STD addressof(_Obj))))
         _Ty(_STD forward<_Types>(_Args)...);
     }

void _Deallocate	(	void *	_Ptr,
		size_t	_Count,
		size_t	_Sz
	)

inline

     {   // deallocate storage for _Count elements of size _Sz
  #if defined(_M_IX86) || defined(_M_X64)
     _SCL_SECURE_ALWAYS_VALIDATE(_Count <= (size_t)(-1) / _Sz);
     const size_t _User_size = _Count * _Sz;
     if (_BIG_ALLOCATION_THRESHOLD <= _User_size)
         {   // deallocate large block
         const uintptr_t _Ptr_user = reinterpret_cast<uintptr_t>(_Ptr);
         _SCL_SECURE_ALWAYS_VALIDATE(
             (_Ptr_user & (_BIG_ALLOCATION_ALIGNMENT - 1)) == 0);
         const uintptr_t _Ptr_ptr = _Ptr_user - sizeof(void *);
         const uintptr_t _Ptr_container =
             *reinterpret_cast<uintptr_t *>(_Ptr_ptr);
 
  #ifdef _DEBUG
         // If the following asserts, it likely means that we are performing
         // an aligned delete on memory coming from an unaligned allocation.
         _SCL_SECURE_ALWAYS_VALIDATE(
             reinterpret_cast<uintptr_t *>(_Ptr_ptr)[-1] ==
                 _BIG_ALLOCATION_SENTINEL);
  #endif /* _DEBUG */
 
         // Extra paranoia on aligned allocation/deallocation
         _SCL_SECURE_ALWAYS_VALIDATE(_Ptr_container < _Ptr_user);
 
  #ifdef _DEBUG
         _SCL_SECURE_ALWAYS_VALIDATE(2 * sizeof(void *)
             <= _Ptr_user - _Ptr_container);
 
  #else /* _DEBUG */
         _SCL_SECURE_ALWAYS_VALIDATE(sizeof(void *)
             <= _Ptr_user - _Ptr_container);
  #endif /* _DEBUG */
 
         _SCL_SECURE_ALWAYS_VALIDATE(_Ptr_user - _Ptr_container
             <= _NON_USER_SIZE);
 
         _Ptr = reinterpret_cast<void *>(_Ptr_container);
         }
 
  #else /* defined(_M_IX86) || defined(_M_X64) */
     static_cast<void>(_Count);
     static_cast<void>(_Sz);
  #endif /* defined(_M_IX86) || defined(_M_X64) */
 
     ::operator delete(_Ptr);
     }

template<class _Ty >

void _Destroy_in_place ( _Ty & _Obj )

inline

     {   // destroy the referenced object
     _Obj.~_Ty();
     }

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>

void _Destroy_range	(	_Ptr	_First,
		_Ptr	_Last,
		_Wrap_alloc< _Alloc > &	_Al
	)

inline

     {   // destroy [_First, _Last), choose optimization
         // note that this is an optimization for debug mode codegen;
         // in release mode the BE removes all of this
     typedef typename _Alloc::value_type _Val;
     _Destroy_range1(_First, _Last, _Al, _Conjunction_t<
         is_trivially_destructible<_Val>,
         _Uses_default_destroy<_Alloc, _Val *>>());
     }

template<class _FwdIt >

void _Destroy_range	(	_FwdIt	_First,
		_FwdIt	_Last
	)

inline

     {   // destroy [_First, _Last), choose optimization
         // note that this is an optimization for debug mode codegen;
         // in release mode the BE removes all of this
     _Destroy_range1(_First, _Last, is_trivially_destructible<_Iter_value_t<_FwdIt>>());
     }

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>

void _Destroy_range1	(	_Ptr	_First,
		_Ptr	_Last,
		_Wrap_alloc< _Alloc > &	_Al,
		false_type
	)

inline

     {   // destroy [_First, _Last), no special optimization
     for (; _First != _Last; ++_First)
         _Al.destroy(_Unfancy(_First));
     }

template<class _Alloc , class _Ptr = typename _Wrap_alloc<_Alloc>::pointer>

void _Destroy_range1	(	_Ptr	,
		_Ptr	,
		_Wrap_alloc< _Alloc > &	,
		true_type
	)

inline

     {   // destroy [_First, _Last), trivially destructible and default destroy
         // nothing to do
     }

template<class _FwdIt >

void _Destroy_range1	(	_FwdIt	_First,
		_FwdIt	_Last,
		false_type
	)

inline

     {   // destroy [_First, _Last), no special optimization
     for (; _First != _Last; ++_First)
         _Destroy_in_place(*_First);
     }

template<class _FwdIt >

void _Destroy_range1	(	_FwdIt	,
		_FwdIt	,
		true_type
	)

inline

     {   // destroy [_First, _Last), trivially destructible
         // nothing to do
     }

template<class _Alty >

void _Pocca	(	_Alty &	_Left,
		const _Alty &	_Right,
		true_type
	)

inline

     {   // propagate on container copy assignment
     _Left = _Right;
     }

template<class _Alty >

void _Pocca	(	_Alty &	,
		const _Alty &	,
		false_type
	)

inline

1138 { // (don't) propagate on container copy assignment

1139 }

template<class _Alty >

void _Pocca	(	_Alty &	_Left,
		const _Alty &	_Right
	)

inline

     {   // (maybe) propagate on container copy assignment
     typename _Alty::propagate_on_container_copy_assignment _Tag;
     _Pocca(_Left, _Right, _Tag);
     }

template<class _Alty >

void _Pocma	(	_Alty &	_Left,
		_Alty &	_Right,
		true_type
	)

inline

     {   // propagate on container move assignment
     _Left = _STD move(_Right);
     }

template<class _Alty >

void _Pocma	(	_Alty &	,
		_Alty &	,
		false_type
	)

inline

1157 { // (don't) propagate on container move assignment

1158 }

template<class _Alty >

void _Pocma	(	_Alty &	_Left,
		_Alty &	_Right
	)

inline

     {   // (maybe) propagate on container move assignment
     typename _Alty::propagate_on_container_move_assignment _Tag;
     _Pocma(_Left, _Right, _Tag);
     }

template<class _Alty >

void _Pocs	(	_Alty &	_Left,
		_Alty &	_Right,
		true_type
	)

inline

     {   // propagate on container swap
     _Swap_adl(_Left, _Right);
     }

template<class _Alty >

void _Pocs	(	_Alty &	_Left,
		_Alty &	_Right,
		false_type
	)

inline

     {   // (don't) propagate on container swap
     if (_Left != _Right)
         {   // containers are incompatible
  #if _ITERATOR_DEBUG_LEVEL == 2
         _DEBUG_ERROR("containers incompatible for swap");
  #else /* ITERATOR_DEBUG_LEVEL == 2 */
         _STD terminate();
  #endif /* ITERATOR_DEBUG_LEVEL == 2 */
         }
     }

template<class _Alty >

void _Pocs	(	_Alty &	_Left,
		_Alty &	_Right
	)

inline

     {   // (maybe) propagate on container swap
     typename _Alty::propagate_on_container_swap _Tag;
     _Pocs(_Left, _Right, _Tag);
     }

template<class _Ty , class _Other >

bool operator!=	(	const allocator< _Ty > &	,
		const allocator< _Other > &
	)

inline

     {   // test for allocator inequality
     return (false);
     }

template<class _Ty , class _Other >

bool operator!=	(	const _Wrap_alloc< _Ty > &	_Left,
		const _Wrap_alloc< _Other > &	_Right
	)

inline

     {   // test for allocator inequality
     return (!(_Left == _Right));
     }

template<class _Ty , class _Other >

bool operator==	(	const allocator< _Ty > &	,
		const allocator< _Other > &
	)

inline

     {   // test for allocator equality
     return (true);
     }

template<class _Ty , class _Other >

bool operator==	(	const _Wrap_alloc< _Ty > &	_Left,
		const _Wrap_alloc< _Other > &	_Right
	)

inline

     {   // test for allocator equality
     return (static_cast<const _Ty&>(_Left)
         == static_cast<const _Other&>(_Right));
     }

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation