root / lab4 / .minix-src / include / c++ / scoped_allocator
History | View | Annotate | Download (21.7 KB)
| 1 | 13 | up20180614 | // -*- C++ -*- |
|---|---|---|---|
| 2 | //===-------------------------- scoped_allocator --------------------------===// |
||
| 3 | // |
||
| 4 | // The LLVM Compiler Infrastructure |
||
| 5 | // |
||
| 6 | // This file is dual licensed under the MIT and the University of Illinois Open |
||
| 7 | // Source Licenses. See LICENSE.TXT for details. |
||
| 8 | // |
||
| 9 | //===----------------------------------------------------------------------===// |
||
| 10 | |||
| 11 | #ifndef _LIBCPP_SCOPED_ALLOCATOR |
||
| 12 | #define _LIBCPP_SCOPED_ALLOCATOR |
||
| 13 | |||
| 14 | /* |
||
| 15 | scoped_allocator synopsis |
||
| 16 | |||
| 17 | namespace std |
||
| 18 | {
|
||
| 19 | |||
| 20 | template <class OuterAlloc, class... InnerAllocs> |
||
| 21 | class scoped_allocator_adaptor : public OuterAlloc |
||
| 22 | {
|
||
| 23 | typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only |
||
| 24 | scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only |
||
| 25 | public: |
||
| 26 | |||
| 27 | typedef OuterAlloc outer_allocator_type; |
||
| 28 | typedef see below inner_allocator_type; |
||
| 29 | |||
| 30 | typedef typename OuterTraits::value_type value_type; |
||
| 31 | typedef typename OuterTraits::size_type size_type; |
||
| 32 | typedef typename OuterTraits::difference_type difference_type; |
||
| 33 | typedef typename OuterTraits::pointer pointer; |
||
| 34 | typedef typename OuterTraits::const_pointer const_pointer; |
||
| 35 | typedef typename OuterTraits::void_pointer void_pointer; |
||
| 36 | typedef typename OuterTraits::const_void_pointer const_void_pointer; |
||
| 37 | |||
| 38 | typedef see below propagate_on_container_copy_assignment; |
||
| 39 | typedef see below propagate_on_container_move_assignment; |
||
| 40 | typedef see below propagate_on_container_swap; |
||
| 41 | typedef see below is_always_equal; |
||
| 42 | |||
| 43 | template <class Tp> |
||
| 44 | struct rebind |
||
| 45 | {
|
||
| 46 | typedef scoped_allocator_adaptor< |
||
| 47 | OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other; |
||
| 48 | }; |
||
| 49 | |||
| 50 | scoped_allocator_adaptor(); |
||
| 51 | template <class OuterA2> |
||
| 52 | scoped_allocator_adaptor(OuterA2&& outerAlloc, |
||
| 53 | const InnerAllocs&... innerAllocs) noexcept; |
||
| 54 | scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept; |
||
| 55 | scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept; |
||
| 56 | template <class OuterA2> |
||
| 57 | scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept; |
||
| 58 | template <class OuterA2> |
||
| 59 | scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept; |
||
| 60 | |||
| 61 | ~scoped_allocator_adaptor(); |
||
| 62 | |||
| 63 | inner_allocator_type& inner_allocator() noexcept; |
||
| 64 | const inner_allocator_type& inner_allocator() const noexcept; |
||
| 65 | |||
| 66 | outer_allocator_type& outer_allocator() noexcept; |
||
| 67 | const outer_allocator_type& outer_allocator() const noexcept; |
||
| 68 | |||
| 69 | pointer allocate(size_type n); |
||
| 70 | pointer allocate(size_type n, const_void_pointer hint); |
||
| 71 | void deallocate(pointer p, size_type n) noexcept; |
||
| 72 | |||
| 73 | size_type max_size() const; |
||
| 74 | template <class T, class... Args> void construct(T* p, Args&& args); |
||
| 75 | template <class T1, class T2, class... Args1, class... Args2> |
||
| 76 | void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x, |
||
| 77 | tuple<Args2...> y); |
||
| 78 | template <class T1, class T2> |
||
| 79 | void construct(pair<T1, T2>* p); |
||
| 80 | template <class T1, class T2, class U, class V> |
||
| 81 | void construct(pair<T1, T2>* p, U&& x, V&& y); |
||
| 82 | template <class T1, class T2, class U, class V> |
||
| 83 | void construct(pair<T1, T2>* p, const pair<U, V>& x); |
||
| 84 | template <class T1, class T2, class U, class V> |
||
| 85 | void construct(pair<T1, T2>* p, pair<U, V>&& x); |
||
| 86 | template <class T> void destroy(T* p); |
||
| 87 | |||
| 88 | template <class T> void destroy(T* p) noexcept; |
||
| 89 | |||
| 90 | scoped_allocator_adaptor select_on_container_copy_construction() const noexcept; |
||
| 91 | }; |
||
| 92 | |||
| 93 | template <class OuterA1, class OuterA2, class... InnerAllocs> |
||
| 94 | bool |
||
| 95 | operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, |
||
| 96 | const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept; |
||
| 97 | |||
| 98 | template <class OuterA1, class OuterA2, class... InnerAllocs> |
||
| 99 | bool |
||
| 100 | operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, |
||
| 101 | const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept; |
||
| 102 | |||
| 103 | } // std |
||
| 104 | |||
| 105 | */ |
||
| 106 | |||
| 107 | #include <__config> |
||
| 108 | #include <memory> |
||
| 109 | |||
| 110 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
||
| 111 | #pragma GCC system_header |
||
| 112 | #endif |
||
| 113 | |||
| 114 | _LIBCPP_BEGIN_NAMESPACE_STD |
||
| 115 | |||
| 116 | #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) |
||
| 117 | |||
| 118 | // scoped_allocator_adaptor |
||
| 119 | |||
| 120 | template <class ..._Allocs> |
||
| 121 | class scoped_allocator_adaptor; |
||
| 122 | |||
| 123 | template <class ..._Allocs> struct __get_poc_copy_assignment; |
||
| 124 | |||
| 125 | template <class _A0> |
||
| 126 | struct __get_poc_copy_assignment<_A0> |
||
| 127 | {
|
||
| 128 | static const bool value = allocator_traits<_A0>:: |
||
| 129 | propagate_on_container_copy_assignment::value; |
||
| 130 | }; |
||
| 131 | |||
| 132 | template <class _A0, class ..._Allocs> |
||
| 133 | struct __get_poc_copy_assignment<_A0, _Allocs...> |
||
| 134 | {
|
||
| 135 | static const bool value = |
||
| 136 | allocator_traits<_A0>::propagate_on_container_copy_assignment::value || |
||
| 137 | __get_poc_copy_assignment<_Allocs...>::value; |
||
| 138 | }; |
||
| 139 | |||
| 140 | template <class ..._Allocs> struct __get_poc_move_assignment; |
||
| 141 | |||
| 142 | template <class _A0> |
||
| 143 | struct __get_poc_move_assignment<_A0> |
||
| 144 | {
|
||
| 145 | static const bool value = allocator_traits<_A0>:: |
||
| 146 | propagate_on_container_move_assignment::value; |
||
| 147 | }; |
||
| 148 | |||
| 149 | template <class _A0, class ..._Allocs> |
||
| 150 | struct __get_poc_move_assignment<_A0, _Allocs...> |
||
| 151 | {
|
||
| 152 | static const bool value = |
||
| 153 | allocator_traits<_A0>::propagate_on_container_move_assignment::value || |
||
| 154 | __get_poc_move_assignment<_Allocs...>::value; |
||
| 155 | }; |
||
| 156 | |||
| 157 | template <class ..._Allocs> struct __get_poc_swap; |
||
| 158 | |||
| 159 | template <class _A0> |
||
| 160 | struct __get_poc_swap<_A0> |
||
| 161 | {
|
||
| 162 | static const bool value = allocator_traits<_A0>:: |
||
| 163 | propagate_on_container_swap::value; |
||
| 164 | }; |
||
| 165 | |||
| 166 | template <class _A0, class ..._Allocs> |
||
| 167 | struct __get_poc_swap<_A0, _Allocs...> |
||
| 168 | {
|
||
| 169 | static const bool value = |
||
| 170 | allocator_traits<_A0>::propagate_on_container_swap::value || |
||
| 171 | __get_poc_swap<_Allocs...>::value; |
||
| 172 | }; |
||
| 173 | |||
| 174 | template <class ..._Allocs> struct __get_is_always_equal; |
||
| 175 | |||
| 176 | template <class _A0> |
||
| 177 | struct __get_is_always_equal<_A0> |
||
| 178 | {
|
||
| 179 | static const bool value = allocator_traits<_A0>::is_always_equal::value; |
||
| 180 | }; |
||
| 181 | |||
| 182 | template <class _A0, class ..._Allocs> |
||
| 183 | struct __get_is_always_equal<_A0, _Allocs...> |
||
| 184 | {
|
||
| 185 | static const bool value = |
||
| 186 | allocator_traits<_A0>::is_always_equal::value && |
||
| 187 | __get_is_always_equal<_Allocs...>::value; |
||
| 188 | }; |
||
| 189 | |||
| 190 | template <class ..._Allocs> |
||
| 191 | class __scoped_allocator_storage; |
||
| 192 | |||
| 193 | template <class _OuterAlloc, class... _InnerAllocs> |
||
| 194 | class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> |
||
| 195 | : public _OuterAlloc |
||
| 196 | {
|
||
| 197 | typedef _OuterAlloc outer_allocator_type; |
||
| 198 | protected: |
||
| 199 | typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type; |
||
| 200 | |||
| 201 | private: |
||
| 202 | inner_allocator_type __inner_; |
||
| 203 | |||
| 204 | protected: |
||
| 205 | |||
| 206 | _LIBCPP_INLINE_VISIBILITY |
||
| 207 | __scoped_allocator_storage() _NOEXCEPT {}
|
||
| 208 | |||
| 209 | template <class _OuterA2, |
||
| 210 | class = typename enable_if< |
||
| 211 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 212 | >::type> |
||
| 213 | _LIBCPP_INLINE_VISIBILITY |
||
| 214 | __scoped_allocator_storage(_OuterA2&& __outerAlloc, |
||
| 215 | const _InnerAllocs& ...__innerAllocs) _NOEXCEPT |
||
| 216 | : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)), |
||
| 217 | __inner_(__innerAllocs...) {}
|
||
| 218 | |||
| 219 | template <class _OuterA2, |
||
| 220 | class = typename enable_if< |
||
| 221 | is_constructible<outer_allocator_type, const _OuterA2&>::value |
||
| 222 | >::type> |
||
| 223 | _LIBCPP_INLINE_VISIBILITY |
||
| 224 | __scoped_allocator_storage( |
||
| 225 | const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT |
||
| 226 | : outer_allocator_type(__other.outer_allocator()), |
||
| 227 | __inner_(__other.inner_allocator()) {}
|
||
| 228 | |||
| 229 | template <class _OuterA2, |
||
| 230 | class = typename enable_if< |
||
| 231 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 232 | >::type> |
||
| 233 | _LIBCPP_INLINE_VISIBILITY |
||
| 234 | __scoped_allocator_storage( |
||
| 235 | __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT |
||
| 236 | : outer_allocator_type(_VSTD::move(__other.outer_allocator())), |
||
| 237 | __inner_(_VSTD::move(__other.inner_allocator())) {}
|
||
| 238 | |||
| 239 | template <class _OuterA2, |
||
| 240 | class = typename enable_if< |
||
| 241 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 242 | >::type> |
||
| 243 | _LIBCPP_INLINE_VISIBILITY |
||
| 244 | __scoped_allocator_storage(_OuterA2&& __o, |
||
| 245 | const inner_allocator_type& __i) _NOEXCEPT |
||
| 246 | : outer_allocator_type(_VSTD::forward<_OuterA2>(__o)), |
||
| 247 | __inner_(__i) |
||
| 248 | {
|
||
| 249 | } |
||
| 250 | |||
| 251 | _LIBCPP_INLINE_VISIBILITY |
||
| 252 | inner_allocator_type& inner_allocator() _NOEXCEPT {return __inner_;}
|
||
| 253 | _LIBCPP_INLINE_VISIBILITY |
||
| 254 | const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;}
|
||
| 255 | |||
| 256 | _LIBCPP_INLINE_VISIBILITY |
||
| 257 | outer_allocator_type& outer_allocator() _NOEXCEPT |
||
| 258 | {return static_cast<outer_allocator_type&>(*this);}
|
||
| 259 | _LIBCPP_INLINE_VISIBILITY |
||
| 260 | const outer_allocator_type& outer_allocator() const _NOEXCEPT |
||
| 261 | {return static_cast<const outer_allocator_type&>(*this);}
|
||
| 262 | |||
| 263 | scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...> |
||
| 264 | _LIBCPP_INLINE_VISIBILITY |
||
| 265 | select_on_container_copy_construction() const _NOEXCEPT |
||
| 266 | {
|
||
| 267 | return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...> |
||
| 268 | ( |
||
| 269 | allocator_traits<outer_allocator_type>:: |
||
| 270 | select_on_container_copy_construction(outer_allocator()), |
||
| 271 | allocator_traits<inner_allocator_type>:: |
||
| 272 | select_on_container_copy_construction(inner_allocator()) |
||
| 273 | ); |
||
| 274 | } |
||
| 275 | |||
| 276 | template <class...> friend class __scoped_allocator_storage; |
||
| 277 | }; |
||
| 278 | |||
| 279 | template <class _OuterAlloc> |
||
| 280 | class __scoped_allocator_storage<_OuterAlloc> |
||
| 281 | : public _OuterAlloc |
||
| 282 | {
|
||
| 283 | typedef _OuterAlloc outer_allocator_type; |
||
| 284 | protected: |
||
| 285 | typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type; |
||
| 286 | |||
| 287 | _LIBCPP_INLINE_VISIBILITY |
||
| 288 | __scoped_allocator_storage() _NOEXCEPT {}
|
||
| 289 | |||
| 290 | template <class _OuterA2, |
||
| 291 | class = typename enable_if< |
||
| 292 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 293 | >::type> |
||
| 294 | _LIBCPP_INLINE_VISIBILITY |
||
| 295 | __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT |
||
| 296 | : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
|
||
| 297 | |||
| 298 | template <class _OuterA2, |
||
| 299 | class = typename enable_if< |
||
| 300 | is_constructible<outer_allocator_type, const _OuterA2&>::value |
||
| 301 | >::type> |
||
| 302 | _LIBCPP_INLINE_VISIBILITY |
||
| 303 | __scoped_allocator_storage( |
||
| 304 | const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT |
||
| 305 | : outer_allocator_type(__other.outer_allocator()) {}
|
||
| 306 | |||
| 307 | template <class _OuterA2, |
||
| 308 | class = typename enable_if< |
||
| 309 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 310 | >::type> |
||
| 311 | _LIBCPP_INLINE_VISIBILITY |
||
| 312 | __scoped_allocator_storage( |
||
| 313 | __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT |
||
| 314 | : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
|
||
| 315 | |||
| 316 | _LIBCPP_INLINE_VISIBILITY |
||
| 317 | inner_allocator_type& inner_allocator() _NOEXCEPT |
||
| 318 | {return static_cast<inner_allocator_type&>(*this);}
|
||
| 319 | _LIBCPP_INLINE_VISIBILITY |
||
| 320 | const inner_allocator_type& inner_allocator() const _NOEXCEPT |
||
| 321 | {return static_cast<const inner_allocator_type&>(*this);}
|
||
| 322 | |||
| 323 | _LIBCPP_INLINE_VISIBILITY |
||
| 324 | outer_allocator_type& outer_allocator() _NOEXCEPT |
||
| 325 | {return static_cast<outer_allocator_type&>(*this);}
|
||
| 326 | _LIBCPP_INLINE_VISIBILITY |
||
| 327 | const outer_allocator_type& outer_allocator() const _NOEXCEPT |
||
| 328 | {return static_cast<const outer_allocator_type&>(*this);}
|
||
| 329 | |||
| 330 | _LIBCPP_INLINE_VISIBILITY |
||
| 331 | scoped_allocator_adaptor<outer_allocator_type> |
||
| 332 | select_on_container_copy_construction() const _NOEXCEPT |
||
| 333 | {return scoped_allocator_adaptor<outer_allocator_type>(
|
||
| 334 | allocator_traits<outer_allocator_type>:: |
||
| 335 | select_on_container_copy_construction(outer_allocator()) |
||
| 336 | );} |
||
| 337 | |||
| 338 | __scoped_allocator_storage(const outer_allocator_type& __o, |
||
| 339 | const inner_allocator_type& __i) _NOEXCEPT; |
||
| 340 | |||
| 341 | template <class...> friend class __scoped_allocator_storage; |
||
| 342 | }; |
||
| 343 | |||
| 344 | // __outermost |
||
| 345 | |||
| 346 | template <class _Alloc> |
||
| 347 | decltype(declval<_Alloc>().outer_allocator(), true_type()) |
||
| 348 | __has_outer_allocator_test(_Alloc&& __a); |
||
| 349 | |||
| 350 | template <class _Alloc> |
||
| 351 | false_type |
||
| 352 | __has_outer_allocator_test(const volatile _Alloc& __a); |
||
| 353 | |||
| 354 | template <class _Alloc> |
||
| 355 | struct __has_outer_allocator |
||
| 356 | : public common_type |
||
| 357 | < |
||
| 358 | decltype(__has_outer_allocator_test(declval<_Alloc&>())) |
||
| 359 | >::type |
||
| 360 | {
|
||
| 361 | }; |
||
| 362 | |||
| 363 | template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value> |
||
| 364 | struct __outermost |
||
| 365 | {
|
||
| 366 | typedef _Alloc type; |
||
| 367 | _LIBCPP_INLINE_VISIBILITY |
||
| 368 | type& operator()(type& __a) const _NOEXCEPT {return __a;}
|
||
| 369 | }; |
||
| 370 | |||
| 371 | template <class _Alloc> |
||
| 372 | struct __outermost<_Alloc, true> |
||
| 373 | {
|
||
| 374 | typedef typename remove_reference |
||
| 375 | < |
||
| 376 | decltype(_VSTD::declval<_Alloc>().outer_allocator()) |
||
| 377 | >::type _OuterAlloc; |
||
| 378 | typedef typename __outermost<_OuterAlloc>::type type; |
||
| 379 | _LIBCPP_INLINE_VISIBILITY |
||
| 380 | type& operator()(_Alloc& __a) const _NOEXCEPT |
||
| 381 | {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
|
||
| 382 | }; |
||
| 383 | |||
| 384 | template <class _OuterAlloc, class... _InnerAllocs> |
||
| 385 | class _LIBCPP_TYPE_VIS_ONLY scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> |
||
| 386 | : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> |
||
| 387 | {
|
||
| 388 | typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base; |
||
| 389 | typedef allocator_traits<_OuterAlloc> _OuterTraits; |
||
| 390 | public: |
||
| 391 | typedef _OuterAlloc outer_allocator_type; |
||
| 392 | typedef typename base::inner_allocator_type inner_allocator_type; |
||
| 393 | typedef typename _OuterTraits::size_type size_type; |
||
| 394 | typedef typename _OuterTraits::difference_type difference_type; |
||
| 395 | typedef typename _OuterTraits::pointer pointer; |
||
| 396 | typedef typename _OuterTraits::const_pointer const_pointer; |
||
| 397 | typedef typename _OuterTraits::void_pointer void_pointer; |
||
| 398 | typedef typename _OuterTraits::const_void_pointer const_void_pointer; |
||
| 399 | |||
| 400 | typedef integral_constant |
||
| 401 | < |
||
| 402 | bool, |
||
| 403 | __get_poc_copy_assignment<outer_allocator_type, |
||
| 404 | _InnerAllocs...>::value |
||
| 405 | > propagate_on_container_copy_assignment; |
||
| 406 | typedef integral_constant |
||
| 407 | < |
||
| 408 | bool, |
||
| 409 | __get_poc_move_assignment<outer_allocator_type, |
||
| 410 | _InnerAllocs...>::value |
||
| 411 | > propagate_on_container_move_assignment; |
||
| 412 | typedef integral_constant |
||
| 413 | < |
||
| 414 | bool, |
||
| 415 | __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value |
||
| 416 | > propagate_on_container_swap; |
||
| 417 | typedef integral_constant |
||
| 418 | < |
||
| 419 | bool, |
||
| 420 | __get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value |
||
| 421 | > is_always_equal; |
||
| 422 | |||
| 423 | template <class _Tp> |
||
| 424 | struct rebind |
||
| 425 | {
|
||
| 426 | typedef scoped_allocator_adaptor |
||
| 427 | < |
||
| 428 | typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs... |
||
| 429 | > other; |
||
| 430 | }; |
||
| 431 | |||
| 432 | _LIBCPP_INLINE_VISIBILITY |
||
| 433 | scoped_allocator_adaptor() _NOEXCEPT {}
|
||
| 434 | template <class _OuterA2, |
||
| 435 | class = typename enable_if< |
||
| 436 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 437 | >::type> |
||
| 438 | _LIBCPP_INLINE_VISIBILITY |
||
| 439 | scoped_allocator_adaptor(_OuterA2&& __outerAlloc, |
||
| 440 | const _InnerAllocs& ...__innerAllocs) _NOEXCEPT |
||
| 441 | : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
|
||
| 442 | // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default; |
||
| 443 | template <class _OuterA2, |
||
| 444 | class = typename enable_if< |
||
| 445 | is_constructible<outer_allocator_type, const _OuterA2&>::value |
||
| 446 | >::type> |
||
| 447 | _LIBCPP_INLINE_VISIBILITY |
||
| 448 | scoped_allocator_adaptor( |
||
| 449 | const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT |
||
| 450 | : base(__other) {}
|
||
| 451 | template <class _OuterA2, |
||
| 452 | class = typename enable_if< |
||
| 453 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 454 | >::type> |
||
| 455 | _LIBCPP_INLINE_VISIBILITY |
||
| 456 | scoped_allocator_adaptor( |
||
| 457 | scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT |
||
| 458 | : base(_VSTD::move(__other)) {}
|
||
| 459 | |||
| 460 | // ~scoped_allocator_adaptor() = default; |
||
| 461 | |||
| 462 | _LIBCPP_INLINE_VISIBILITY |
||
| 463 | inner_allocator_type& inner_allocator() _NOEXCEPT |
||
| 464 | {return base::inner_allocator();}
|
||
| 465 | _LIBCPP_INLINE_VISIBILITY |
||
| 466 | const inner_allocator_type& inner_allocator() const _NOEXCEPT |
||
| 467 | {return base::inner_allocator();}
|
||
| 468 | |||
| 469 | _LIBCPP_INLINE_VISIBILITY |
||
| 470 | outer_allocator_type& outer_allocator() _NOEXCEPT |
||
| 471 | {return base::outer_allocator();}
|
||
| 472 | _LIBCPP_INLINE_VISIBILITY |
||
| 473 | const outer_allocator_type& outer_allocator() const _NOEXCEPT |
||
| 474 | {return base::outer_allocator();}
|
||
| 475 | |||
| 476 | _LIBCPP_INLINE_VISIBILITY |
||
| 477 | pointer allocate(size_type __n) |
||
| 478 | {return allocator_traits<outer_allocator_type>::
|
||
| 479 | allocate(outer_allocator(), __n);} |
||
| 480 | _LIBCPP_INLINE_VISIBILITY |
||
| 481 | pointer allocate(size_type __n, const_void_pointer __hint) |
||
| 482 | {return allocator_traits<outer_allocator_type>::
|
||
| 483 | allocate(outer_allocator(), __n, __hint);} |
||
| 484 | |||
| 485 | _LIBCPP_INLINE_VISIBILITY |
||
| 486 | void deallocate(pointer __p, size_type __n) _NOEXCEPT |
||
| 487 | {allocator_traits<outer_allocator_type>::
|
||
| 488 | deallocate(outer_allocator(), __p, __n);} |
||
| 489 | |||
| 490 | _LIBCPP_INLINE_VISIBILITY |
||
| 491 | size_type max_size() const |
||
| 492 | {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
|
||
| 493 | |||
| 494 | template <class _Tp, class... _Args> |
||
| 495 | _LIBCPP_INLINE_VISIBILITY |
||
| 496 | void construct(_Tp* __p, _Args&& ...__args) |
||
| 497 | {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
|
||
| 498 | __p, _VSTD::forward<_Args>(__args)...);} |
||
| 499 | template <class _Tp> |
||
| 500 | _LIBCPP_INLINE_VISIBILITY |
||
| 501 | void destroy(_Tp* __p) |
||
| 502 | {
|
||
| 503 | typedef __outermost<outer_allocator_type> _OM; |
||
| 504 | allocator_traits<typename _OM::type>:: |
||
| 505 | destroy(_OM()(outer_allocator()), __p); |
||
| 506 | } |
||
| 507 | |||
| 508 | _LIBCPP_INLINE_VISIBILITY |
||
| 509 | scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT |
||
| 510 | {return base::select_on_container_copy_construction();}
|
||
| 511 | |||
| 512 | private: |
||
| 513 | |||
| 514 | template <class _OuterA2, |
||
| 515 | class = typename enable_if< |
||
| 516 | is_constructible<outer_allocator_type, _OuterA2>::value |
||
| 517 | >::type> |
||
| 518 | _LIBCPP_INLINE_VISIBILITY |
||
| 519 | scoped_allocator_adaptor(_OuterA2&& __o, |
||
| 520 | const inner_allocator_type& __i) _NOEXCEPT |
||
| 521 | : base(_VSTD::forward<_OuterA2>(__o), __i) {}
|
||
| 522 | |||
| 523 | template <class _Tp, class... _Args> |
||
| 524 | _LIBCPP_INLINE_VISIBILITY |
||
| 525 | void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args) |
||
| 526 | {
|
||
| 527 | typedef __outermost<outer_allocator_type> _OM; |
||
| 528 | allocator_traits<typename _OM::type>::construct |
||
| 529 | ( |
||
| 530 | _OM()(outer_allocator()), |
||
| 531 | __p, |
||
| 532 | _VSTD::forward<_Args>(__args)... |
||
| 533 | ); |
||
| 534 | } |
||
| 535 | |||
| 536 | template <class _Tp, class... _Args> |
||
| 537 | _LIBCPP_INLINE_VISIBILITY |
||
| 538 | void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args) |
||
| 539 | {
|
||
| 540 | typedef __outermost<outer_allocator_type> _OM; |
||
| 541 | allocator_traits<typename _OM::type>::construct |
||
| 542 | ( |
||
| 543 | _OM()(outer_allocator()), |
||
| 544 | __p, |
||
| 545 | allocator_arg, |
||
| 546 | inner_allocator(), |
||
| 547 | _VSTD::forward<_Args>(__args)... |
||
| 548 | ); |
||
| 549 | } |
||
| 550 | |||
| 551 | template <class _Tp, class... _Args> |
||
| 552 | _LIBCPP_INLINE_VISIBILITY |
||
| 553 | void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args) |
||
| 554 | {
|
||
| 555 | typedef __outermost<outer_allocator_type> _OM; |
||
| 556 | allocator_traits<typename _OM::type>::construct |
||
| 557 | ( |
||
| 558 | _OM()(outer_allocator()), |
||
| 559 | __p, |
||
| 560 | _VSTD::forward<_Args>(__args)..., |
||
| 561 | inner_allocator() |
||
| 562 | ); |
||
| 563 | } |
||
| 564 | |||
| 565 | template <class...> friend class __scoped_allocator_storage; |
||
| 566 | }; |
||
| 567 | |||
| 568 | template <class _OuterA1, class _OuterA2> |
||
| 569 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 570 | bool |
||
| 571 | operator==(const scoped_allocator_adaptor<_OuterA1>& __a, |
||
| 572 | const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT |
||
| 573 | {
|
||
| 574 | return __a.outer_allocator() == __b.outer_allocator(); |
||
| 575 | } |
||
| 576 | |||
| 577 | template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs> |
||
| 578 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 579 | bool |
||
| 580 | operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a, |
||
| 581 | const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT |
||
| 582 | {
|
||
| 583 | return __a.outer_allocator() == __b.outer_allocator() && |
||
| 584 | __a.inner_allocator() == __b.inner_allocator(); |
||
| 585 | } |
||
| 586 | |||
| 587 | template <class _OuterA1, class _OuterA2, class... _InnerAllocs> |
||
| 588 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 589 | bool |
||
| 590 | operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a, |
||
| 591 | const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT |
||
| 592 | {
|
||
| 593 | return !(__a == __b); |
||
| 594 | } |
||
| 595 | |||
| 596 | #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) |
||
| 597 | |||
| 598 | _LIBCPP_END_NAMESPACE_STD |
||
| 599 | |||
| 600 | #endif // _LIBCPP_SCOPED_ALLOCATOR |