src/third_party/libc++/trunk/test/support/allocators.h

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef ALLOCATORS_H
  11 #define ALLOCATORS_H
  12
  13 #include <type_traits>
  14 #include <utility>
  15
  16 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
  17
  18 template <class T>
  19 class A1
  20 {
  21     int id_;
  22 public:
  23     explicit A1(int id = 0) : id_(id) {}
  24
  25     typedef T value_type;
  26
  27     int id() const {return id_;}
  28
  29     static bool copy_called;
  30     static bool move_called;
  31     static bool allocate_called;
  32     static std::pair<T*, std::size_t> deallocate_called;
  33
  34     A1(const A1& a) : id_(a.id()) {copy_called = true;}
  35     A1(A1&& a) : id_(a.id())      {move_called = true;}
  36
  37     template <class U>
  38         A1(const A1<U>& a) : id_(a.id()) {copy_called = true;}
  39     template <class U>
  40         A1(A1<U>&& a) : id_(a.id()) {move_called = true;}
  41
  42     T* allocate(std::size_t n)
  43     {
  44         allocate_called = true;
  45         return (T*)n;
  46     }
  47
  48     void deallocate(T* p, std::size_t n)
  49     {
  50         deallocate_called = std::pair<T*, std::size_t>(p, n);
  51     }
  52
  53     std::size_t max_size() const {return id_;}
  54 };
  55
  56 template <class T> bool A1<T>::copy_called = false;
  57 template <class T> bool A1<T>::move_called = false;
  58 template <class T> bool A1<T>::allocate_called = false;
  59 template <class T> std::pair<T*, std::size_t> A1<T>::deallocate_called;
  60
  61 template <class T, class U>
  62 inline
  63 bool operator==(const A1<T>& x, const A1<U>& y)
  64 {
  65     return x.id() == y.id();
  66 }
  67
  68 template <class T, class U>
  69 inline
  70 bool operator!=(const A1<T>& x, const A1<U>& y)
  71 {
  72     return !(x == y);
  73 }
  74
  75 template <class T>
  76 class A2
  77 {
  78     int id_;
  79 public:
  80     explicit A2(int id = 0) : id_(id) {}
  81
  82     typedef T value_type;
  83
  84     typedef unsigned size_type;
  85     typedef int difference_type;
  86
  87     typedef std::true_type propagate_on_container_move_assignment;
  88
  89     int id() const {return id_;}
  90
  91     static bool copy_called;
  92     static bool move_called;
  93     static bool allocate_called;
  94
  95     A2(const A2& a) : id_(a.id()) {copy_called = true;}
  96     A2(A2&& a) : id_(a.id())      {move_called = true;}
  97
  98     T* allocate(std::size_t n, const void* hint)
  99     {
 100         allocate_called = true;
 101         return (T*)hint;
 102     }
 103 };
 104
 105 template <class T> bool A2<T>::copy_called = false;
 106 template <class T> bool A2<T>::move_called = false;
 107 template <class T> bool A2<T>::allocate_called = false;
 108
 109 template <class T, class U>
 110 inline
 111 bool operator==(const A2<T>& x, const A2<U>& y)
 112 {
 113     return x.id() == y.id();
 114 }
 115
 116 template <class T, class U>
 117 inline
 118 bool operator!=(const A2<T>& x, const A2<U>& y)
 119 {
 120     return !(x == y);
 121 }
 122
 123 template <class T>
 124 class A3
 125 {
 126     int id_;
 127 public:
 128     explicit A3(int id = 0) : id_(id) {}
 129
 130     typedef T value_type;
 131
 132     typedef std::true_type propagate_on_container_copy_assignment;
 133     typedef std::true_type propagate_on_container_swap;
 134
 135     int id() const {return id_;}
 136
 137     static bool copy_called;
 138     static bool move_called;
 139     static bool constructed;
 140     static bool destroy_called;
 141
 142     A3(const A3& a) : id_(a.id()) {copy_called = true;}
 143     A3(A3&& a) : id_(a.id())      {move_called = true;}
 144
 145     template <class U, class ...Args>
 146     void construct(U* p, Args&& ...args)
 147     {
 148         ::new (p) U(std::forward<Args>(args)...);
 149         constructed = true;
 150     }
 151
 152     template <class U>
 153     void destroy(U* p)
 154     {
 155         p->~U();
 156         destroy_called = true;
 157     }
 158
 159     A3 select_on_container_copy_construction() const {return A3(-1);}
 160 };
 161
 162 template <class T> bool A3<T>::copy_called = false;
 163 template <class T> bool A3<T>::move_called = false;
 164 template <class T> bool A3<T>::constructed = false;
 165 template <class T> bool A3<T>::destroy_called = false;
 166
 167 template <class T, class U>
 168 inline
 169 bool operator==(const A3<T>& x, const A3<U>& y)
 170 {
 171     return x.id() == y.id();
 172 }
 173
 174 template <class T, class U>
 175 inline
 176 bool operator!=(const A3<T>& x, const A3<U>& y)
 177 {
 178     return !(x == y);
 179 }
 180
 181 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 182
 183 #endif  // ALLOCATORS_H