<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/scoped_allocator</h2><form method='post'><textarea name='content' class='file-edit'>// &lt;scoped_allocator&gt; -*- C++ -*-

// Copyright (C) 2011-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file include/scoped_allocator
 *  This is a Standard C++ Library header.
 *  @ingroup allocators
 */

#ifndef _SCOPED_ALLOCATOR
#define _SCOPED_ALLOCATOR 1

#pragma GCC system_header

#if __cplusplus &lt; 201103L
# include &lt;bits/c++0x_warning.h&gt;
#else

#include &lt;tuple&gt;
#include &lt;bits/alloc_traits.h&gt;
#include &lt;bits/stl_pair.h&gt;
#include &lt;bits/uses_allocator.h&gt;
#if __cplusplus &gt; 201703L
# include &lt;bits/uses_allocator_args.h&gt;
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   * @addtogroup allocators
   * @{
   */

  template&lt;typename _OuterAlloc, typename... _InnerAllocs&gt;
    class scoped_allocator_adaptor;

  /// @cond undocumented

  template&lt;typename _Alloc&gt;
    using __outer_allocator_t
      = decltype(std::declval&lt;_Alloc&gt;().outer_allocator());

  template&lt;typename _Alloc, typename = void&gt;
    struct __outermost_type
    {
      using type = _Alloc;
      static type&amp; _S_outermost(_Alloc&amp; __a) { return __a; }
    };

  template&lt;typename _Alloc&gt;
    struct __outermost_type&lt;_Alloc, __void_t&lt;__outer_allocator_t&lt;_Alloc&gt;&gt;&gt;
    : __outermost_type&lt;
      typename remove_reference&lt;__outer_allocator_t&lt;_Alloc&gt;&gt;::type
    &gt;
    {
      using __base = __outermost_type&lt;
        typename remove_reference&lt;__outer_allocator_t&lt;_Alloc&gt;&gt;::type
      &gt;;

      static typename __base::type&amp;
      _S_outermost(_Alloc&amp; __a)
      { return __base::_S_outermost(__a.outer_allocator()); }
    };

  // Implementation of the OUTERMOST pseudofunction
  template&lt;typename _Alloc&gt;
    inline typename __outermost_type&lt;_Alloc&gt;::type&amp;
    __outermost(_Alloc&amp; __a)
    { return __outermost_type&lt;_Alloc&gt;::_S_outermost(__a); }

  template&lt;typename...&gt;
    struct __inner_type_impl;

  template&lt;typename _Outer&gt;
    struct __inner_type_impl&lt;_Outer&gt;
    {
      typedef scoped_allocator_adaptor&lt;_Outer&gt; __type;

      __inner_type_impl() = default;
      __inner_type_impl(const __inner_type_impl&amp;) = default;
      __inner_type_impl(__inner_type_impl&amp;&amp;) = default;
      __inner_type_impl&amp; operator=(const __inner_type_impl&amp;) = default;
      __inner_type_impl&amp; operator=(__inner_type_impl&amp;&amp;) = default;

      template&lt;typename _Alloc&gt;
      __inner_type_impl(const __inner_type_impl&lt;_Alloc&gt;&amp; __other)
      { }

      template&lt;typename _Alloc&gt;
      __inner_type_impl(__inner_type_impl&lt;_Alloc&gt;&amp;&amp; __other)
      { }

      __type&amp;
      _M_get(__type* __p) noexcept { return *__p; }

      const __type&amp;
      _M_get(const __type* __p) const noexcept { return *__p; }

      tuple&lt;&gt;
      _M_tie() const noexcept { return tuple&lt;&gt;(); }

      bool
      operator==(const __inner_type_impl&amp;) const noexcept
      { return true; }
    };

  template&lt;typename _Outer, typename _InnerHead, typename... _InnerTail&gt;
    struct __inner_type_impl&lt;_Outer, _InnerHead, _InnerTail...&gt;
    {
      typedef scoped_allocator_adaptor&lt;_InnerHead, _InnerTail...&gt; __type;

      __inner_type_impl() = default;
      __inner_type_impl(const __inner_type_impl&amp;) = default;
      __inner_type_impl(__inner_type_impl&amp;&amp;) = default;
      __inner_type_impl&amp; operator=(const __inner_type_impl&amp;) = default;
      __inner_type_impl&amp; operator=(__inner_type_impl&amp;&amp;) = default;

      template&lt;typename... _Allocs&gt;
      __inner_type_impl(const __inner_type_impl&lt;_Allocs...&gt;&amp; __other)
      : _M_inner(__other._M_inner) { }

      template&lt;typename... _Allocs&gt;
      __inner_type_impl(__inner_type_impl&lt;_Allocs...&gt;&amp;&amp; __other)
      : _M_inner(std::move(__other._M_inner)) { }

    template&lt;typename... _Args&gt;
      explicit
      __inner_type_impl(_Args&amp;&amp;... __args)
      : _M_inner(std::forward&lt;_Args&gt;(__args)...) { }

      __type&amp;
      _M_get(void*) noexcept { return _M_inner; }

      const __type&amp;
      _M_get(const void*) const noexcept { return _M_inner; }

      tuple&lt;const _InnerHead&amp;, const _InnerTail&amp;...&gt;
      _M_tie() const noexcept
      { return _M_inner._M_tie(); }

      bool
      operator==(const __inner_type_impl&amp; __other) const noexcept
      { return _M_inner == __other._M_inner; }

    private:
      template&lt;typename...&gt; friend class __inner_type_impl;
      template&lt;typename, typename...&gt; friend class scoped_allocator_adaptor;

      __type _M_inner;
    };

  /// @endcond

  /// An adaptor to recursively pass an allocator to the objects it constructs
  template&lt;typename _OuterAlloc, typename... _InnerAllocs&gt;
    class scoped_allocator_adaptor
    : public _OuterAlloc
    {
      typedef allocator_traits&lt;_OuterAlloc&gt; __traits;

      typedef __inner_type_impl&lt;_OuterAlloc, _InnerAllocs...&gt; __inner_type;
      __inner_type _M_inner;

      template&lt;typename _Outer, typename... _Inner&gt;
        friend class scoped_allocator_adaptor;

      template&lt;typename...&gt;
        friend class __inner_type_impl;

      tuple&lt;const _OuterAlloc&amp;, const _InnerAllocs&amp;...&gt;
      _M_tie() const noexcept
      { return std::tuple_cat(std::tie(outer_allocator()), _M_inner._M_tie()); }

      template&lt;typename _Alloc&gt;
	using __outermost_alloc_traits
	  = allocator_traits&lt;typename __outermost_type&lt;_Alloc&gt;::type&gt;;

#if ! __cpp_lib_make_obj_using_allocator
      template&lt;typename _Tp, typename... _Args&gt;
        void
        _M_construct(__uses_alloc0, _Tp* __p, _Args&amp;&amp;... __args)
        {
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  _O_traits::construct(__outermost(*this), __p,
			       std::forward&lt;_Args&gt;(__args)...);
        }

      typedef __uses_alloc1&lt;typename __inner_type::__type&gt; __uses_alloc1_;
      typedef __uses_alloc2&lt;typename __inner_type::__type&gt; __uses_alloc2_;

      template&lt;typename _Tp, typename... _Args&gt;
        void
        _M_construct(__uses_alloc1_, _Tp* __p, _Args&amp;&amp;... __args)
        {
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  _O_traits::construct(__outermost(*this), __p,
			       allocator_arg, inner_allocator(),
			       std::forward&lt;_Args&gt;(__args)...);
        }

      template&lt;typename _Tp, typename... _Args&gt;
        void
        _M_construct(__uses_alloc2_, _Tp* __p, _Args&amp;&amp;... __args)
        {
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  _O_traits::construct(__outermost(*this), __p,
			       std::forward&lt;_Args&gt;(__args)...,
			       inner_allocator());
        }
#endif // ! make_obj_using_allocator

      template&lt;typename _Alloc&gt;
        static _Alloc
        _S_select_on_copy(const _Alloc&amp; __a)
        {
          typedef allocator_traits&lt;_Alloc&gt; __a_traits;
          return __a_traits::select_on_container_copy_construction(__a);
        }

      template&lt;std::size_t... _Indices&gt;
        scoped_allocator_adaptor(tuple&lt;const _OuterAlloc&amp;,
                                       const _InnerAllocs&amp;...&gt; __refs,
                                 _Index_tuple&lt;_Indices...&gt;)
        : _OuterAlloc(_S_select_on_copy(std::get&lt;0&gt;(__refs))),
          _M_inner(_S_select_on_copy(std::get&lt;_Indices+1&gt;(__refs))...)
        { }

      // Used to constrain constructors to disallow invalid conversions.
      template&lt;typename _Alloc&gt;
        using _Constructible = typename enable_if&lt;
            is_constructible&lt;_OuterAlloc, _Alloc&gt;::value
          &gt;::type;

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2975. Missing case for pair construction in scoped [...] allocators
      template&lt;typename _Tp&gt;
	struct __not_pair { using type = void; };

      template&lt;typename _Tp, typename _Up&gt;
	struct __not_pair&lt;pair&lt;_Tp, _Up&gt;&gt; { };

    public:
      typedef _OuterAlloc                       outer_allocator_type;
      typedef typename __inner_type::__type     inner_allocator_type;

      typedef typename __traits::value_type             value_type;
      typedef typename __traits::size_type              size_type;
      typedef typename __traits::difference_type        difference_type;
      typedef typename __traits::pointer                pointer;
      typedef typename __traits::const_pointer          const_pointer;
      typedef typename __traits::void_pointer           void_pointer;
      typedef typename __traits::const_void_pointer     const_void_pointer;

      typedef typename __or_&lt;
	typename __traits::propagate_on_container_copy_assignment,
	typename allocator_traits&lt;_InnerAllocs&gt;::
	  propagate_on_container_copy_assignment...&gt;::type
	  propagate_on_container_copy_assignment;

      typedef typename __or_&lt;
	typename __traits::propagate_on_container_move_assignment,
	typename allocator_traits&lt;_InnerAllocs&gt;::
	  propagate_on_container_move_assignment...&gt;::type
	  propagate_on_container_move_assignment;

      typedef typename __or_&lt;
	typename __traits::propagate_on_container_swap,
	typename allocator_traits&lt;_InnerAllocs&gt;::
	  propagate_on_container_swap...&gt;::type
	  propagate_on_container_swap;

      typedef typename __and_&lt;
	typename __traits::is_always_equal,
	typename allocator_traits&lt;_InnerAllocs&gt;::is_always_equal...&gt;::type
	  is_always_equal;

      template &lt;class _Tp&gt;
        struct rebind
        {
          typedef scoped_allocator_adaptor&lt;
            typename __traits::template rebind_alloc&lt;_Tp&gt;,
            _InnerAllocs...&gt; other;
        };

      scoped_allocator_adaptor() : _OuterAlloc(), _M_inner() { }

      template&lt;typename _Outer2, typename = _Constructible&lt;_Outer2&gt;&gt;
        scoped_allocator_adaptor(_Outer2&amp;&amp; __outer,
                                 const _InnerAllocs&amp;... __inner)
        : _OuterAlloc(std::forward&lt;_Outer2&gt;(__outer)),
          _M_inner(__inner...)
        { }

      scoped_allocator_adaptor(const scoped_allocator_adaptor&amp; __other)
      : _OuterAlloc(__other.outer_allocator()),
	_M_inner(__other._M_inner)
      { }

      scoped_allocator_adaptor(scoped_allocator_adaptor&amp;&amp; __other)
      : _OuterAlloc(std::move(__other.outer_allocator())),
	_M_inner(std::move(__other._M_inner))
      { }

      template&lt;typename _Outer2, typename = _Constructible&lt;const _Outer2&amp;&gt;&gt;
        scoped_allocator_adaptor(
            const scoped_allocator_adaptor&lt;_Outer2, _InnerAllocs...&gt;&amp; __other)
        : _OuterAlloc(__other.outer_allocator()),
          _M_inner(__other._M_inner)
        { }

      template&lt;typename _Outer2, typename = _Constructible&lt;_Outer2&gt;&gt;
        scoped_allocator_adaptor(
            scoped_allocator_adaptor&lt;_Outer2, _InnerAllocs...&gt;&amp;&amp; __other)
        : _OuterAlloc(std::move(__other.outer_allocator())),
          _M_inner(std::move(__other._M_inner))
        { }

      scoped_allocator_adaptor&amp;
      operator=(const scoped_allocator_adaptor&amp;) = default;

      scoped_allocator_adaptor&amp;
      operator=(scoped_allocator_adaptor&amp;&amp;) = default;

      inner_allocator_type&amp; inner_allocator() noexcept
      { return _M_inner._M_get(this); }

      const inner_allocator_type&amp; inner_allocator() const noexcept
      { return _M_inner._M_get(this); }

      outer_allocator_type&amp; outer_allocator() noexcept
      { return static_cast&lt;_OuterAlloc&amp;&gt;(*this); }

      const outer_allocator_type&amp; outer_allocator() const noexcept
      { return static_cast&lt;const _OuterAlloc&amp;&gt;(*this); }

      _GLIBCXX_NODISCARD pointer allocate(size_type __n)
      { return __traits::allocate(outer_allocator(), __n); }

      _GLIBCXX_NODISCARD pointer allocate(size_type __n, const_void_pointer __hint)
      { return __traits::allocate(outer_allocator(), __n, __hint); }

      void deallocate(pointer __p, size_type __n)
      { return __traits::deallocate(outer_allocator(), __p, __n); }

      size_type max_size() const
      { return __traits::max_size(outer_allocator()); }

#if ! __cpp_lib_make_obj_using_allocator
      template&lt;typename _Tp, typename... _Args&gt;
	typename __not_pair&lt;_Tp&gt;::type
	construct(_Tp* __p, _Args&amp;&amp;... __args)
	{
	  auto&amp; __inner = inner_allocator();
	  auto __use_tag
	    = std::__use_alloc&lt;_Tp, inner_allocator_type, _Args...&gt;(__inner);
	  _M_construct(__use_tag, __p, std::forward&lt;_Args&gt;(__args)...);
	}

      template&lt;typename _T1, typename _T2, typename... _Args1,
	       typename... _Args2&gt;
	void
	construct(pair&lt;_T1, _T2&gt;* __p, piecewise_construct_t,
		  tuple&lt;_Args1...&gt; __x, tuple&lt;_Args2...&gt; __y)
	{
	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
	  // 2203.  wrong argument types for piecewise construction
	  auto&amp; __inner = inner_allocator();
	  auto __x_use_tag
	    = std::__use_alloc&lt;_T1, inner_allocator_type, _Args1...&gt;(__inner);
	  auto __y_use_tag
	    = std::__use_alloc&lt;_T2, inner_allocator_type, _Args2...&gt;(__inner);
	  typename _Build_index_tuple&lt;sizeof...(_Args1)&gt;::__type __x_indices;
	  typename _Build_index_tuple&lt;sizeof...(_Args2)&gt;::__type __y_indices;
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  _O_traits::construct(__outermost(*this), __p, piecewise_construct,
			       _M_construct_p(__x_use_tag, __x_indices, __x),
			       _M_construct_p(__y_use_tag, __y_indices, __y));
	}

      template&lt;typename _T1, typename _T2&gt;
	void
	construct(pair&lt;_T1, _T2&gt;* __p)
	{ construct(__p, piecewise_construct, tuple&lt;&gt;(), tuple&lt;&gt;()); }

      template&lt;typename _T1, typename _T2, typename _Up, typename _Vp&gt;
	void
	construct(pair&lt;_T1, _T2&gt;* __p, _Up&amp;&amp; __u, _Vp&amp;&amp; __v)
	{
	  construct(__p, piecewise_construct,
		    std::forward_as_tuple(std::forward&lt;_Up&gt;(__u)),
		    std::forward_as_tuple(std::forward&lt;_Vp&gt;(__v)));
	}

      template&lt;typename _T1, typename _T2, typename _Up, typename _Vp&gt;
	void
	construct(pair&lt;_T1, _T2&gt;* __p, const pair&lt;_Up, _Vp&gt;&amp; __x)
	{
	  construct(__p, piecewise_construct,
		    std::forward_as_tuple(__x.first),
		    std::forward_as_tuple(__x.second));
	}

      template&lt;typename _T1, typename _T2, typename _Up, typename _Vp&gt;
	void
	construct(pair&lt;_T1, _T2&gt;* __p, pair&lt;_Up, _Vp&gt;&amp;&amp; __x)
	{
	  construct(__p, piecewise_construct,
		    std::forward_as_tuple(std::forward&lt;_Up&gt;(__x.first)),
		    std::forward_as_tuple(std::forward&lt;_Vp&gt;(__x.second)));
	}
#else // make_obj_using_allocator
      template&lt;typename _Tp, typename... _Args&gt;
	__attribute__((__nonnull__))
	void
	construct(_Tp* __p, _Args&amp;&amp;... __args)
	{
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  std::apply([__p, this](auto&amp;&amp;... __newargs) {
	      _O_traits::construct(__outermost(*this), __p,
		  std::forward&lt;decltype(__newargs)&gt;(__newargs)...);
	  },
	  uses_allocator_construction_args&lt;_Tp&gt;(inner_allocator(),
	    std::forward&lt;_Args&gt;(__args)...));
	}
#endif

      template&lt;typename _Tp&gt;
        void destroy(_Tp* __p)
        {
	  typedef __outermost_alloc_traits&lt;scoped_allocator_adaptor&gt; _O_traits;
	  _O_traits::destroy(__outermost(*this), __p);
	}

      scoped_allocator_adaptor
      select_on_container_copy_construction() const
      {
        typedef typename _Build_index_tuple&lt;sizeof...(_InnerAllocs)&gt;::__type
	    _Indices;
        return scoped_allocator_adaptor(_M_tie(), _Indices());
      }

      template &lt;typename _OutA1, typename _OutA2, typename... _InA&gt;
      friend bool
      operator==(const scoped_allocator_adaptor&lt;_OutA1, _InA...&gt;&amp; __a,
                 const scoped_allocator_adaptor&lt;_OutA2, _InA...&gt;&amp; __b) noexcept;

    private:
#if ! __cpp_lib_make_obj_using_allocator
      template&lt;typename _Ind, typename... _Args&gt;
	tuple&lt;_Args&amp;&amp;...&gt;
	_M_construct_p(__uses_alloc0, _Ind, tuple&lt;_Args...&gt;&amp; __t)
	{ return std::move(__t); }

      template&lt;size_t... _Ind, typename... _Args&gt;
	tuple&lt;allocator_arg_t, inner_allocator_type&amp;, _Args&amp;&amp;...&gt;
	_M_construct_p(__uses_alloc1_, _Index_tuple&lt;_Ind...&gt;,
		       tuple&lt;_Args...&gt;&amp; __t)
	{
	  return { allocator_arg, inner_allocator(),
	      std::get&lt;_Ind&gt;(std::move(__t))...
	  };
	}

      template&lt;size_t... _Ind, typename... _Args&gt;
	tuple&lt;_Args&amp;&amp;..., inner_allocator_type&amp;&gt;
	_M_construct_p(__uses_alloc2_, _Index_tuple&lt;_Ind...&gt;,
		       tuple&lt;_Args...&gt;&amp; __t)
	{
	  return { std::get&lt;_Ind&gt;(std::move(__t))..., inner_allocator() };
	}
#endif // ! make_obj_using_allocator
    };

  /// @related std::scoped_allocator_adaptor
  template &lt;typename _OutA1, typename _OutA2, typename... _InA&gt;
    inline bool
    operator==(const scoped_allocator_adaptor&lt;_OutA1, _InA...&gt;&amp; __a,
               const scoped_allocator_adaptor&lt;_OutA2, _InA...&gt;&amp; __b) noexcept
    {
      return __a.outer_allocator() == __b.outer_allocator()
          &amp;&amp; __a._M_inner == __b._M_inner;
    }

#if __cpp_impl_three_way_comparison &lt; 201907L
  /// @related std::scoped_allocator_adaptor
  template &lt;typename _OutA1, typename _OutA2, typename... _InA&gt;
    inline bool
    operator!=(const scoped_allocator_adaptor&lt;_OutA1, _InA...&gt;&amp; __a,
               const scoped_allocator_adaptor&lt;_OutA2, _InA...&gt;&amp; __b) noexcept
    { return !(__a == __b); }
#endif

  /// @}

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // C++11

#endif // _SCOPED_ALLOCATOR
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11'>Back to Directory</a>