typedef unspecified pointer;

Allocator::pointer if such a type exists; otherwise, value_type*

typedef see_documentation const_pointer;

Allocator::const_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<const

typedef see_documentation reference;

Non-standard extension Allocator::reference if such a type exists; otherwise, value_type&

typedef see_documentation const_reference;

Non-standard extension Allocator::const_reference if such a type exists ; otherwise, const value_type&

typedef see_documentation void_pointer;

Allocator::void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<void>.

typedef see_documentation const_void_pointer;

Allocator::const_void_pointer if such a type exists ; otherwis e, pointer_traits<pointer>::rebind<const

typedef see_documentation difference_type;

Allocator::difference_type if such a type exists ; otherwise, pointer_traits<pointer>::difference_type.

typedef see_documentation size_type;

Allocator::size_type if such a type exists ; otherwise, make_unsigned<difference_type>::type

typedef see_documentation propagate_on_container_copy_assignment;

Allocator::propagate_on_container_copy_assignment if such a type exists, otherwise a type with an internal constant static boolean member value == false.

typedef see_documentation propagate_on_container_move_assignment;

Allocator::propagate_on_container_move_assignment if such a type exists, otherwise a type with an internal constant static boolean member value == false.

typedef see_documentation propagate_on_container_swap;

Allocator::propagate_on_container_swap if such a type exists, otherwise a type with an internal constant static boolean member value == false.

typedef see_documentation is_always_equal;

Allocator::is_always_equal if such a type exists, otherwise a type with an internal constant static boolean member value == is_empty<Allocator>::value

typedef see_documentation is_partially_propagable;

Allocator::is_partially_propagable if such a type exists, otherwise a type with an internal constant static boolean member value == false Note: Non-standard extension used to implement small_vector_allocator.

typedef see_documentation rebind_alloc;

Defines an allocator: Allocator::rebind<T>::other if such a type exists; otherwise, Allocator<T, Args> if Allocator is a class template instantiation of the form Allocator<U, Args>, where Args is zero or more type arguments ; otherwise, the instantiation of rebind_alloc is ill-formed.

In C++03 compilers rebind_alloc is a struct derived from an allocator deduced by previously detailed rules.

typedef allocator_traits< rebind_alloc< T > > rebind_traits;

In C++03 compilers rebind_traits is a struct derived from allocator_traits<OtherAlloc>, where OtherAlloc is the allocator deduced by rules explained in rebind_alloc.

static pointer allocate(Allocator & a, size_type n);

Returns: a.allocate(n)

static void deallocate(Allocator & a, pointer p, size_type n);

Returns: a.deallocate(p, n)

Throws: Nothing

static pointer allocate(Allocator & a, size_type n, const_void_pointer p);

Effects: calls a.allocate(n, p) if that call is well-formed; otherwise, invokes a.allocate(n)

template<typename T> static void destroy(Allocator & a, T * p) noexcept;

Effects: calls a.destroy(p) if that call is well-formed; otherwise, invokes p->~T().

static size_type max_size(const Allocator & a) noexcept;

Returns: a.max_size() if that expression is well-formed; otherwise, numeric_limits<size_type>::max().

static Allocator select_on_container_copy_construction(const Allocator & a);

Returns: a.select_on_container_copy_construction() if that expression is well-formed; otherwise, a.

template<typename T, class... Args> 
  static void construct(Allocator & a, T * p, Args &&... args);

Effects: calls a.construct(p, std::forward<Args>(args)...) if that call is well-formed; otherwise, invokes ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)

static bool storage_is_unpropagable(const Allocator & a, pointer p) noexcept;

Returns: a.storage_is_unpropagable(p) if is_partially_propagable::value is true; otherwise, false.

static bool equal(const Allocator & a, const Allocator & b) noexcept;

Returns: true if is_always_equal::value == true, otherwise, a == b.