11.2.0/ext/pointer.h

// Custom pointer adapter and sample storage policies

// Copyright (C) 2008-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
// <http://www.gnu.org/licenses/>.

/**
 *  @file ext/pointer.h
 *  This file is a GNU extension to the Standard C++ Library.
 *
 *  @author Bob Walters
 *
 * Provides reusable _Pointer_adapter for assisting in the development of
 * custom pointer types that can be used with the standard containers via
 * the allocator::pointer and allocator::const_pointer typedefs.
 */

#ifndef _POINTER_H
#define _POINTER_H 1

#pragma GCC system_header

#include <iosfwd>
#include <bits/stl_iterator_base_types.h>
#include <ext/cast.h>
#include <ext/type_traits.h>
#if __cplusplus >= 201103L
# include <bits/move.h>
# include <bits/ptr_traits.h>
#endif
#if __cplusplus > 201703L
# include <iterator> // for indirectly_readable_traits
#endif

namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /** 
   * @brief A storage policy for use with _Pointer_adapter<> which yields a
   *        standard pointer.
   * 
   *  A _Storage_policy is required to provide 4 things:
   *    1) A get() API for returning the stored pointer value.
   *    2) An set() API for storing a pointer value.
   *    3) An element_type typedef to define the type this points to.
   *    4) An operator<() to support pointer comparison.
   *    5) An operator==() to support pointer comparison.
   */
  template<typename _Tp> 
    class _Std_pointer_impl 
    {
    public:
      // the type this pointer points to.
      typedef _Tp element_type;
  
      // A method to fetch the pointer value as a standard T* value;
      inline _Tp* 
      get() const 
      { return _M_value; }
  
      // A method to set the pointer value, from a standard T* value;
      inline void 
      set(element_type* __arg) 
      { _M_value = __arg; }
  
      // Comparison of pointers
      inline bool
      operator<(const _Std_pointer_impl& __rarg) const
      { return (_M_value < __rarg._M_value); }
  
      inline bool
      operator==(const _Std_pointer_impl& __rarg) const
      { return (_M_value == __rarg._M_value); }

    private:
      element_type* _M_value;
    };

  /**
   * @brief A storage policy for use with _Pointer_adapter<> which stores
   *        the pointer's address as an offset value which is relative to
   *        its own address.
   * 
   * This is intended for pointers within shared memory regions which
   * might be mapped at different addresses by different processes.
   * For null pointers, a value of 1 is used.  (0 is legitimate
   * sometimes for nodes in circularly linked lists) This value was
   * chosen as the least likely to generate an incorrect null, As
   * there is no reason why any normal pointer would point 1 byte into
   * its own pointer address.
   */
  template<typename _Tp> 
    class _Relative_pointer_impl 
    {
    public:
      typedef _Tp element_type;
  
      _Tp*
      get() const 
      {
        if (_M_diff == 1)
          return 0;
        else
          return reinterpret_cast<_Tp*>(reinterpret_cast<_UIntPtrType>(this)
                                        + _M_diff);
      }
  
      void 
      set(_Tp* __arg)
      {
        if (!__arg)
          _M_diff = 1;
        else
          _M_diff = reinterpret_cast<_UIntPtrType>(__arg) 
                    - reinterpret_cast<_UIntPtrType>(this);
      }
  
      // Comparison of pointers
      inline bool
      operator<(const _Relative_pointer_impl& __rarg) const
      { return (reinterpret_cast<_UIntPtrType>(this->get())
                < reinterpret_cast<_UIntPtrType>(__rarg.get())); }

      inline bool
      operator==(const _Relative_pointer_impl& __rarg) const
      { return (reinterpret_cast<_UIntPtrType>(this->get())
                == reinterpret_cast<_UIntPtrType>(__rarg.get())); }

    private:
#ifdef _GLIBCXX_USE_LONG_LONG
      typedef __gnu_cxx::__conditional_type<
         (sizeof(unsigned long) >= sizeof(void*)),
         unsigned long, unsigned long long>::__type _UIntPtrType;
#else
      typedef unsigned long _UIntPtrType;
#endif
      _UIntPtrType _M_diff;
    };
  
  /**
   * Relative_pointer_impl needs a specialization for const T because of
   * the casting done during pointer arithmetic.
   */
  template<typename _Tp> 
    class _Relative_pointer_impl<const _Tp> 
    {
    public:
      typedef const _Tp element_type;
  
      const _Tp*
      get() const
      {
        if (_M_diff == 1)
          return 0;
        else
          return reinterpret_cast<const _Tp*>
              (reinterpret_cast<_UIntPtrType>(this) + _M_diff);
      }
  
      void 
      set(const _Tp* __arg)
      {
        if (!__arg)
          _M_diff = 1;
        else
          _M_diff = reinterpret_cast<_UIntPtrType>(__arg) 
                    - reinterpret_cast<_UIntPtrType>(this);
      }
  
      // Comparison of pointers
      inline bool
      operator<(const _Relative_pointer_impl& __rarg) const
      { return (reinterpret_cast<_UIntPtrType>(this->get())
                < reinterpret_cast<_UIntPtrType>(__rarg.get())); }

      inline bool
      operator==(const _Relative_pointer_impl& __rarg) const
      { return (reinterpret_cast<_UIntPtrType>(this->get())
                == reinterpret_cast<_UIntPtrType>(__rarg.get())); }
  
    private:
#ifdef _GLIBCXX_USE_LONG_LONG
      typedef __gnu_cxx::__conditional_type<
         (sizeof(unsigned long) >= sizeof(void*)),
         unsigned long, unsigned long long>::__type _UIntPtrType;
#else
      typedef unsigned long _UIntPtrType;
#endif
       _UIntPtrType _M_diff;
    };

  /**
   * The specialization on this type helps resolve the problem of
   * reference to void, and eliminates the need to specialize
   * _Pointer_adapter for cases of void*, const void*, and so on.
   */
  struct _Invalid_type { };
  
  template<typename _Tp>
    struct _Reference_type 
    { typedef _Tp& reference; };

  template<> 
    struct _Reference_type<void> 
    { typedef _Invalid_type& reference; };

  template<> 
    struct _Reference_type<const void> 
    { typedef const _Invalid_type& reference; };

  template<> 
    struct _Reference_type<volatile void> 
    { typedef volatile _Invalid_type&  reference; };

  template<> 
    struct _Reference_type<volatile const void> 
    { typedef const volatile _Invalid_type&  reference; };

  /**
   * This structure accommodates the way in which
   * std::iterator_traits<> is normally specialized for const T*, so
   * that value_type is still T.
   */
  template<typename _Tp> 
    struct _Unqualified_type 
    { typedef _Tp type; };
    
  template<typename _Tp> 
    struct _Unqualified_type<const _Tp> 
    { typedef _Tp type; };
    
  /**
   * The following provides an 'alternative pointer' that works with
   * the containers when specified as the pointer typedef of the
   * allocator.
   *
   * The pointer type used with the containers doesn't have to be this
   * class, but it must support the implicit conversions, pointer
   * arithmetic, comparison operators, etc. that are supported by this
   * class, and avoid raising compile-time ambiguities.  Because
   * creating a working pointer can be challenging, this pointer
   * template was designed to wrapper an easier storage policy type,
   * so that it becomes reusable for creating other pointer types.
   *
   * A key point of this class is also that it allows container
   * writers to 'assume' Allocator::pointer is a typedef for a normal
   * pointer.  This class supports most of the conventions of a true
   * pointer, and can, for instance handle implicit conversion to
   * const and base class pointer types.  The only impositions on
   * container writers to support extended pointers are: 1) use the
   * Allocator::pointer typedef appropriately for pointer types.  2)
   * if you need pointer casting, use the __pointer_cast<> functions
   * from ext/cast.h.  This allows pointer cast operations to be
   * overloaded as necessary by custom pointers.
   *
   * Note: The const qualifier works with this pointer adapter as
   * follows:
   *
   * _Tp*             == _Pointer_adapter<_Std_pointer_impl<_Tp> >;
   * const _Tp*       == _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
   * _Tp* const       == const _Pointer_adapter<_Std_pointer_impl<_Tp> >;
   * const _Tp* const == const _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
   */
  template<typename _Storage_policy>
    class _Pointer_adapter : public _Storage_policy 
    {
    public:
      typedef typename _Storage_policy::element_type element_type;

      // These are needed for iterator_traits
      typedef std::random_access_iterator_tag                iterator_category;
      typedef typename _Unqualified_type<element_type>::type value_type;
      typedef std::ptrdiff_t                                 difference_type;
      typedef _Pointer_adapter                               pointer;
      typedef typename _Reference_type<element_type>::reference  reference;

      // Reminder: 'const' methods mean that the method is valid when the 
      // pointer is immutable, and has nothing to do with whether the 
      // 'pointee' is const.

      // Default Constructor (Convert from element_type*)
      _Pointer_adapter(element_type* __arg = 0)
      { _Storage_policy::set(__arg); }

      // Copy constructor from _Pointer_adapter of same type.
      _Pointer_adapter(const _Pointer_adapter& __arg) 
      { _Storage_policy::set(__arg.get()); }

      // Convert from _Up* if conversion to element_type* is valid.
      template<typename _Up>
        _Pointer_adapter(_Up* __arg)
        { _Storage_policy::set(__arg); }

      // Conversion from another _Pointer_adapter if _Up if static cast is
      // valid.
      template<typename _Up>
        _Pointer_adapter(const _Pointer_adapter<_Up>& __arg)
        { _Storage_policy::set(__arg.get()); }

      // Destructor
      ~_Pointer_adapter() { }
  
      // Assignment operator
      _Pointer_adapter&
      operator=(const _Pointer_adapter& __arg) 
      {
        _Storage_policy::set(__arg.get()); 
        return *this; 
      }

      template<typename _Up>
        _Pointer_adapter&
        operator=(const _Pointer_adapter<_Up>& __arg)
        {
          _Storage_policy::set(__arg.get()); 
          return *this; 
        }

      template<typename _Up>
        _Pointer_adapter&
        operator=(_Up* __arg)
        {
          _Storage_policy::set(__arg); 
          return *this; 
        }

      // Operator*, returns element_type&
      inline reference 
      operator*() const 
      { return *(_Storage_policy::get()); }

      // Operator->, returns element_type*
      inline element_type* 
      operator->() const 
      { return _Storage_policy::get(); }

      // Operator[], returns a element_type& to the item at that loc.
      inline reference
      operator[](std::ptrdiff_t __index) const
      { return _Storage_policy::get()[__index]; }

      // To allow implicit conversion to "bool", for "if (ptr)..."
#if __cplusplus >= 201103L
      explicit operator bool() const { return _Storage_policy::get() != 0; }
#else
    private:
      typedef element_type*(_Pointer_adapter::*__unspecified_bool_type)() const;

    public:
      operator __unspecified_bool_type() const
      {
        return _Storage_policy::get() == 0 ? 0 : 
                         &_Pointer_adapter::operator->; 
      }

      // ! operator (for: if (!ptr)...)
      inline bool
      operator!() const 
      { return (_Storage_policy::get() == 0); }
#endif
  
      // Pointer differences
      inline friend std::ptrdiff_t 
      operator-(const _Pointer_adapter& __lhs, element_type* __rhs) 
      { return (__lhs.get() - __rhs); }
  
      inline friend std::ptrdiff_t 
      operator-(element_type* __lhs, const _Pointer_adapter& __rhs) 
      { return (__lhs - __rhs.get()); }
  
      template<typename _Up>
        inline friend std::ptrdiff_t 
        operator-(const _Pointer_adapter& __lhs, _Up* __rhs) 
        { return (__lhs.get() - __rhs); }
    
      template<typename _Up>
        inline friend std::ptrdiff_t 
        operator-(_Up* __lhs, const _Pointer_adapter& __rhs)
        { return (__lhs - __rhs.get()); }

      template<typename _Up>
        inline std::ptrdiff_t 
        operator-(const _Pointer_adapter<_Up>& __rhs) const 
        { return (_Storage_policy::get() - __rhs.get()); }
  
      // Pointer math
      // Note: There is a reason for all this overloading based on different
      // integer types.  In some libstdc++-v3 test cases, a templated
      // operator+ is declared which can match any types.  This operator
      // tends to "steal" the recognition of _Pointer_adapter's own operator+ 
      // unless the integer type matches perfectly.

#define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
      inline friend _Pointer_adapter \
      operator+(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
      { return _Pointer_adapter(__lhs.get() + __offset); } \
\
      inline friend _Pointer_adapter \
      operator+(INT_TYPE __offset, const _Pointer_adapter& __rhs) \
      { return _Pointer_adapter(__rhs.get() + __offset); } \
\
      inline friend _Pointer_adapter \
      operator-(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
      { return _Pointer_adapter(__lhs.get() - __offset); } \
\
      inline _Pointer_adapter& \
      operator+=(INT_TYPE __offset) \
      { \
        _Storage_policy::set(_Storage_policy::get() + __offset); \
        return *this; \
      } \
\
      inline _Pointer_adapter& \
      operator-=(INT_TYPE __offset) \
      { \
        _Storage_policy::set(_Storage_policy::get() - __offset); \
        return *this; \
      } \
// END of _CXX_POINTER_ARITH_OPERATOR_SET macro
  
      // Expand into the various pointer arithmetic operators needed.
      _CXX_POINTER_ARITH_OPERATOR_SET(short);
      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned short);
      _CXX_POINTER_ARITH_OPERATOR_SET(int);
      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned int);
      _CXX_POINTER_ARITH_OPERATOR_SET(long);
      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned long);
