forked from OSchip/llvm-project
Howard Hinnant
parent
361b9be7c6
commit
20cc2a42b8
|
|
@ -181,6 +181,332 @@ public:
|
|||
template<class Y> operator auto_ptr<Y>() throw();
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct default_delete
|
||||
{
|
||||
constexpr default_delete();
|
||||
template <class U> default_delete(const default_delete<U>&);
|
||||
|
||||
void operator()(T*) const;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct default_delete<T[]>
|
||||
{
|
||||
constexpr default_delete();
|
||||
void operator()(T*) const;
|
||||
template <class U> void operator()(U*) const = delete;
|
||||
};
|
||||
|
||||
template <class T, class D = default_delete<T>> class unique_ptr;
|
||||
|
||||
template <class T, class D = default_delete<T>>
|
||||
class unique_ptr
|
||||
{
|
||||
public:
|
||||
typedef see below pointer;
|
||||
typedef T element_type;
|
||||
typedef D deleter_type;
|
||||
|
||||
// constructors
|
||||
constexpr unique_ptr();
|
||||
explicit unique_ptr(pointer p);
|
||||
unique_ptr(pointer p, implementation-defined d1);
|
||||
unique_ptr(pointer p, implementation-defined d2);
|
||||
unique_ptr(unique_ptr&& u);
|
||||
unique_ptr(nullptr_t) : unique_ptr() { }
|
||||
template <class U, class E>
|
||||
unique_ptr(unique_ptr<U, E>&& u);
|
||||
template <class U>
|
||||
explicit unique_ptr(auto_ptr<U>& u);
|
||||
template <class U>
|
||||
unique_ptr(auto_ptr<U>&& u);
|
||||
|
||||
// destructor
|
||||
~unique_ptr();
|
||||
|
||||
// assignment
|
||||
unique_ptr& operator=(unique_ptr&& u);
|
||||
template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);
|
||||
unique_ptr& operator=(nullptr_t);
|
||||
|
||||
// observers
|
||||
typename add_lvalue_reference<T>::type operator*() const;
|
||||
pointer operator->() const;
|
||||
pointer get() const;
|
||||
deleter_type& get_deleter();
|
||||
const deleter_type& get_deleter() const;
|
||||
explicit operator bool() const;
|
||||
|
||||
// modifiers
|
||||
pointer release();
|
||||
void reset(pointer p = pointer());
|
||||
void swap(unique_ptr& u);
|
||||
};
|
||||
|
||||
template <class T, class D>
|
||||
class unique_ptr<T[], D>
|
||||
{
|
||||
public:
|
||||
typedef implementation-defined pointer;
|
||||
typedef T element_type;
|
||||
typedef D deleter_type;
|
||||
|
||||
// constructors
|
||||
constexpr unique_ptr();
|
||||
explicit unique_ptr(pointer p);
|
||||
unique_ptr(pointer p, implementation-defined d);
|
||||
unique_ptr(pointer p, implementation-defined d);
|
||||
unique_ptr(unique_ptr&& u);
|
||||
unique_ptr(nullptr_t) : unique_ptr() { }
|
||||
|
||||
// destructor
|
||||
∼unique_ptr();
|
||||
|
||||
// assignment
|
||||
unique_ptr& operator=(unique_ptr&& u);
|
||||
unique_ptr& operator=(nullptr_t);
|
||||
|
||||
// observers
|
||||
T& operator[](size_t i) const;
|
||||
pointer get() const;
|
||||
deleter_type& get_deleter();
|
||||
const deleter_type& get_deleter() const;
|
||||
explicit operator bool() const;
|
||||
|
||||
// modifiers
|
||||
pointer release();
|
||||
void reset(pointer p = pointer());
|
||||
void reset(nullptr_t);
|
||||
template <class U> void reset(U) = delete;
|
||||
void swap(unique_ptr& u);
|
||||
};
|
||||
|
||||
template <class T, class D>
|
||||
void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);
|
||||
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
template <class T1, class D1, class T2, class D2>
|
||||
bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
|
||||
|
||||
class bad_weak_ptr
|
||||
: public std::exception
|
||||
{
|
||||
bad_weak_ptr();
|
||||
};
|
||||
|
||||
template<class T>
|
||||
class shared_ptr
|
||||
{
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
// constructors:
|
||||
constexpr shared_ptr();
|
||||
template<class Y> explicit shared_ptr(Y* p);
|
||||
template<class Y, class D> shared_ptr(Y* p, D d);
|
||||
template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
|
||||
template <class D> shared_ptr(nullptr_t p, D d);
|
||||
template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
|
||||
template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p);
|
||||
shared_ptr(const shared_ptr& r);
|
||||
template<class Y> shared_ptr(const shared_ptr<Y>& r);
|
||||
shared_ptr(shared_ptr&& r);
|
||||
template<class Y> shared_ptr(shared_ptr<Y>&& r);
|
||||
template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
|
||||
template<class Y> shared_ptr(auto_ptr<Y>&& r);
|
||||
template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
|
||||
shared_ptr(nullptr_t) : shared_ptr() { }
|
||||
|
||||
// destructor:
|
||||
~shared_ptr();
|
||||
|
||||
// assignment:
|
||||
shared_ptr& operator=(const shared_ptr& r);
|
||||
template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r);
|
||||
shared_ptr& operator=(shared_ptr&& r);
|
||||
template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
|
||||
template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r);
|
||||
template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
|
||||
|
||||
// modifiers:
|
||||
void swap(shared_ptr& r);
|
||||
void reset();
|
||||
template<class Y> void reset(Y* p);
|
||||
template<class Y, class D> void reset(Y* p, D d);
|
||||
template<class Y, class D, class A> void reset(Y* p, D d, A a);
|
||||
|
||||
// observers: T* get() const;
|
||||
T& operator*() const;
|
||||
T* operator->() const;
|
||||
long use_count() const;
|
||||
bool unique() const;
|
||||
explicit operator bool() const;
|
||||
template<class U> bool owner_before(shared_ptr<U> const& b) const;
|
||||
template<class U> bool owner_before(weak_ptr<U> const& b) const;
|
||||
};
|
||||
|
||||
// shared_ptr comparisons:
|
||||
template<class T, class U>
|
||||
bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
template<class T, class U>
|
||||
bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
template<class T, class U>
|
||||
bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
template<class T, class U>
|
||||
bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
template<class T, class U>
|
||||
bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
template<class T, class U>
|
||||
bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b);
|
||||
|
||||
// shared_ptr specialized algorithms:
|
||||
template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b);
|
||||
|
||||
// shared_ptr casts:
|
||||
template<class T, class U>
|
||||
shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r);
|
||||
template<class T, class U>
|
||||
shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r);
|
||||
template<class T, class U>
|
||||
shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r);
|
||||
|
||||
// shared_ptr I/O:
|
||||
template<class E, class T, class Y>
|
||||
basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
|
||||
|
||||
// shared_ptr get_deleter:
|
||||
template<class D, class T> D* get_deleter(shared_ptr<T> const& p);
|
||||
|
||||
template<class T, class... Args>
|
||||
shared_ptr<T> make_shared(Args&&... args);
|
||||
template<class T, class A, class... Args>
|
||||
shared_ptr<T> allocate_shared(const A& a, Args&&... args);
|
||||
|
||||
template<class T>
|
||||
class weak_ptr
|
||||
{
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
// constructors
|
||||
constexpr weak_ptr();
|
||||
template<class Y> weak_ptr(shared_ptr<Y> const& r);
|
||||
weak_ptr(weak_ptr const& r);
|
||||
template<class Y> weak_ptr(weak_ptr<Y> const& r);
|
||||
|
||||
// destructor
|
||||
~weak_ptr();
|
||||
|
||||
// assignment
|
||||
weak_ptr& operator=(weak_ptr const& r);
|
||||
template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r);
|
||||
template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r);
|
||||
|
||||
// modifiers
|
||||
void swap(weak_ptr& r);
|
||||
void reset();
|
||||
|
||||
// observers
|
||||
long use_count() const;
|
||||
bool expired() const;
|
||||
shared_ptr<T> lock() const;
|
||||
template<class U> bool owner_before(shared_ptr<U> const& b);
|
||||
template<class U> bool owner_before(weak_ptr<U> const& b);
|
||||
};
|
||||
|
||||
// weak_ptr specialized algorithms:
|
||||
template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b);
|
||||
|
||||
// class owner_less:
|
||||
template<class T> struct owner_less;
|
||||
|
||||
template<class T>
|
||||
struct owner_less<shared_ptr<T>>
|
||||
: binary_function<shared_ptr<T>, shared_ptr<T>, bool>
|
||||
{
|
||||
typedef bool result_type;
|
||||
bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const;
|
||||
bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const;
|
||||
bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct owner_less<weak_ptr<T>>
|
||||
: binary_function<weak_ptr<T>, weak_ptr<T>, bool>
|
||||
{
|
||||
typedef bool result_type;
|
||||
bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const;
|
||||
bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const;
|
||||
bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
class enable_shared_from_this
|
||||
{
|
||||
protected:
|
||||
constexpr enable_shared_from_this();
|
||||
enable_shared_from_this(enable_shared_from_this const&);
|
||||
enable_shared_from_this& operator=(enable_shared_from_this const&);
|
||||
~enable_shared_from_this();
|
||||
public:
|
||||
shared_ptr<T> shared_from_this();
|
||||
shared_ptr<T const> shared_from_this() const;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
bool atomic_is_lock_free(const shared_ptr<T>* p);
|
||||
template<class T>
|
||||
shared_ptr<T> atomic_load(const shared_ptr<T>* p);
|
||||
template<class T>
|
||||
shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
|
||||
template<class T>
|
||||
void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
|
||||
template<class T>
|
||||
void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
|
||||
template<class T>
|
||||
shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
|
||||
template<class T>
|
||||
shared_ptr<T>
|
||||
atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
|
||||
template<class T>
|
||||
bool
|
||||
atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
|
||||
template<class T>
|
||||
bool
|
||||
atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
|
||||
template<class T>
|
||||
bool
|
||||
atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
|
||||
shared_ptr<T> w, memory_order success,
|
||||
memory_order failure);
|
||||
template<class T>
|
||||
bool
|
||||
atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
|
||||
shared_ptr<T> w, memory_order success,
|
||||
memory_order failure);
|
||||
// Hash support
|
||||
template <class T> struct hash;
|
||||
template <class T, class D> struct hash<unique_ptr<T, D> >;
|
||||
template <class T> struct hash<shared_ptr<T> >;
|
||||
|
||||
// Pointer safety
|
||||
enum class pointer_safety { relaxed, preferred, strict };
|
||||
void declare_reachable(void *p);
|
||||
template <class T> T *undeclare_reachable(T *p);
|
||||
void declare_no_pointers(char *p, size_t n);
|
||||
void undeclare_no_pointers(char *p, size_t n);
|
||||
pointer_safety get_pointer_safety();
|
||||
|
||||
void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
|
||||
|
||||
} // std
|
||||
|
|
@ -1147,423 +1473,6 @@ struct __uses_alloc_ctor
|
|||
: integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
|
||||
{};
|
||||
|
||||
// scoped_allocator_adaptor
|
||||
|
||||
template <class ..._Allocs>
|
||||
class scoped_allocator_adaptor;
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_copy_assignment;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_copy_assignment<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_copy_assignment::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_copy_assignment<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
|
||||
__get_poc_copy_assignment<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_move_assignment;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_move_assignment<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_move_assignment::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_move_assignment<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
|
||||
__get_poc_move_assignment<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_swap;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_swap<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_swap::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_swap<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_swap::value ||
|
||||
__get_poc_swap<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs>
|
||||
class __scoped_allocator_storage;
|
||||
|
||||
template <class _OuterAlloc, class... _InnerAllocs>
|
||||
class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
||||
: public _OuterAlloc
|
||||
{
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
protected:
|
||||
typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
|
||||
|
||||
private:
|
||||
inner_allocator_type __inner_;
|
||||
|
||||
protected:
|
||||
|
||||
__scoped_allocator_storage() {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
|
||||
const _InnerAllocs& ...__innerAllocs)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
|
||||
__inner_(__innerAllocs...) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other)
|
||||
: outer_allocator_type(__other.outer_allocator()),
|
||||
__inner_(__other.inner_allocator()) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other)
|
||||
: outer_allocator_type(_STD::move(__other.outer_allocator())),
|
||||
__inner_(_STD::move(__other.inner_allocator())) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __o,
|
||||
const inner_allocator_type& __i)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__o)),
|
||||
__inner_(__i)
|
||||
{
|
||||
}
|
||||
|
||||
inner_allocator_type& inner_allocator() {return __inner_;}
|
||||
const inner_allocator_type& inner_allocator() const {return __inner_;}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return static_cast<outer_allocator_type&>(*this);}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return static_cast<const outer_allocator_type&>(*this);}
|
||||
|
||||
scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
||||
select_on_container_copy_construction() const
|
||||
{
|
||||
return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
||||
(
|
||||
allocator_traits<outer_allocator_type>::
|
||||
select_on_container_copy_construction(outer_allocator()),
|
||||
allocator_traits<inner_allocator_type>::
|
||||
select_on_container_copy_construction(inner_allocator())
|
||||
);
|
||||
}
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
template <class _OuterAlloc>
|
||||
class __scoped_allocator_storage<_OuterAlloc>
|
||||
: public _OuterAlloc
|
||||
{
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
protected:
|
||||
typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
|
||||
|
||||
__scoped_allocator_storage() {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __outerAlloc)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
const __scoped_allocator_storage<_OuterA2>& __other)
|
||||
: outer_allocator_type(__other.outer_allocator()) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
__scoped_allocator_storage<_OuterA2>&& __other)
|
||||
: outer_allocator_type(_STD::move(__other.outer_allocator())) {}
|
||||
|
||||
inner_allocator_type& inner_allocator()
|
||||
{return static_cast<inner_allocator_type&>(*this);}
|
||||
const inner_allocator_type& inner_allocator() const
|
||||
{return static_cast<const inner_allocator_type&>(*this);}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return static_cast<outer_allocator_type&>(*this);}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return static_cast<const outer_allocator_type&>(*this);}
|
||||
|
||||
scoped_allocator_adaptor<outer_allocator_type>
|
||||
select_on_container_copy_construction() const
|
||||
{return scoped_allocator_adaptor<outer_allocator_type>(
|
||||
allocator_traits<outer_allocator_type>::
|
||||
select_on_container_copy_construction(outer_allocator())
|
||||
);}
|
||||
|
||||
__scoped_allocator_storage(const outer_allocator_type& __o,
|
||||
const inner_allocator_type& __i);
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
// __outermost
|
||||
|
||||
template <class _Alloc>
|
||||
decltype(declval<_Alloc>().outer_allocator(), true_type())
|
||||
__has_outer_allocator_test(_Alloc&& __a);
|
||||
|
||||
template <class _Alloc>
|
||||
false_type
|
||||
__has_outer_allocator_test(const volatile _Alloc& __a);
|
||||
|
||||
template <class _Alloc>
|
||||
struct __has_outer_allocator
|
||||
: public common_type
|
||||
<
|
||||
decltype(__has_outer_allocator_test(declval<_Alloc&>()))
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
|
||||
struct __outermost
|
||||
{
|
||||
typedef _Alloc type;
|
||||
type& operator()(type& __a) const {return __a;}
|
||||
};
|
||||
|
||||
template <class _Alloc>
|
||||
struct __outermost<_Alloc, true>
|
||||
{
|
||||
typedef typename remove_reference
|
||||
<
|
||||
decltype(_STD::declval<_Alloc>().outer_allocator())
|
||||
>::type _OuterAlloc;
|
||||
typedef typename __outermost<_OuterAlloc>::type type;
|
||||
type& operator()(_Alloc& __a) const
|
||||
{return __outermost<_OuterAlloc>()(__a.outer_allocator());}
|
||||
};
|
||||
|
||||
template <class _OuterAlloc, class... _InnerAllocs>
|
||||
class scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
|
||||
: public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
||||
{
|
||||
typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
|
||||
typedef allocator_traits<_OuterAlloc> _OuterTraits;
|
||||
public:
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
typedef typename base::inner_allocator_type inner_allocator_type;
|
||||
typedef typename _OuterTraits::size_type size_type;
|
||||
typedef typename _OuterTraits::difference_type difference_type;
|
||||
typedef typename _OuterTraits::pointer pointer;
|
||||
typedef typename _OuterTraits::const_pointer const_pointer;
|
||||
typedef typename _OuterTraits::void_pointer void_pointer;
|
||||
typedef typename _OuterTraits::const_void_pointer const_void_pointer;
|
||||
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_copy_assignment<outer_allocator_type,
|
||||
_InnerAllocs...>::value
|
||||
> propagate_on_container_copy_assignment;
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_move_assignment<outer_allocator_type,
|
||||
_InnerAllocs...>::value
|
||||
> propagate_on_container_move_assignment;
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
|
||||
> propagate_on_container_swap;
|
||||
|
||||
template <class _Tp>
|
||||
struct rebind
|
||||
{
|
||||
typedef scoped_allocator_adaptor
|
||||
<
|
||||
typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
|
||||
> other;
|
||||
};
|
||||
|
||||
scoped_allocator_adaptor() {}
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
|
||||
const _InnerAllocs& ...__innerAllocs)
|
||||
: base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
|
||||
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other)
|
||||
: base(__other) {}
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(
|
||||
scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other)
|
||||
: base(_STD::move(__other)) {}
|
||||
|
||||
// ~scoped_allocator_adaptor() = default;
|
||||
|
||||
inner_allocator_type& inner_allocator()
|
||||
{return base::inner_allocator();}
|
||||
const inner_allocator_type& inner_allocator() const
|
||||
{return base::inner_allocator();}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return base::outer_allocator();}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return base::outer_allocator();}
|
||||
|
||||
pointer allocate(size_type __n)
|
||||
{return allocator_traits<outer_allocator_type>::
|
||||
allocate(outer_allocator(), __n);}
|
||||
pointer allocate(size_type __n, const_void_pointer __hint)
|
||||
{return allocator_traits<outer_allocator_type>::
|
||||
allocate(outer_allocator(), __n, __hint);}
|
||||
|
||||
void deallocate(pointer __p, size_type __n)
|
||||
{allocator_traits<outer_allocator_type>::
|
||||
deallocate(outer_allocator(), __p, __n);}
|
||||
|
||||
size_type max_size() const
|
||||
{allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void construct(_Tp* __p, _Args&& ...__args)
|
||||
{__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
|
||||
__p, _STD::forward<_Args>(__args)...);}
|
||||
template <class _Tp>
|
||||
void destroy(_Tp* __p)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::
|
||||
destroy(_OM()(outer_allocator()), __p);
|
||||
}
|
||||
|
||||
scoped_allocator_adaptor select_on_container_copy_construction() const
|
||||
{return base::select_on_container_copy_construction();}
|
||||
|
||||
private:
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(_OuterA2&& __o,
|
||||
const inner_allocator_type& __i)
|
||||
: base(_STD::forward<_OuterA2>(__o), __i) {}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
_STD::forward<_Args>(__args)...
|
||||
);
|
||||
}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
allocator_arg,
|
||||
inner_allocator(),
|
||||
_STD::forward<_Args>(__args)...
|
||||
);
|
||||
}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
_STD::forward<_Args>(__args)...,
|
||||
inner_allocator()
|
||||
);
|
||||
}
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
template <class _OuterA1, class _OuterA2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2>& __b)
|
||||
{
|
||||
return __a.outer_allocator() == __b.outer_allocator();
|
||||
}
|
||||
|
||||
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
|
||||
{
|
||||
return __a.outer_allocator() == __b.outer_allocator() &&
|
||||
__a.inner_allocator() == __b.inner_allocator();
|
||||
}
|
||||
|
||||
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
|
||||
{
|
||||
return !(__a == __b);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// allocator
|
||||
|
|
|
|||
|
|
@ -0,0 +1,533 @@
|
|||
// -*- C++ -*-
|
||||
//===-------------------------- scoped_allocator --------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_SCOPED_ALLOCATOR
|
||||
#define _LIBCPP_SCOPED_ALLOCATOR
|
||||
|
||||
/*
|
||||
scoped_allocator synopsis
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
template <class OuterAlloc, class... InnerAllocs>
|
||||
class scoped_allocator_adaptor : public OuterAlloc
|
||||
{
|
||||
typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only
|
||||
scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only
|
||||
public:
|
||||
|
||||
typedef OuterAlloc outer_allocator_type;
|
||||
typedef see below inner_allocator_type;
|
||||
|
||||
typedef typename OuterTraits::value_type value_type;
|
||||
typedef typename OuterTraits::size_type size_type;
|
||||
typedef typename OuterTraits::difference_type difference_type;
|
||||
typedef typename OuterTraits::pointer pointer;
|
||||
typedef typename OuterTraits::const_pointer const_pointer;
|
||||
typedef typename OuterTraits::void_pointer void_pointer;
|
||||
typedef typename OuterTraits::const_void_pointer const_void_pointer;
|
||||
|
||||
typedef see below propagate_on_container_copy_assignment;
|
||||
typedef see below propagate_on_container_move_assignment;
|
||||
typedef see below propagate_on_container_swap;
|
||||
|
||||
template <class Tp>
|
||||
struct rebind
|
||||
{
|
||||
typedef scoped_allocator_adaptor<
|
||||
OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other;
|
||||
};
|
||||
|
||||
scoped_allocator_adaptor();
|
||||
template <class OuterA2>
|
||||
scoped_allocator_adaptor(OuterA2&& outerAlloc,
|
||||
const InnerAllocs&... innerAllocs);
|
||||
scoped_allocator_adaptor(const scoped_allocator_adaptor& other);
|
||||
template <class OuterA2>
|
||||
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other);
|
||||
template <class OuterA2>
|
||||
scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other);
|
||||
|
||||
~scoped_allocator_adaptor();
|
||||
|
||||
inner_allocator_type& inner_allocator();
|
||||
const inner_allocator_type& inner_allocator() const;
|
||||
|
||||
outer_allocator_type& outer_allocator();
|
||||
const outer_allocator_type& outer_allocator() const;
|
||||
|
||||
pointer allocate(size_type n);
|
||||
pointer allocate(size_type n, const_void_pointer hint);
|
||||
void deallocate(pointer p, size_type n);
|
||||
|
||||
size_type max_size() const;
|
||||
template <class T, class... Args> void construct(T* p, Args&& args);
|
||||
template <class T1, class T2, class... Args1, class... Args2>
|
||||
void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x,
|
||||
tuple<Args2...> y);
|
||||
template <class T1, class T2>
|
||||
void construct(pair<T1, T2>* p);
|
||||
template <class T1, class T2, class U, class V>
|
||||
void construct(pair<T1, T2>* p, U&& x, V&& y);
|
||||
template <class T1, class T2, class U, class V>
|
||||
void construct(pair<T1, T2>* p, const pair<U, V>& x);
|
||||
template <class T1, class T2, class U, class V>
|
||||
void construct(pair<T1, T2>* p, pair<U, V>&& x);
|
||||
template <class T> void destroy(T* p);
|
||||
|
||||
scoped_allocator_adaptor select_on_container_copy_construction() const;
|
||||
};
|
||||
|
||||
template <class OuterA1, class OuterA2, class... InnerAllocs>
|
||||
bool
|
||||
operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
|
||||
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
|
||||
|
||||
template <class OuterA1, class OuterA2, class... InnerAllocs>
|
||||
bool
|
||||
operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
|
||||
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
|
||||
|
||||
} // std
|
||||
|
||||
*/
|
||||
|
||||
#include <__config>
|
||||
#include <memory>
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if defined(_LIBCPP_MOVE) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)
|
||||
|
||||
// scoped_allocator_adaptor
|
||||
|
||||
template <class ..._Allocs>
|
||||
class scoped_allocator_adaptor;
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_copy_assignment;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_copy_assignment<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_copy_assignment::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_copy_assignment<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
|
||||
__get_poc_copy_assignment<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_move_assignment;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_move_assignment<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_move_assignment::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_move_assignment<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
|
||||
__get_poc_move_assignment<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs> struct __get_poc_swap;
|
||||
|
||||
template <class _A0>
|
||||
struct __get_poc_swap<_A0>
|
||||
{
|
||||
static const bool value = allocator_traits<_A0>::
|
||||
propagate_on_container_swap::value;
|
||||
};
|
||||
|
||||
template <class _A0, class ..._Allocs>
|
||||
struct __get_poc_swap<_A0, _Allocs...>
|
||||
{
|
||||
static const bool value =
|
||||
allocator_traits<_A0>::propagate_on_container_swap::value ||
|
||||
__get_poc_swap<_Allocs...>::value;
|
||||
};
|
||||
|
||||
template <class ..._Allocs>
|
||||
class __scoped_allocator_storage;
|
||||
|
||||
template <class _OuterAlloc, class... _InnerAllocs>
|
||||
class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
||||
: public _OuterAlloc
|
||||
{
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
protected:
|
||||
typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
|
||||
|
||||
private:
|
||||
inner_allocator_type __inner_;
|
||||
|
||||
protected:
|
||||
|
||||
__scoped_allocator_storage() {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
|
||||
const _InnerAllocs& ...__innerAllocs)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
|
||||
__inner_(__innerAllocs...) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other)
|
||||
: outer_allocator_type(__other.outer_allocator()),
|
||||
__inner_(__other.inner_allocator()) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other)
|
||||
: outer_allocator_type(_STD::move(__other.outer_allocator())),
|
||||
__inner_(_STD::move(__other.inner_allocator())) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __o,
|
||||
const inner_allocator_type& __i)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__o)),
|
||||
__inner_(__i)
|
||||
{
|
||||
}
|
||||
|
||||
inner_allocator_type& inner_allocator() {return __inner_;}
|
||||
const inner_allocator_type& inner_allocator() const {return __inner_;}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return static_cast<outer_allocator_type&>(*this);}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return static_cast<const outer_allocator_type&>(*this);}
|
||||
|
||||
scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
||||
select_on_container_copy_construction() const
|
||||
{
|
||||
return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
|
||||
(
|
||||
allocator_traits<outer_allocator_type>::
|
||||
select_on_container_copy_construction(outer_allocator()),
|
||||
allocator_traits<inner_allocator_type>::
|
||||
select_on_container_copy_construction(inner_allocator())
|
||||
);
|
||||
}
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
template <class _OuterAlloc>
|
||||
class __scoped_allocator_storage<_OuterAlloc>
|
||||
: public _OuterAlloc
|
||||
{
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
protected:
|
||||
typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
|
||||
|
||||
__scoped_allocator_storage() {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(_OuterA2&& __outerAlloc)
|
||||
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
const __scoped_allocator_storage<_OuterA2>& __other)
|
||||
: outer_allocator_type(__other.outer_allocator()) {}
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
__scoped_allocator_storage(
|
||||
__scoped_allocator_storage<_OuterA2>&& __other)
|
||||
: outer_allocator_type(_STD::move(__other.outer_allocator())) {}
|
||||
|
||||
inner_allocator_type& inner_allocator()
|
||||
{return static_cast<inner_allocator_type&>(*this);}
|
||||
const inner_allocator_type& inner_allocator() const
|
||||
{return static_cast<const inner_allocator_type&>(*this);}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return static_cast<outer_allocator_type&>(*this);}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return static_cast<const outer_allocator_type&>(*this);}
|
||||
|
||||
scoped_allocator_adaptor<outer_allocator_type>
|
||||
select_on_container_copy_construction() const
|
||||
{return scoped_allocator_adaptor<outer_allocator_type>(
|
||||
allocator_traits<outer_allocator_type>::
|
||||
select_on_container_copy_construction(outer_allocator())
|
||||
);}
|
||||
|
||||
__scoped_allocator_storage(const outer_allocator_type& __o,
|
||||
const inner_allocator_type& __i);
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
// __outermost
|
||||
|
||||
template <class _Alloc>
|
||||
decltype(declval<_Alloc>().outer_allocator(), true_type())
|
||||
__has_outer_allocator_test(_Alloc&& __a);
|
||||
|
||||
template <class _Alloc>
|
||||
false_type
|
||||
__has_outer_allocator_test(const volatile _Alloc& __a);
|
||||
|
||||
template <class _Alloc>
|
||||
struct __has_outer_allocator
|
||||
: public common_type
|
||||
<
|
||||
decltype(__has_outer_allocator_test(declval<_Alloc&>()))
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
|
||||
struct __outermost
|
||||
{
|
||||
typedef _Alloc type;
|
||||
type& operator()(type& __a) const {return __a;}
|
||||
};
|
||||
|
||||
template <class _Alloc>
|
||||
struct __outermost<_Alloc, true>
|
||||
{
|
||||
typedef typename remove_reference
|
||||
<
|
||||
decltype(_STD::declval<_Alloc>().outer_allocator())
|
||||
>::type _OuterAlloc;
|
||||
typedef typename __outermost<_OuterAlloc>::type type;
|
||||
type& operator()(_Alloc& __a) const
|
||||
{return __outermost<_OuterAlloc>()(__a.outer_allocator());}
|
||||
};
|
||||
|
||||
template <class _OuterAlloc, class... _InnerAllocs>
|
||||
class scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
|
||||
: public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
|
||||
{
|
||||
typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
|
||||
typedef allocator_traits<_OuterAlloc> _OuterTraits;
|
||||
public:
|
||||
typedef _OuterAlloc outer_allocator_type;
|
||||
typedef typename base::inner_allocator_type inner_allocator_type;
|
||||
typedef typename _OuterTraits::size_type size_type;
|
||||
typedef typename _OuterTraits::difference_type difference_type;
|
||||
typedef typename _OuterTraits::pointer pointer;
|
||||
typedef typename _OuterTraits::const_pointer const_pointer;
|
||||
typedef typename _OuterTraits::void_pointer void_pointer;
|
||||
typedef typename _OuterTraits::const_void_pointer const_void_pointer;
|
||||
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_copy_assignment<outer_allocator_type,
|
||||
_InnerAllocs...>::value
|
||||
> propagate_on_container_copy_assignment;
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_move_assignment<outer_allocator_type,
|
||||
_InnerAllocs...>::value
|
||||
> propagate_on_container_move_assignment;
|
||||
typedef integral_constant
|
||||
<
|
||||
bool,
|
||||
__get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
|
||||
> propagate_on_container_swap;
|
||||
|
||||
template <class _Tp>
|
||||
struct rebind
|
||||
{
|
||||
typedef scoped_allocator_adaptor
|
||||
<
|
||||
typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
|
||||
> other;
|
||||
};
|
||||
|
||||
scoped_allocator_adaptor() {}
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
|
||||
const _InnerAllocs& ...__innerAllocs)
|
||||
: base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
|
||||
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, const _OuterA2&>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other)
|
||||
: base(__other) {}
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(
|
||||
scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other)
|
||||
: base(_STD::move(__other)) {}
|
||||
|
||||
// ~scoped_allocator_adaptor() = default;
|
||||
|
||||
inner_allocator_type& inner_allocator()
|
||||
{return base::inner_allocator();}
|
||||
const inner_allocator_type& inner_allocator() const
|
||||
{return base::inner_allocator();}
|
||||
|
||||
outer_allocator_type& outer_allocator()
|
||||
{return base::outer_allocator();}
|
||||
const outer_allocator_type& outer_allocator() const
|
||||
{return base::outer_allocator();}
|
||||
|
||||
pointer allocate(size_type __n)
|
||||
{return allocator_traits<outer_allocator_type>::
|
||||
allocate(outer_allocator(), __n);}
|
||||
pointer allocate(size_type __n, const_void_pointer __hint)
|
||||
{return allocator_traits<outer_allocator_type>::
|
||||
allocate(outer_allocator(), __n, __hint);}
|
||||
|
||||
void deallocate(pointer __p, size_type __n)
|
||||
{allocator_traits<outer_allocator_type>::
|
||||
deallocate(outer_allocator(), __p, __n);}
|
||||
|
||||
size_type max_size() const
|
||||
{allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void construct(_Tp* __p, _Args&& ...__args)
|
||||
{__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
|
||||
__p, _STD::forward<_Args>(__args)...);}
|
||||
template <class _Tp>
|
||||
void destroy(_Tp* __p)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::
|
||||
destroy(_OM()(outer_allocator()), __p);
|
||||
}
|
||||
|
||||
scoped_allocator_adaptor select_on_container_copy_construction() const
|
||||
{return base::select_on_container_copy_construction();}
|
||||
|
||||
private:
|
||||
|
||||
template <class _OuterA2,
|
||||
class = typename enable_if<
|
||||
is_constructible<outer_allocator_type, _OuterA2>::value
|
||||
>::type>
|
||||
scoped_allocator_adaptor(_OuterA2&& __o,
|
||||
const inner_allocator_type& __i)
|
||||
: base(_STD::forward<_OuterA2>(__o), __i) {}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
_STD::forward<_Args>(__args)...
|
||||
);
|
||||
}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
allocator_arg,
|
||||
inner_allocator(),
|
||||
_STD::forward<_Args>(__args)...
|
||||
);
|
||||
}
|
||||
|
||||
template <class _Tp, class... _Args>
|
||||
void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
|
||||
{
|
||||
typedef __outermost<outer_allocator_type> _OM;
|
||||
allocator_traits<typename _OM::type>::construct
|
||||
(
|
||||
_OM()(outer_allocator()),
|
||||
__p,
|
||||
_STD::forward<_Args>(__args)...,
|
||||
inner_allocator()
|
||||
);
|
||||
}
|
||||
|
||||
template <class...> friend class __scoped_allocator_storage;
|
||||
};
|
||||
|
||||
template <class _OuterA1, class _OuterA2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2>& __b)
|
||||
{
|
||||
return __a.outer_allocator() == __b.outer_allocator();
|
||||
}
|
||||
|
||||
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
|
||||
{
|
||||
return __a.outer_allocator() == __b.outer_allocator() &&
|
||||
__a.inner_allocator() == __b.inner_allocator();
|
||||
}
|
||||
|
||||
template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
|
||||
const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
|
||||
{
|
||||
return !(__a == __b);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_SCOPED_ALLOCATOR
|
||||
|
|
@ -16,7 +16,7 @@
|
|||
// scoped_allocator_adaptor(OuterA2&& outerAlloc,
|
||||
// const InnerAllocs& ...innerAllocs);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
// scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2,
|
||||
// InnerAllocs...>& other);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
// scoped_allocator_adaptor(scoped_allocator_adaptor<OuterA2,
|
||||
// InnerAllocs...>&& other);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// scoped_allocator_adaptor(const scoped_allocator_adaptor& other);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// scoped_allocator_adaptor();
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// pointer allocate(size_type n);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// pointer allocate(size_type n, const_void_pointer hint);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// template <class T, class... Args> void construct(T* p, Args&&... args);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// void deallocate(pointer p, size_type n);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// template <class T> void destroy(T* p);
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
// inner_allocator_type& inner_allocator();
|
||||
// const inner_allocator_type& inner_allocator() const;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// size_type max_size() const;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
// outer_allocator_type& outer_allocator();
|
||||
// const outer_allocator_type& outer_allocator() const;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// scoped_allocator_adaptor select_on_container_copy_construction() const;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <cassert>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// typedef see below inner_allocator_type;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <type_traits>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// typedef see below propagate_on_container_copy_assignment;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <type_traits>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// typedef see below propagate_on_container_move_assignment;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <type_traits>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
// typedef see below propagate_on_container_swap;
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <type_traits>
|
||||
|
||||
#include "../allocators.h"
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
// typedef typename OuterTraits::const_void_pointer const_void_pointer;
|
||||
// };
|
||||
|
||||
#include <memory>
|
||||
#include <scoped_allocator>
|
||||
#include <type_traits>
|
||||
|
||||
#include "allocators.h"
|
||||
|
|
|
|||
Loading…
Reference in New Issue