39#pragma GCC system_header
48#if __cplusplus >= 201103L
52#if __cplusplus > 201703L
56namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
58_GLIBCXX_BEGIN_NAMESPACE_VERSION
71 template<
typename _Tp>
76 typedef _Tp element_type;
85 set(element_type* __arg)
91 {
return (_M_value < __rarg._M_value); }
95 {
return (_M_value == __rarg._M_value); }
98 element_type* _M_value;
114 template<
typename _Tp>
118 typedef _Tp element_type;
126 return reinterpret_cast<_Tp*
>(
reinterpret_cast<uintptr_t
>(
this)
136 _M_diff =
reinterpret_cast<uintptr_t
>(__arg)
137 -
reinterpret_cast<uintptr_t
>(
this);
143 {
return (
reinterpret_cast<uintptr_t
>(this->get())
144 <
reinterpret_cast<uintptr_t
>(__rarg.get())); }
148 {
return (
reinterpret_cast<uintptr_t
>(this->get())
149 ==
reinterpret_cast<uintptr_t
>(__rarg.get())); }
152 typedef __UINTPTR_TYPE__ uintptr_t;
160 template<
typename _Tp>
164 typedef const _Tp element_type;
172 return reinterpret_cast<const _Tp*
>
173 (
reinterpret_cast<uintptr_t
>(
this) + _M_diff);
177 set(
const _Tp* __arg)
182 _M_diff =
reinterpret_cast<uintptr_t
>(__arg)
183 -
reinterpret_cast<uintptr_t
>(
this);
189 {
return (
reinterpret_cast<uintptr_t
>(this->get())
190 <
reinterpret_cast<uintptr_t
>(__rarg.get())); }
194 {
return (
reinterpret_cast<uintptr_t
>(this->get())
195 ==
reinterpret_cast<uintptr_t
>(__rarg.get())); }
198 typedef __UINTPTR_TYPE__ uintptr_t;
209 template<
typename _Tp>
210 struct _Reference_type
211 {
typedef _Tp& reference; };
214 struct _Reference_type<void>
215 {
typedef _Invalid_type& reference; };
218 struct _Reference_type<const void>
219 {
typedef const _Invalid_type& reference; };
222 struct _Reference_type<volatile void>
223 {
typedef volatile _Invalid_type& reference; };
226 struct _Reference_type<volatile const void>
227 {
typedef const volatile _Invalid_type& reference; };
234 template<
typename _Tp>
236 {
typedef _Tp type; };
238 template<
typename _Tp>
240 {
typedef _Tp type; };
274 template<
typename _Storage_policy>
278 typedef typename _Storage_policy::element_type element_type;
282 typedef typename _Unqualified_type<element_type>::type value_type;
283 typedef std::ptrdiff_t difference_type;
285 typedef typename _Reference_type<element_type>::reference reference;
293 { _Storage_policy::set(__arg); }
297 { _Storage_policy::set(__arg.get()); }
300 template<
typename _Up>
302 { _Storage_policy::set(__arg); }
306 template<
typename _Up>
308 { _Storage_policy::set(__arg.get()); }
317 _Storage_policy::set(__arg.get());
321 template<
typename _Up>
325 _Storage_policy::set(__arg.get());
329 template<
typename _Up>
331 operator=(_Up* __arg)
333 _Storage_policy::set(__arg);
340 {
return *(_Storage_policy::get()); }
345 {
return _Storage_policy::get(); }
349 operator[](std::ptrdiff_t __index)
const
350 {
return _Storage_policy::get()[__index]; }
353#if __cplusplus >= 201103L
354 explicit operator bool()
const {
return _Storage_policy::get() != 0; }
360 operator __unspecified_bool_type()
const
362 return _Storage_policy::get() == 0 ? 0 :
363 &_Pointer_adapter::operator->;
369 {
return (_Storage_policy::get() == 0); }
373 inline friend std::ptrdiff_t
375 {
return (__lhs.get() - __rhs); }
377 inline friend std::ptrdiff_t
379 {
return (__lhs - __rhs.get()); }
381 template<
typename _Up>
382 inline friend std::ptrdiff_t
384 {
return (__lhs.get() - __rhs); }
386 template<
typename _Up>
387 inline friend std::ptrdiff_t
389 {
return (__lhs - __rhs.get()); }
391 template<
typename _Up>
392 inline std::ptrdiff_t
394 {
return (_Storage_policy::get() - __rhs.get()); }
403#define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
404 inline friend _Pointer_adapter \
405 operator+(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
406 { return _Pointer_adapter(__lhs.get() + __offset); } \
408 inline friend _Pointer_adapter \
409 operator+(INT_TYPE __offset, const _Pointer_adapter& __rhs) \
410 { return _Pointer_adapter(__rhs.get() + __offset); } \
412 inline friend _Pointer_adapter \
413 operator-(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
414 { return _Pointer_adapter(__lhs.get() - __offset); } \
416 inline _Pointer_adapter& \
417 operator+=(INT_TYPE __offset) \
419 _Storage_policy::set(_Storage_policy::get() + __offset); \
423 inline _Pointer_adapter& \
424 operator-=(INT_TYPE __offset) \
426 _Storage_policy::set(_Storage_policy::get() - __offset); \
432 _CXX_POINTER_ARITH_OPERATOR_SET(
short);
433 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned short);
434 _CXX_POINTER_ARITH_OPERATOR_SET(
int);
435 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned int);
436 _CXX_POINTER_ARITH_OPERATOR_SET(
long);
437 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned long);
438#ifdef _GLIBCXX_USE_LONG_LONG
439 _CXX_POINTER_ARITH_OPERATOR_SET(
long long);
440 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned long long);
447 _Storage_policy::set(_Storage_policy::get() + 1);
455 _Storage_policy::set(_Storage_policy::get() + 1);
462 _Storage_policy::set(_Storage_policy::get() - 1);
470 _Storage_policy::set(_Storage_policy::get() - 1);
474#if __cpp_lib_three_way_comparison
475 friend std::strong_ordering
478 {
return __lhs.get() <=> __rhs.get(); }
483#define _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(OPERATOR) \
484 template<typename _Tp1, typename _Tp2> \
486 operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, _Tp2 __rhs) \
487 { return __lhs.get() OPERATOR __rhs; } \
489 template<typename _Tp1, typename _Tp2> \
491 operator OPERATOR(_Tp1 __lhs, const _Pointer_adapter<_Tp2>& __rhs) \
492 { return __lhs OPERATOR __rhs.get(); } \
494 template<typename _Tp1, typename _Tp2> \
496 operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, \
497 const _Pointer_adapter<_Tp2>& __rhs) \
498 { return __lhs.get() OPERATOR __rhs.get(); } \
503 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
504 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
505 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<)
506 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<=)
507 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>)
508 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>=)
511 template<typename _Tp>
514 {
return __lhs.get() ==
reinterpret_cast<void*
>(__rhs); }
516 template<
typename _Tp>
518 operator==(
int __lhs,
const _Pointer_adapter<_Tp>& __rhs)
519 {
return __rhs.get() ==
reinterpret_cast<void*
>(__lhs); }
521 template<
typename _Tp>
523 operator!=(
const _Pointer_adapter<_Tp>& __lhs,
int __rhs)
524 {
return __lhs.get() !=
reinterpret_cast<void*
>(__rhs); }
526 template<
typename _Tp>
528 operator!=(
int __lhs,
const _Pointer_adapter<_Tp>& __rhs)
529 {
return __rhs.get() !=
reinterpret_cast<void*
>(__lhs); }
535 template<
typename _Tp>
539 {
return __lhs._Tp::operator==(__rhs); }
541 template<
typename _Tp>
543 operator<=(
const _Pointer_adapter<_Tp>& __lhs,
544 const _Pointer_adapter<_Tp>& __rhs)
545 {
return __lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs); }
547 template<
typename _Tp>
549 operator!=(
const _Pointer_adapter<_Tp>& __lhs,
550 const _Pointer_adapter<_Tp>& __rhs)
551 {
return !(__lhs._Tp::operator==(__rhs)); }
553 template<
typename _Tp>
555 operator>(
const _Pointer_adapter<_Tp>& __lhs,
556 const _Pointer_adapter<_Tp>& __rhs)
557 {
return !(__lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs)); }
559 template<
typename _Tp>
561 operator>=(
const _Pointer_adapter<_Tp>& __lhs,
562 const _Pointer_adapter<_Tp>& __rhs)
563 {
return !(__lhs._Tp::operator<(__rhs)); }
566 template<
typename _CharT,
typename _Traits,
typename _StoreT>
569 const _Pointer_adapter<_StoreT>& __p)
570 {
return (__os << __p.get()); }
573_GLIBCXX_END_NAMESPACE_VERSION
576#if __cplusplus >= 201103L
577namespace std _GLIBCXX_VISIBILITY(default)
579_GLIBCXX_BEGIN_NAMESPACE_VERSION
581 template<
typename _Storage_policy>
582 struct pointer_traits<
__gnu_cxx::_Pointer_adapter<_Storage_policy>>
587 typedef typename pointer::element_type element_type;
589 typedef typename pointer::difference_type difference_type;
591 template<
typename _Up>
593 typename pointer_traits<_Storage_policy>::template rebind<_Up>>;
595 static pointer pointer_to(
typename pointer::reference __r)
noexcept
599#if __cpp_lib_concepts
600 template<
typename _Policy>
601 struct indirectly_readable_traits<
__gnu_cxx::_Pointer_adapter<_Policy>>
604 =
typename __gnu_cxx::_Pointer_adapter<_Policy>::value_type;
607_GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
ISO C++ entities toplevel namespace is std.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
GNU extensions for public use.
Template class basic_ostream.
Random-access iterators support a superset of bidirectional iterator operations.
A storage policy for use with _Pointer_adapter<> which yields a standard pointer.
A storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset valu...