#ifdef _GLIBCXX_USE_LONG_LONG
      _CXX_POINTER_ARITH_OPERATOR_SET(long long);
      _CXX_POINTER_ARITH_OPERATOR_SET(unsigned long long);
#endif

      // Mathematical Manipulators
      inline _Pointer_adapter& 
      operator++()
      {
        _Storage_policy::set(_Storage_policy::get() + 1); 
        return *this;
      }
  
      inline _Pointer_adapter 
      operator++(int)
      {
        _Pointer_adapter __tmp(*this);
        _Storage_policy::set(_Storage_policy::get() + 1);
        return __tmp;
      }
  
      inline _Pointer_adapter& 
      operator--() 
      {
        _Storage_policy::set(_Storage_policy::get() - 1); 
        return *this;
      }
  
      inline _Pointer_adapter
      operator--(int) 
      {
        _Pointer_adapter __tmp(*this);
        _Storage_policy::set(_Storage_policy::get() - 1);
        return __tmp;
      }

#if __cpp_lib_three_way_comparison
      friend std::strong_ordering
      operator<=>(const _Pointer_adapter& __lhs, const _Pointer_adapter& __rhs)
      noexcept
      { return __lhs.get() <=> __rhs.get(); }
#endif
    }; // class _Pointer_adapter


