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