root / lab4 / .minix-src / include / c++ / scoped_allocator
History | View | Annotate | Download (21.7 KB)
| 1 |
// -*- 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 |