#define _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(OPERATOR) \
  template<typename _Tp1, typename _Tp2> \
    inline bool \
    operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, _Tp2 __rhs) \
    { return __lhs.get() OPERATOR __rhs; } \
\
  template<typename _Tp1, typename _Tp2> \
    inline bool \
    operator OPERATOR(_Tp1 __lhs, const _Pointer_adapter<_Tp2>& __rhs) \
    { return __lhs OPERATOR __rhs.get(); } \
\
  template<typename _Tp1, typename _Tp2> \
    inline bool \
    operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, \
                              const _Pointer_adapter<_Tp2>& __rhs) \
    { return __lhs.get() OPERATOR __rhs.get(); } \
\
// End GCC_CXX_POINTER_COMPARISON_OPERATION_SET Macro
  
  // Expand into the various comparison operators needed.
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<)
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<=)
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>)
  _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>=)

  // These are here for expressions like "ptr == 0", "ptr != 0"
  template<typename _Tp>
    inline bool
    operator==(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
    { return __lhs.get() == reinterpret_cast<void*>(__rhs); } 

  template<typename _Tp>
    inline bool
    operator==(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
    { return __rhs.get() == reinterpret_cast<void*>(__lhs); } 

  template<typename _Tp>
    inline bool
    operator!=(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
    { return __lhs.get() != reinterpret_cast<void*>(__rhs); } 

  template<typename _Tp>
    inline bool
    operator!=(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
    { return __rhs.get() != reinterpret_cast<void*>(__lhs); } 

  /**
   * Comparison operators for _Pointer_adapter defer to the base class'
   * comparison operators, when possible.
   */
  template<typename _Tp>
    inline bool
    operator==(const _Pointer_adapter<_Tp>& __lhs, 
               const _Pointer_adapter<_Tp>& __rhs)
    { return __lhs._Tp::operator==(__rhs); }

  template<typename _Tp>
    inline bool
    operator<=(const _Pointer_adapter<_Tp>& __lhs, 
               const _Pointer_adapter<_Tp>& __rhs)
    { return __lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs); }

  template<typename _Tp>
    inline bool
    operator!=(const _Pointer_adapter<_Tp>& __lhs, 
               const _Pointer_adapter<_Tp>& __rhs)
    { return !(__lhs._Tp::operator==(__rhs)); }

  template<typename _Tp>
    inline bool
    operator>(const _Pointer_adapter<_Tp>& __lhs, 
              const _Pointer_adapter<_Tp>& __rhs)
    { return !(__lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs)); }

  template<typename _Tp>
    inline bool
    operator>=(const _Pointer_adapter<_Tp>& __lhs, 
               const _Pointer_adapter<_Tp>& __rhs)
    { return !(__lhs._Tp::operator<(__rhs)); }

  template<typename _CharT, typename _Traits, typename _StoreT>
    inline std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os, 
               const _Pointer_adapter<_StoreT>& __p)
    { return (__os << __p.get()); }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#if __cplusplus >= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _Storage_policy>
    struct pointer_traits<__gnu_cxx::_Pointer_adapter<_Storage_policy>>
    {
      /// The pointer type
      typedef __gnu_cxx::_Pointer_adapter<_Storage_policy>         pointer;
      /// The type pointed to
      typedef typename pointer::element_type            element_type;
      /// Type used to represent the difference between two pointers
      typedef typename pointer::difference_type         difference_type;

      template<typename _Up>
        using rebind = typename __gnu_cxx::_Pointer_adapter<
        typename pointer_traits<_Storage_policy>::template rebind<_Up>>;

      static pointer pointer_to(typename pointer::reference __r) noexcept
      { return pointer(std::addressof(__r)); }
    };

#if __cpp_lib_concepts
  template<typename _Policy>
    struct indirectly_readable_traits<__gnu_cxx::_Pointer_adapter<_Policy>>
    {
      using value_type
        = typename __gnu_cxx::_Pointer_adapter<_Policy>::value_type;
    };
#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif

#endif // _POINTER_H
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	20480 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// Custom pointer adapter and sample storage policies
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/pointer.h
27	* This file is a GNU extension to the Standard C++ Library.
28	*
29	* @author Bob Walters
30	*
31	* Provides reusable _Pointer_adapter for assisting in the development of
32	* custom pointer types that can be used with the standard containers via
33	* the allocator::pointer and allocator::const_pointer typedefs.
34	*/
35
36	#ifndef _POINTER_H
37	#define _POINTER_H 1
38
39	#pragma GCC system_header
40
41	#include <iosfwd>
42	#include <bits/stl_iterator_base_types.h>
43	#include <ext/cast.h>
44	#include <ext/type_traits.h>
45	#if __cplusplus >= 201103L
46	# include <bits/move.h>
47	# include <bits/ptr_traits.h>
48	#endif
49	#if __cplusplus > 201703L
50	# include <iterator> // for indirectly_readable_traits
51	#endif
52
53	namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
54	{
55	_GLIBCXX_BEGIN_NAMESPACE_VERSION
56
57	/**
58	* @brief A storage policy for use with _Pointer_adapter<> which yields a
59	* standard pointer.
60	*
61	* A _Storage_policy is required to provide 4 things:
62	* 1) A get() API for returning the stored pointer value.
63	* 2) An set() API for storing a pointer value.
64	* 3) An element_type typedef to define the type this points to.
65	* 4) An operator<() to support pointer comparison.
66	* 5) An operator==() to support pointer comparison.
67	*/
68	template<typename _Tp>
69	class _Std_pointer_impl
70	{
71	public:
72	// the type this pointer points to.
73	typedef _Tp element_type;
74
75	// A method to fetch the pointer value as a standard T* value;
76	inline _Tp*
77	get() const
78	{ return _M_value; }
79
80	// A method to set the pointer value, from a standard T* value;
81	inline void
82	set(element_type* __arg)
83	{ _M_value = __arg; }
84
85	// Comparison of pointers
86	inline bool
87	operator<(const _Std_pointer_impl& __rarg) const
88	{ return (_M_value < __rarg._M_value); }
89
90	inline bool
91	operator==(const _Std_pointer_impl& __rarg) const
92	{ return (_M_value == __rarg._M_value); }
93
94	private:
95	element_type* _M_value;
96	};
97
98	/**
99	* @brief A storage policy for use with _Pointer_adapter<> which stores
100	* the pointer's address as an offset value which is relative to
101	* its own address.
102	*
103	* This is intended for pointers within shared memory regions which
104	* might be mapped at different addresses by different processes.
105	* For null pointers, a value of 1 is used. (0 is legitimate
106	* sometimes for nodes in circularly linked lists) This value was
107	* chosen as the least likely to generate an incorrect null, As
108	* there is no reason why any normal pointer would point 1 byte into
109	* its own pointer address.
110	*/
111	template<typename _Tp>
112	class _Relative_pointer_impl
113	{
114	public:
115	typedef _Tp element_type;
116
117	_Tp*
118	get() const
119	{
120	if (_M_diff == 1)
121	return 0;
122	else
123	return reinterpret_cast<_Tp*>(reinterpret_cast<_UIntPtrType>(this)
124	+ _M_diff);
125	}
126
127	void
128	set(_Tp* __arg)
129	{
130	if (!__arg)
131	_M_diff = 1;
132	else
133	_M_diff = reinterpret_cast<_UIntPtrType>(__arg)
134	- reinterpret_cast<_UIntPtrType>(this);
135	}
136
137	// Comparison of pointers
138	inline bool
139	operator<(const _Relative_pointer_impl& __rarg) const
140	{ return (reinterpret_cast<_UIntPtrType>(this->get())
141	< reinterpret_cast<_UIntPtrType>(__rarg.get())); }
142
143	inline bool
144	operator==(const _Relative_pointer_impl& __rarg) const
145	{ return (reinterpret_cast<_UIntPtrType>(this->get())
146	== reinterpret_cast<_UIntPtrType>(__rarg.get())); }
147
148	private:
149	#ifdef _GLIBCXX_USE_LONG_LONG
150	typedef __gnu_cxx::__conditional_type<
151	(sizeof(unsigned long) >= sizeof(void*)),
152	unsigned long, unsigned long long>::__type _UIntPtrType;
153	#else
154	typedef unsigned long _UIntPtrType;
155	#endif
156	_UIntPtrType _M_diff;
157	};
158
159	/**
160	* Relative_pointer_impl needs a specialization for const T because of
161	* the casting done during pointer arithmetic.
162	*/
163	template<typename _Tp>
164	class _Relative_pointer_impl<const _Tp>
165	{
166	public:
167	typedef const _Tp element_type;
168
169	const _Tp*
170	get() const
171	{
172	if (_M_diff == 1)
173	return 0;
174	else
175	return reinterpret_cast<const _Tp*>
176	(reinterpret_cast<_UIntPtrType>(this) + _M_diff);
177	}
178
179	void
180	set(const _Tp* __arg)
181	{
182	if (!__arg)
183	_M_diff = 1;
184	else
185	_M_diff = reinterpret_cast<_UIntPtrType>(__arg)
186	- reinterpret_cast<_UIntPtrType>(this);
187	}
188
189	// Comparison of pointers
190	inline bool
191	operator<(const _Relative_pointer_impl& __rarg) const
192	{ return (reinterpret_cast<_UIntPtrType>(this->get())
193	< reinterpret_cast<_UIntPtrType>(__rarg.get())); }
194
195	inline bool
196	operator==(const _Relative_pointer_impl& __rarg) const
197	{ return (reinterpret_cast<_UIntPtrType>(this->get())
198	== reinterpret_cast<_UIntPtrType>(__rarg.get())); }
199
200	private:
201	#ifdef _GLIBCXX_USE_LONG_LONG
202	typedef __gnu_cxx::__conditional_type<
203	(sizeof(unsigned long) >= sizeof(void*)),
204	unsigned long, unsigned long long>::__type _UIntPtrType;
205	#else
206	typedef unsigned long _UIntPtrType;
207	#endif
208	_UIntPtrType _M_diff;
209	};
210
211	/**
212	* The specialization on this type helps resolve the problem of
213	* reference to void, and eliminates the need to specialize
214	* _Pointer_adapter for cases of void, const void, and so on.
215	*/
216	struct _Invalid_type { };
217
218	template<typename _Tp>
219	struct _Reference_type
220	{ typedef _Tp& reference; };
221
222	template<>
223	struct _Reference_type<void>
224	{ typedef _Invalid_type& reference; };
225
226	template<>
227	struct _Reference_type<const void>
228	{ typedef const _Invalid_type& reference; };
229
230	template<>
231	struct _Reference_type<volatile void>
232	{ typedef volatile _Invalid_type& reference; };
233
234	template<>
235	struct _Reference_type<volatile const void>
236	{ typedef const volatile _Invalid_type& reference; };
237
238	/**
239	* This structure accommodates the way in which
240	* std::iterator_traits<> is normally specialized for const T*, so
241	* that value_type is still T.
242	*/
243	template<typename _Tp>
244	struct _Unqualified_type
245	{ typedef _Tp type; };
246
247	template<typename _Tp>
248	struct _Unqualified_type<const _Tp>
249	{ typedef _Tp type; };
250
251	/**
252	* The following provides an 'alternative pointer' that works with
253	* the containers when specified as the pointer typedef of the
254	* allocator.
255	*
256	* The pointer type used with the containers doesn't have to be this
257	* class, but it must support the implicit conversions, pointer
258	* arithmetic, comparison operators, etc. that are supported by this
259	* class, and avoid raising compile-time ambiguities. Because
260	* creating a working pointer can be challenging, this pointer
261	* template was designed to wrapper an easier storage policy type,
262	* so that it becomes reusable for creating other pointer types.
263	*
264	* A key point of this class is also that it allows container
265	* writers to 'assume' Allocator::pointer is a typedef for a normal
266	* pointer. This class supports most of the conventions of a true
267	* pointer, and can, for instance handle implicit conversion to
268	* const and base class pointer types. The only impositions on
269	* container writers to support extended pointers are: 1) use the
270	* Allocator::pointer typedef appropriately for pointer types. 2)
271	* if you need pointer casting, use the __pointer_cast<> functions
272	* from ext/cast.h. This allows pointer cast operations to be
273	* overloaded as necessary by custom pointers.
274	*
275	* Note: The const qualifier works with this pointer adapter as
276	* follows:
277	*
278	* _Tp* == _Pointer_adapter<_Std_pointer_impl<_Tp> >;
279	* const _Tp* == _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
280	* _Tp* const == const _Pointer_adapter<_Std_pointer_impl<_Tp> >;
281	* const _Tp* const == const _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
282	*/
283	template<typename _Storage_policy>
284	class _Pointer_adapter : public _Storage_policy
285	{
286	public:
287	typedef typename _Storage_policy::element_type element_type;
288
289	// These are needed for iterator_traits
290	typedef std::random_access_iterator_tag iterator_category;
291	typedef typename _Unqualified_type<element_type>::type value_type;
292	typedef std::ptrdiff_t difference_type;
293	typedef _Pointer_adapter pointer;
294	typedef typename _Reference_type<element_type>::reference reference;
295
296	// Reminder: 'const' methods mean that the method is valid when the
297	// pointer is immutable, and has nothing to do with whether the
298	// 'pointee' is const.
299
300	// Default Constructor (Convert from element_type*)
301	_Pointer_adapter(element_type* __arg = 0)
302	{ _Storage_policy::set(__arg); }
303
304	// Copy constructor from _Pointer_adapter of same type.
305	_Pointer_adapter(const _Pointer_adapter& __arg)
306	{ _Storage_policy::set(__arg.get()); }
307
308	// Convert from _Up* if conversion to element_type* is valid.
309	template<typename _Up>
310	_Pointer_adapter(_Up* __arg)
311	{ _Storage_policy::set(__arg); }
312
313	// Conversion from another _Pointer_adapter if _Up if static cast is
314	// valid.
315	template<typename _Up>
316	_Pointer_adapter(const _Pointer_adapter<_Up>& __arg)
317	{ _Storage_policy::set(__arg.get()); }
318
319	// Destructor
320	~_Pointer_adapter() { }
321
322	// Assignment operator
323	_Pointer_adapter&
324	operator=(const _Pointer_adapter& __arg)
325	{
326	_Storage_policy::set(__arg.get());
327	return *this;
328	}
329
330	template<typename _Up>
331	_Pointer_adapter&
332	operator=(const _Pointer_adapter<_Up>& __arg)
333	{
334	_Storage_policy::set(__arg.get());
335	return *this;
336	}
337
338	template<typename _Up>
339	_Pointer_adapter&
340	operator=(_Up* __arg)
341	{
342	_Storage_policy::set(__arg);
343	return *this;
344	}
345
346	// Operator*, returns element_type&
347	inline reference
348	operator*() const
349	{ return *(_Storage_policy::get()); }
350
351	// Operator->, returns element_type*
352	inline element_type*
353	operator->() const
354	{ return _Storage_policy::get(); }
355
356	// Operator[], returns a element_type& to the item at that loc.
357	inline reference
358	operator[](std::ptrdiff_t __index) const
359	{ return _Storage_policy::get()[__index]; }
360
361	// To allow implicit conversion to "bool", for "if (ptr)..."
362	#if __cplusplus >= 201103L
363	explicit operator bool() const { return _Storage_policy::get() != 0; }
364	#else
365	private:
366	typedef element_type(_Pointer_adapter::__unspecified_bool_type)() const;
367
368	public:
369	operator __unspecified_bool_type() const
370	{
371	return _Storage_policy::get() == 0 ? 0 :
372	&_Pointer_adapter::operator->;
373	}
374
375	// ! operator (for: if (!ptr)...)
376	inline bool
377	operator!() const
378	{ return (_Storage_policy::get() == 0); }
379	#endif
380
381	// Pointer differences
382	inline friend std::ptrdiff_t
383	operator-(const _Pointer_adapter& __lhs, element_type* __rhs)
384	{ return (__lhs.get() - __rhs); }
385
386	inline friend std::ptrdiff_t
387	operator-(element_type* __lhs, const _Pointer_adapter& __rhs)
388	{ return (__lhs - __rhs.get()); }
389
390	template<typename _Up>
391	inline friend std::ptrdiff_t
392	operator-(const _Pointer_adapter& __lhs, _Up* __rhs)
393	{ return (__lhs.get() - __rhs); }
394
395	template<typename _Up>
396	inline friend std::ptrdiff_t
397	operator-(_Up* __lhs, const _Pointer_adapter& __rhs)
398	{ return (__lhs - __rhs.get()); }
399
400	template<typename _Up>
401	inline std::ptrdiff_t
402	operator-(const _Pointer_adapter<_Up>& __rhs) const
403	{ return (_Storage_policy::get() - __rhs.get()); }
404
405	// Pointer math
406	// Note: There is a reason for all this overloading based on different
407	// integer types. In some libstdc++-v3 test cases, a templated
408	// operator+ is declared which can match any types. This operator
409	// tends to "steal" the recognition of _Pointer_adapter's own operator+
410	// unless the integer type matches perfectly.
411
412	#define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
413	inline friend _Pointer_adapter \
414	operator+(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
415	{ return _Pointer_adapter(__lhs.get() + __offset); } \
416	\
417	inline friend _Pointer_adapter \
418	operator+(INT_TYPE __offset, const _Pointer_adapter& __rhs) \
419	{ return _Pointer_adapter(__rhs.get() + __offset); } \
420	\
421	inline friend _Pointer_adapter \
422	operator-(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
423	{ return _Pointer_adapter(__lhs.get() - __offset); } \
424	\
425	inline _Pointer_adapter& \
426	operator+=(INT_TYPE __offset) \
427	{ \
428	_Storage_policy::set(_Storage_policy::get() + __offset); \
429	return *this; \
430	} \
431	\
432	inline _Pointer_adapter& \
433	operator-=(INT_TYPE __offset) \
434	{ \
435	_Storage_policy::set(_Storage_policy::get() - __offset); \
436	return *this; \
437	} \
438	// END of _CXX_POINTER_ARITH_OPERATOR_SET macro
439
440	// Expand into the various pointer arithmetic operators needed.
441	_CXX_POINTER_ARITH_OPERATOR_SET(short);
442	_CXX_POINTER_ARITH_OPERATOR_SET(unsigned short);
443	_CXX_POINTER_ARITH_OPERATOR_SET(int);
444	_CXX_POINTER_ARITH_OPERATOR_SET(unsigned int);
445	_CXX_POINTER_ARITH_OPERATOR_SET(long);
446	_CXX_POINTER_ARITH_OPERATOR_SET(unsigned long);
447	#ifdef _GLIBCXX_USE_LONG_LONG
448	_CXX_POINTER_ARITH_OPERATOR_SET(long long);
449	_CXX_POINTER_ARITH_OPERATOR_SET(unsigned long long);
450	#endif
451
452	// Mathematical Manipulators
453	inline _Pointer_adapter&
454	operator++()
455	{
456	_Storage_policy::set(_Storage_policy::get() + 1);
457	return *this;
458	}
459
460	inline _Pointer_adapter
461	operator++(int)
462	{
463	_Pointer_adapter __tmp(*this);
464	_Storage_policy::set(_Storage_policy::get() + 1);
465	return __tmp;
466	}
467
468	inline _Pointer_adapter&
469	operator--()
470	{
471	_Storage_policy::set(_Storage_policy::get() - 1);
472	return *this;
473	}
474
475	inline _Pointer_adapter
476	operator--(int)
477	{
478	_Pointer_adapter __tmp(*this);
479	_Storage_policy::set(_Storage_policy::get() - 1);
480	return __tmp;
481	}
482
483	#if __cpp_lib_three_way_comparison
484	friend std::strong_ordering
485	operator<=>(const _Pointer_adapter& __lhs, const _Pointer_adapter& __rhs)
486	noexcept
487	{ return __lhs.get() <=> __rhs.get(); }
488	#endif
489	}; // class _Pointer_adapter
490
491
492	#define _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(OPERATOR) \
493	template<typename _Tp1, typename _Tp2> \
494	inline bool \
495	operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, _Tp2 __rhs) \
496	{ return __lhs.get() OPERATOR __rhs; } \
497	\
498	template<typename _Tp1, typename _Tp2> \
499	inline bool \
500	operator OPERATOR(_Tp1 __lhs, const _Pointer_adapter<_Tp2>& __rhs) \
501	{ return __lhs OPERATOR __rhs.get(); } \
502	\
503	template<typename _Tp1, typename _Tp2> \
504	inline bool \
505	operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, \
506	const _Pointer_adapter<_Tp2>& __rhs) \
507	{ return __lhs.get() OPERATOR __rhs.get(); } \
508	\
509	// End GCC_CXX_POINTER_COMPARISON_OPERATION_SET Macro
510
511	// Expand into the various comparison operators needed.
512	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
513	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
514	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<)
515	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<=)
516	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>)
517	_GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>=)
518
519	// These are here for expressions like "ptr == 0", "ptr != 0"
520	template<typename _Tp>
521	inline bool
522	operator==(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
523	{ return __lhs.get() == reinterpret_cast<void*>(__rhs); }
524
525	template<typename _Tp>
526	inline bool
527	operator==(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
528	{ return __rhs.get() == reinterpret_cast<void*>(__lhs); }
529
530	template<typename _Tp>
531	inline bool
532	operator!=(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
533	{ return __lhs.get() != reinterpret_cast<void*>(__rhs); }
534
535	template<typename _Tp>
536	inline bool
537	operator!=(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
538	{ return __rhs.get() != reinterpret_cast<void*>(__lhs); }
539
540	/**
541	* Comparison operators for _Pointer_adapter defer to the base class'
542	* comparison operators, when possible.
543	*/
544	template<typename _Tp>
545	inline bool
546	operator==(const _Pointer_adapter<_Tp>& __lhs,
547	const _Pointer_adapter<_Tp>& __rhs)
548	{ return __lhs._Tp::operator==(__rhs); }
549
550	template<typename _Tp>
551	inline bool
552	operator<=(const _Pointer_adapter<_Tp>& __lhs,
553	const _Pointer_adapter<_Tp>& __rhs)
554	{ return __lhs._Tp::operator<(__rhs) \|\| __lhs._Tp::operator==(__rhs); }
555
556	template<typename _Tp>
557	inline bool
558	operator!=(const _Pointer_adapter<_Tp>& __lhs,
559	const _Pointer_adapter<_Tp>& __rhs)
560	{ return !(__lhs._Tp::operator==(__rhs)); }
561
562	template<typename _Tp>
563	inline bool
564	operator>(const _Pointer_adapter<_Tp>& __lhs,
565	const _Pointer_adapter<_Tp>& __rhs)
566	{ return !(__lhs._Tp::operator<(__rhs) \|\| __lhs._Tp::operator==(__rhs)); }
567
568	template<typename _Tp>
569	inline bool
570	operator>=(const _Pointer_adapter<_Tp>& __lhs,
571	const _Pointer_adapter<_Tp>& __rhs)
572	{ return !(__lhs._Tp::operator<(__rhs)); }
573
574	template<typename _CharT, typename _Traits, typename _StoreT>
575	inline std::basic_ostream<_CharT, _Traits>&
576	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
577	const _Pointer_adapter<_StoreT>& __p)
578	{ return (__os << __p.get()); }
579
580	_GLIBCXX_END_NAMESPACE_VERSION
581	} // namespace
582
583	#if __cplusplus >= 201103L
584	namespace std _GLIBCXX_VISIBILITY(default)
585	{
586	_GLIBCXX_BEGIN_NAMESPACE_VERSION
587
588	template<typename _Storage_policy>
589	struct pointer_traits<__gnu_cxx::_Pointer_adapter<_Storage_policy>>
590	{
591	/// The pointer type
592	typedef __gnu_cxx::_Pointer_adapter<_Storage_policy> pointer;
593	/// The type pointed to
594	typedef typename pointer::element_type element_type;
595	/// Type used to represent the difference between two pointers
596	typedef typename pointer::difference_type difference_type;
597
598	template<typename _Up>
599	using rebind = typename __gnu_cxx::_Pointer_adapter<
600	typename pointer_traits<_Storage_policy>::template rebind<_Up>>;
601
602	static pointer pointer_to(typename pointer::reference __r) noexcept
603	{ return pointer(std::addressof(__r)); }
604	};
605
606	#if __cpp_lib_concepts
607	template<typename _Policy>
608	struct indirectly_readable_traits<__gnu_cxx::_Pointer_adapter<_Policy>>
609	{
610	using value_type
611	= typename __gnu_cxx::_Pointer_adapter<_Policy>::value_type;
612	};
613	#endif
614	_GLIBCXX_END_NAMESPACE_VERSION
615	} // namespace
616	#endif
617
618	#endif // _POINTER_H