aboutsummaryrefslogtreecommitdiff
path: root/tests/libcxx/include/memory
diff options
context:
space:
mode:
Diffstat (limited to 'tests/libcxx/include/memory')
-rw-r--r--tests/libcxx/include/memory3854
1 files changed, 0 insertions, 3854 deletions
diff --git a/tests/libcxx/include/memory b/tests/libcxx/include/memory
deleted file mode 100644
index f50128ca..00000000
--- a/tests/libcxx/include/memory
+++ /dev/null
@@ -1,3854 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- memory ------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_MEMORY
-#define _LIBCPP_MEMORY
-
-/*
- memory synopsis
-
-namespace std
-{
-
-struct allocator_arg_t { };
-constexpr allocator_arg_t allocator_arg = allocator_arg_t();
-
-template <class T, class Alloc> struct uses_allocator;
-
-template <class Ptr>
-struct pointer_traits
-{
- typedef Ptr pointer;
- typedef <details> element_type;
- typedef <details> difference_type;
-
- template <class U> using rebind = <details>;
-
- static pointer pointer_to(<details>);
-};
-
-template <class Alloc>
-struct allocator_traits
-{
- typedef Alloc allocator_type;
- typedef typename allocator_type::value_type
- value_type;
-
- typedef Alloc::pointer | value_type* pointer;
- typedef Alloc::const_pointer
- | pointer_traits<pointer>::rebind<const value_type>
- const_pointer;
- typedef Alloc::void_pointer
- | pointer_traits<pointer>::rebind<void>
- void_pointer;
- typedef Alloc::const_void_pointer
- | pointer_traits<pointer>::rebind<const void>
- const_void_pointer;
- typedef Alloc::difference_type
- | pointer_traits<pointer>::difference_type
- difference_type;
- typedef Alloc::size_type
- | make_unsigned<difference_type>::type
- size_type;
- typedef Alloc::propagate_on_container_copy_assignment
- | false_type propagate_on_container_copy_assignment;
- typedef Alloc::propagate_on_container_move_assignment
- | false_type propagate_on_container_move_assignment;
- typedef Alloc::propagate_on_container_swap
- | false_type propagate_on_container_swap;
-
- template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>;
- template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
-
- static pointer allocate(allocator_type& a, size_type n);
- static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
-
- static void deallocate(allocator_type& a, pointer p, size_type n);
-
- template <class T, class... Args>
- static void construct(allocator_type& a, T* p, Args&&... args);
-
- template <class T>
- static void destroy(allocator_type& a, T* p);
-
- static size_type max_size(const allocator_type& a);
-
- static allocator_type
- select_on_container_copy_construction(const allocator_type& a);
-};
-
-template <>
-class allocator<void>
-{
-public:
- typedef void* pointer;
- typedef const void* const_pointer;
- typedef void value_type;
-
- template <class _Up> struct rebind {typedef allocator<_Up> other;};
-};
-
-template <class T>
-class allocator
-{
-public:
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
- typedef T* pointer;
- typedef const T* const_pointer;
- typedef typename add_lvalue_reference<T>::type reference;
- typedef typename add_lvalue_reference<const T>::type const_reference;
- typedef T value_type;
-
- template <class U> struct rebind {typedef allocator<U> other;};
-
- allocator() throw();
- allocator(const allocator&) throw();
- template <class U> allocator(const allocator<U>&) throw();
- ~allocator() throw();
- pointer address(reference x) const;
- const_pointer address(const_reference x) const;
- pointer allocate(size_type, allocator<void>::const_pointer hint = 0);
- void deallocate(pointer p, size_type n);
- size_type max_size() const throw();
- void construct(pointer p, const T& val);
- void destroy(pointer p);
-};
-
-template <class T, class U>
-bool operator==(const allocator<T>&, const allocator<U>&) throw();
-
-template <class T, class U>
-bool operator!=(const allocator<T>&, const allocator<U>&) throw();
-
-template <class OutputIterator, class T>
-class raw_storage_iterator
- : public iterator<output_iterator_tag,
- T, // purposefully not C++03
- ptrdiff_t, // purposefully not C++03
- T*, // purposefully not C++03
- raw_storage_iterator&> // purposefully not C++03
-{
-public:
- explicit raw_storage_iterator(OutputIterator x);
- raw_storage_iterator& operator*();
- raw_storage_iterator& operator=(const T& element);
- raw_storage_iterator& operator++();
- raw_storage_iterator operator++(int);
-};
-
-template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n);
-template <class T> void return_temporary_buffer(T* p);
-
-template <class InputIterator, class ForwardIterator>
-ForwardIterator
-uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result);
-
-template <class ForwardIterator, class T>
-void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);
-
-template <class ForwardIterator, class Size, class T>
-ForwardIterator
-uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
-
-template <class Y> struct auto_ptr_ref {};
-
-template<class X>
-class auto_ptr
-{
-public:
- typedef X element_type;
-
- explicit auto_ptr(X* p =0) throw();
- auto_ptr(auto_ptr&) throw();
- template<class Y> auto_ptr(auto_ptr<Y>&) throw();
- auto_ptr& operator=(auto_ptr&) throw();
- template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
- auto_ptr& operator=(auto_ptr_ref<X> r) throw();
- ~auto_ptr() throw();
-
- typename add_lvalue_reference<X>::type operator*() const throw();
- X* operator->() const throw();
- X* get() const throw();
- X* release() throw();
- void reset(X* p =0) throw();
-
- auto_ptr(auto_ptr_ref<X>) throw();
- template<class Y> operator auto_ptr_ref<Y>() throw();
- 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>
- 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
-
-*/
-
-#include <__config>
-#include <type_traits>
-#include <typeinfo>
-#include <cstddef>
-#include <cstdint>
-#include <new>
-#include <utility>
-#include <limits>
-#include <iterator>
-#include <__functional_base>
-#if defined(_LIBCPP_NO_EXCEPTIONS)
- #include <cassert>
-#endif
-
-#pragma GCC system_header
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// allocator_arg_t
-
-struct _LIBCPP_VISIBLE allocator_arg_t { };
-
-extern const allocator_arg_t allocator_arg;
-
-// addressof
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-addressof(_Tp& __x)
-{
- return (_Tp*)&(char&)__x;
-}
-
-template <class _Tp> class allocator;
-
-template <>
-class _LIBCPP_VISIBLE allocator<void>
-{
-public:
- typedef void* pointer;
- typedef const void* const_pointer;
- typedef void value_type;
-
- template <class _Up> struct rebind {typedef allocator<_Up> other;};
-};
-
-// pointer_traits
-
-template <class _Tp>
-struct __has_element_type
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::element_type* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Ptr, bool = __has_element_type<_Ptr>::value>
-struct __pointer_traits_element_type;
-
-template <class _Ptr>
-struct __pointer_traits_element_type<_Ptr, true>
-{
- typedef typename _Ptr::element_type type;
-};
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <template <class, class...> class _Sp, class _Tp, class ..._Args>
-struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
-{
- typedef typename _Sp<_Tp, _Args...>::element_type type;
-};
-
-template <template <class, class...> class _Sp, class _Tp, class ..._Args>
-struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
-{
- typedef _Tp type;
-};
-
-#else // _LIBCPP_HAS_NO_VARIADICS
-
-template <template <class> class _Sp, class _Tp>
-struct __pointer_traits_element_type<_Sp<_Tp>, true>
-{
- typedef typename _Sp<_Tp>::element_type type;
-};
-
-template <template <class> class _Sp, class _Tp>
-struct __pointer_traits_element_type<_Sp<_Tp>, false>
-{
- typedef _Tp type;
-};
-
-template <template <class, class> class _Sp, class _Tp, class _A0>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true>
-{
- typedef typename _Sp<_Tp, _A0>::element_type type;
-};
-
-template <template <class, class> class _Sp, class _Tp, class _A0>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false>
-{
- typedef _Tp type;
-};
-
-template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true>
-{
- typedef typename _Sp<_Tp, _A0, _A1>::element_type type;
-};
-
-template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false>
-{
- typedef _Tp type;
-};
-
-template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _A2>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true>
-{
- typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type;
-};
-
-template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _A2>
-struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false>
-{
- typedef _Tp type;
-};
-
-#endif // _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Tp>
-struct __has_difference_type
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::difference_type* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
-struct __pointer_traits_difference_type
-{
- typedef ptrdiff_t type;
-};
-
-template <class _Ptr>
-struct __pointer_traits_difference_type<_Ptr, true>
-{
- typedef typename _Ptr::difference_type type;
-};
-
-template <class _Tp, class _Up>
-struct __has_rebind
-{
-private:
- struct __two {char _; char __;};
- template <class _Xp> static __two __test(...);
- template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
-struct __pointer_traits_rebind
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Tp::template rebind<_Up> type;
-#else
- typedef typename _Tp::template rebind<_Up>::other type;
-#endif
-};
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
-#else
- typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
-#endif
-};
-
-template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
-{
- typedef _Sp<_Up, _Args...> type;
-};
-
-#else // _LIBCPP_HAS_NO_VARIADICS
-
-template <template <class> class _Sp, class _Tp, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Sp<_Tp>::template rebind<_Up> type;
-#else
- typedef typename _Sp<_Tp>::template rebind<_Up>::other type;
-#endif
-};
-
-template <template <class> class _Sp, class _Tp, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false>
-{
- typedef _Sp<_Up> type;
-};
-
-template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type;
-#else
- typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type;
-#endif
-};
-
-template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false>
-{
- typedef _Sp<_Up, _A0> type;
-};
-
-template <template <class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type;
-#else
- typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type;
-#endif
-};
-
-template <template <class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false>
-{
- typedef _Sp<_Up, _A0, _A1> type;
-};
-
-template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _A2, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type;
-#else
- typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
-#endif
-};
-
-template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
- class _A1, class _A2, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
-{
- typedef _Sp<_Up, _A0, _A1, _A2> type;
-};
-
-#endif // _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Ptr>
-struct _LIBCPP_VISIBLE pointer_traits
-{
- typedef _Ptr pointer;
- typedef typename __pointer_traits_element_type<pointer>::type element_type;
- typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
-
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- template <class _Up> using rebind = __pointer_traits_rebind<pointer, _Up>::type;
-#else
- template <class _Up> struct rebind
- {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
-#endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-private:
- struct __nat {};
-public:
- _LIBCPP_INLINE_VISIBILITY
- static pointer pointer_to(typename conditional<is_void<element_type>::value,
- __nat, element_type>::type& __r)
- {return pointer::pointer_to(__r);}
-};
-
-template <class _Tp>
-struct _LIBCPP_VISIBLE pointer_traits<_Tp*>
-{
- typedef _Tp* pointer;
- typedef _Tp element_type;
- typedef ptrdiff_t difference_type;
-
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- template <class _Up> using rebind = _Up*;
-#else
- template <class _Up> struct rebind {typedef _Up* other;};
-#endif
-
-private:
- struct __nat {};
-public:
- _LIBCPP_INLINE_VISIBILITY
- static pointer pointer_to(typename conditional<is_void<element_type>::value,
- __nat, element_type>::type& __r)
- {return _STD::addressof(__r);}
-};
-
-// allocator_traits
-
-namespace __has_pointer_type_imp
-{
- template <class _Up> static __two test(...);
- template <class _Up> static char test(typename _Up::pointer* = 0);
-}
-
-template <class _Tp>
-struct __has_pointer_type
- : public integral_constant<bool, sizeof(__has_pointer_type_imp::test<_Tp>(0)) == 1>
-{
-};
-
-namespace __pointer_type_imp
-{
-
-template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value>
-struct __pointer_type
-{
- typedef typename _Dp::pointer type;
-};
-
-template <class _Tp, class _Dp>
-struct __pointer_type<_Tp, _Dp, false>
-{
- typedef _Tp* type;
-};
-
-} // __pointer_type_imp
-
-template <class _Tp, class _Dp>
-struct __pointer_type
-{
- typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type;
-};
-
-template <class _Tp>
-struct __has_const_pointer
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::const_pointer* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
-struct __const_pointer
-{
- typedef typename _Alloc::const_pointer type;
-};
-
-template <class _Tp, class _Ptr, class _Alloc>
-struct __const_pointer<_Tp, _Ptr, _Alloc, false>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type;
-#else
- typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
-#endif
-};
-
-template <class _Tp>
-struct __has_void_pointer
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::void_pointer* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
-struct __void_pointer
-{
- typedef typename _Alloc::void_pointer type;
-};
-
-template <class _Ptr, class _Alloc>
-struct __void_pointer<_Ptr, _Alloc, false>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename pointer_traits<_Ptr>::template rebind<void> type;
-#else
- typedef typename pointer_traits<_Ptr>::template rebind<void>::other type;
-#endif
-};
-
-template <class _Tp>
-struct __has_const_void_pointer
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::const_void_pointer* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
-struct __const_void_pointer
-{
- typedef typename _Alloc::const_void_pointer type;
-};
-
-template <class _Ptr, class _Alloc>
-struct __const_void_pointer<_Ptr, _Alloc, false>
-{
-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
- typedef typename pointer_traits<_Ptr>::template rebind<const void> type;
-#else
- typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type;
-#endif
-};
-
-template <class _T>
-inline _LIBCPP_INLINE_VISIBILITY
-_T*
-__to_raw_pointer(_T* __p)
-{
- return __p;
-}
-
-template <class _Pointer>
-inline _LIBCPP_INLINE_VISIBILITY
-typename pointer_traits<_Pointer>::element_type*
-__to_raw_pointer(_Pointer __p)
-{
- return _STD::__to_raw_pointer(__p.operator->());
-}
-
-template <class _Tp>
-struct __has_size_type
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::size_type* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
-struct __size_type
-{
- typedef typename make_unsigned<_DiffType>::type type;
-};
-
-template <class _Alloc, class _DiffType>
-struct __size_type<_Alloc, _DiffType, true>
-{
- typedef typename _Alloc::size_type type;
-};
-
-template <class _Tp>
-struct __has_propagate_on_container_copy_assignment
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::propagate_on_container_copy_assignment* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
-struct __propagate_on_container_copy_assignment
-{
- typedef false_type type;
-};
-
-template <class _Alloc>
-struct __propagate_on_container_copy_assignment<_Alloc, true>
-{
- typedef typename _Alloc::propagate_on_container_copy_assignment type;
-};
-
-template <class _Tp>
-struct __has_propagate_on_container_move_assignment
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::propagate_on_container_move_assignment* = 0);
-public:
- static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
-
-template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
-struct __propagate_on_container_move_assignment
-{
- typedef false_type type;
-};
-
-template <class _Alloc>
-struct __propagate_on_container_move_assignment<_Alloc, true>
-{
- typedef typename _Alloc::propagate_on_container_move_assignment type;
-};
-
-template <class _Tp>
-struct __has_propagate_on_container_swap
-{
-private:
- struct __two {char _; char __;};
- template <class _Up> static __two __test(...);
- template <class _Up> static char __test(typename _Up::propagate_on_container_swap* = 0);
-public: