The C and C++ Include Header Files

/usr/include/c++/11/ext/extptr_allocator.h


$ cat -n /usr/include/c++/11/ext/extptr_allocator.h

     1	// <extptr_allocator.h> -*- C++ -*-
     2	
     3	// Copyright (C) 2008-2021 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/**
    26	 *  @file ext/extptr_allocator.h
    27	 *  This file is a GNU extension to the Standard C++ Library.
    28	 *
    29	 *  @author Bob Walters
    30	 *
    31	 * An example allocator which uses an alternative pointer type from
    32	 * bits/pointer.h.  Supports test cases which confirm container support
    33	 * for alternative pointers.
    34	 */
    35	
    36	#ifndef _EXTPTR_ALLOCATOR_H
    37	#define _EXTPTR_ALLOCATOR_H 1
    38	
    39	#include <memory>
    40	#include <ext/numeric_traits.h>
    41	#include <ext/pointer.h>
    42	
    43	namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
    44	{
    45	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    46	
    47	  /**
    48	   * @brief An example allocator which uses a non-standard pointer type.
    49	   * @ingroup allocators
    50	   *
    51	   * This allocator specifies that containers use a 'relative pointer' as it's
    52	   * pointer type.  (See ext/pointer.h)  Memory allocation in this example
    53	   * is still performed using std::allocator.
    54	   */
    55	  template<typename _Tp>
    56	    class _ExtPtr_allocator
    57	    {
    58	    public:
    59	      typedef std::size_t     size_type;
    60	      typedef std::ptrdiff_t  difference_type;
    61	
    62	      // Note the non-standard pointer types.
    63	      typedef _Pointer_adapter<_Relative_pointer_impl<_Tp> >       pointer;
    64	      typedef _Pointer_adapter<_Relative_pointer_impl<const _Tp> > 
    65	                                                             const_pointer;
    66	
    67	      typedef _Tp&       reference;
    68	      typedef const _Tp& const_reference;
    69	      typedef _Tp        value_type;
    70	
    71	      template<typename _Up>
    72	        struct rebind
    73	        { typedef _ExtPtr_allocator<_Up> other; };
    74	
    75	      _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT 
    76	      : _M_real_alloc() { }
    77	
    78	      _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT
    79	      : _M_real_alloc(__rarg._M_real_alloc) { }
    80	
    81	      template<typename _Up>
    82	        _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg)
    83		_GLIBCXX_USE_NOEXCEPT
    84	        : _M_real_alloc(__rarg._M_getUnderlyingImp()) { }
    85	
    86	      ~_ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT
    87	      { }
    88	
    89	      pointer address(reference __x) const _GLIBCXX_NOEXCEPT
    90	      { return std::__addressof(__x); }
    91	
    92	      const_pointer address(const_reference __x) const _GLIBCXX_NOEXCEPT
    93	      { return std::__addressof(__x); }
    94	
    95	      _GLIBCXX_NODISCARD pointer allocate(size_type __n, const void* = 0)
    96	      { return _M_real_alloc.allocate(__n); }
    97	
    98	      void deallocate(pointer __p, size_type __n)
    99	      { _M_real_alloc.deallocate(__p.get(), __n); }
   100	
   101	      size_type max_size() const _GLIBCXX_USE_NOEXCEPT
   102	      { return __numeric_traits<size_type>::__max / sizeof(_Tp); }
   103	
   104	#if __cplusplus >= 201103L
   105	      template<typename _Up, typename... _Args>
   106	        void
   107	        construct(_Up* __p, _Args&&... __args)
   108		{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
   109	
   110	      template<typename... _Args>
   111	        void
   112	        construct(pointer __p, _Args&&... __args)
   113		{ construct(__p.get(), std::forward<_Args>(__args)...); }
   114	
   115	      template<typename _Up>
   116	        void 
   117	        destroy(_Up* __p)
   118	        { __p->~_Up(); }
   119	
   120	      void destroy(pointer __p)
   121	      { destroy(__p.get()); }
   122	
   123	#else
   124	
   125	      void construct(pointer __p, const _Tp& __val)
   126	      { ::new(__p.get()) _Tp(__val); }
   127	
   128	      void destroy(pointer __p)
   129	      { __p->~_Tp(); }
   130	#endif
   131	
   132	      template<typename _Up>
   133	        inline bool
   134	        operator==(const _ExtPtr_allocator<_Up>& __rarg) const
   135	        { return _M_real_alloc == __rarg._M_getUnderlyingImp(); }
   136	
   137	      inline bool
   138	      operator==(const _ExtPtr_allocator& __rarg) const
   139	      { return _M_real_alloc == __rarg._M_real_alloc; }
   140	
   141	#if __cpp_impl_three_way_comparison < 201907L
   142	      template<typename _Up>
   143	        inline bool
   144	        operator!=(const _ExtPtr_allocator<_Up>& __rarg) const
   145	        { return _M_real_alloc != __rarg._M_getUnderlyingImp(); }
   146	
   147	      inline bool
   148	      operator!=(const _ExtPtr_allocator& __rarg) const
   149	      { return _M_real_alloc != __rarg._M_real_alloc; }
   150	#endif
   151	
   152	      template<typename _Up>
   153	        inline friend void
   154	        swap(_ExtPtr_allocator<_Up>&, _ExtPtr_allocator<_Up>&);
   155	
   156	      // A method specific to this implementation.
   157	      const std::allocator<_Tp>&
   158	      _M_getUnderlyingImp() const
   159	      { return _M_real_alloc; }
   160	
   161	    private:
   162	      std::allocator<_Tp>  _M_real_alloc;
   163	    };
   164	
   165	  // _ExtPtr_allocator<void> specialization.
   166	  template<>
   167	    class _ExtPtr_allocator<void>
   168	    {
   169	    public:
   170	      typedef std::size_t      size_type;
   171	      typedef std::ptrdiff_t   difference_type;
   172	      typedef void             value_type;
   173	
   174	      // Note the non-standard pointer types
   175	      typedef _Pointer_adapter<_Relative_pointer_impl<void> >       pointer;
   176	      typedef _Pointer_adapter<_Relative_pointer_impl<const void> >
   177	                                                              const_pointer;
   178	
   179	      _ExtPtr_allocator() { }
   180	
   181	      template<typename _Up>
   182		_ExtPtr_allocator(const _ExtPtr_allocator<_Up>&) { }
   183	
   184	      template<typename _Up>
   185	        struct rebind
   186	        { typedef _ExtPtr_allocator<_Up> other; };
   187	
   188	    private:
   189	      std::allocator<void>  _M_real_alloc;
   190	    };
   191	
   192	  template<typename _Tp>
   193	    inline void
   194	    swap(_ExtPtr_allocator<_Tp>& __larg, _ExtPtr_allocator<_Tp>& __rarg)
   195	    {
   196	      std::allocator<_Tp> __tmp( __rarg._M_real_alloc );
   197	      __rarg._M_real_alloc = __larg._M_real_alloc;
   198	      __larg._M_real_alloc = __tmp;
   199	    }
   200	
   201	_GLIBCXX_END_NAMESPACE_VERSION
   202	} // namespace
   203	
   204	#endif /* _EXTPTR_ALLOCATOR_H */