39 #ifdef _GLIBCXX_SYSHDR
40 #pragma GCC system_header
51 #if __cplusplus >= 201103L
55 #if __cplusplus > 201703L
59 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
61 _GLIBCXX_BEGIN_NAMESPACE_VERSION
74 template<
typename _Tp>
79 typedef _Tp element_type;
88 set(element_type* __arg)
94 {
return (_M_value < __rarg._M_value); }
98 {
return (_M_value == __rarg._M_value); }
101 element_type* _M_value;
117 template<
typename _Tp>
121 typedef _Tp element_type;
129 return reinterpret_cast<_Tp*
>(
reinterpret_cast<uintptr_t
>(
this)
139 _M_diff =
reinterpret_cast<uintptr_t
>(__arg)
140 -
reinterpret_cast<uintptr_t
>(
this);
146 {
return (
reinterpret_cast<uintptr_t
>(this->get())
147 <
reinterpret_cast<uintptr_t
>(__rarg.get())); }
151 {
return (
reinterpret_cast<uintptr_t
>(this->get())
152 ==
reinterpret_cast<uintptr_t
>(__rarg.get())); }
155 typedef __UINTPTR_TYPE__ uintptr_t;
163 template<
typename _Tp>
167 typedef const _Tp element_type;
175 return reinterpret_cast<const _Tp*
>
176 (
reinterpret_cast<uintptr_t
>(
this) + _M_diff);
180 set(
const _Tp* __arg)
185 _M_diff =
reinterpret_cast<uintptr_t
>(__arg)
186 -
reinterpret_cast<uintptr_t
>(
this);
192 {
return (
reinterpret_cast<uintptr_t
>(this->get())
193 <
reinterpret_cast<uintptr_t
>(__rarg.get())); }
197 {
return (
reinterpret_cast<uintptr_t
>(this->get())
198 ==
reinterpret_cast<uintptr_t
>(__rarg.get())); }
201 typedef __UINTPTR_TYPE__ uintptr_t;
212 template<
typename _Tp>
213 struct _Reference_type
214 {
typedef _Tp& reference; };
217 struct _Reference_type<void>
218 {
typedef _Invalid_type& reference; };
221 struct _Reference_type<const void>
222 {
typedef const _Invalid_type& reference; };
225 struct _Reference_type<volatile void>
226 {
typedef volatile _Invalid_type& reference; };
229 struct _Reference_type<volatile const void>
230 {
typedef const volatile _Invalid_type& reference; };
237 template<
typename _Tp>
239 {
typedef _Tp type; };
241 template<
typename _Tp>
243 {
typedef _Tp type; };
277 template<
typename _Storage_policy>
281 typedef typename _Storage_policy::element_type element_type;
285 typedef typename _Unqualified_type<element_type>::type value_type;
286 typedef std::ptrdiff_t difference_type;
288 typedef typename _Reference_type<element_type>::reference reference;
296 { _Storage_policy::set(__arg); }
300 { _Storage_policy::set(__arg.get()); }
303 template<
typename _Up>
305 { _Storage_policy::set(__arg); }
309 template<
typename _Up>
311 { _Storage_policy::set(__arg.get()); }
320 _Storage_policy::set(__arg.get());
324 template<
typename _Up>
328 _Storage_policy::set(__arg.get());
332 template<
typename _Up>
334 operator=(_Up* __arg)
336 _Storage_policy::set(__arg);
343 {
return *(_Storage_policy::get()); }
348 {
return _Storage_policy::get(); }
352 operator[](std::ptrdiff_t __index)
const
353 {
return _Storage_policy::get()[__index]; }
356 #if __cplusplus >= 201103L
357 explicit operator bool()
const {
return _Storage_policy::get() != 0; }
363 operator __unspecified_bool_type()
const
365 return _Storage_policy::get() == 0 ? 0 :
366 &_Pointer_adapter::operator->;
372 {
return (_Storage_policy::get() == 0); }
376 inline friend std::ptrdiff_t
378 {
return (__lhs.get() - __rhs); }
380 inline friend std::ptrdiff_t
382 {
return (__lhs - __rhs.get()); }
384 template<
typename _Up>
385 inline friend std::ptrdiff_t
387 {
return (__lhs.get() - __rhs); }
389 template<
typename _Up>
390 inline friend std::ptrdiff_t
392 {
return (__lhs - __rhs.get()); }
394 template<
typename _Up>
395 inline std::ptrdiff_t
397 {
return (_Storage_policy::get() - __rhs.get()); }
406 #define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
407 inline friend _Pointer_adapter \
408 operator+(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
409 { return _Pointer_adapter(__lhs.get() + __offset); } \
411 inline friend _Pointer_adapter \
412 operator+(INT_TYPE __offset, const _Pointer_adapter& __rhs) \
413 { return _Pointer_adapter(__rhs.get() + __offset); } \
415 inline friend _Pointer_adapter \
416 operator-(const _Pointer_adapter& __lhs, INT_TYPE __offset) \
417 { return _Pointer_adapter(__lhs.get() - __offset); } \
419 inline _Pointer_adapter& \
420 operator+=(INT_TYPE __offset) \
422 _Storage_policy::set(_Storage_policy::get() + __offset); \
426 inline _Pointer_adapter& \
427 operator-=(INT_TYPE __offset) \
429 _Storage_policy::set(_Storage_policy::get() - __offset); \
435 _CXX_POINTER_ARITH_OPERATOR_SET(
short);
436 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned short);
437 _CXX_POINTER_ARITH_OPERATOR_SET(
int);
438 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned int);
439 _CXX_POINTER_ARITH_OPERATOR_SET(
long);
440 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned long);
441 #ifdef _GLIBCXX_USE_LONG_LONG
442 #pragma GCC diagnostic push
443 #pragma GCC diagnostic ignored "-Wlong-long"
444 _CXX_POINTER_ARITH_OPERATOR_SET(
long long);
445 _CXX_POINTER_ARITH_OPERATOR_SET(
unsigned long long);
446 #pragma GCC diagnostic pop
453 _Storage_policy::set(_Storage_policy::get() + 1);
461 _Storage_policy::set(_Storage_policy::get() + 1);
468 _Storage_policy::set(_Storage_policy::get() - 1);
476 _Storage_policy::set(_Storage_policy::get() - 1);
480 #if __cpp_lib_three_way_comparison
481 friend std::strong_ordering
484 {
return __lhs.get() <=> __rhs.get(); }
489 #define _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(OPERATOR) \
490 template<typename _Tp1, typename _Tp2> \
492 operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, _Tp2 __rhs) \
493 { return __lhs.get() OPERATOR __rhs; } \
495 template<typename _Tp1, typename _Tp2> \
497 operator OPERATOR(_Tp1 __lhs, const _Pointer_adapter<_Tp2>& __rhs) \
498 { return __lhs OPERATOR __rhs.get(); } \
500 template<typename _Tp1, typename _Tp2> \
502 operator OPERATOR(const _Pointer_adapter<_Tp1>& __lhs, \
503 const _Pointer_adapter<_Tp2>& __rhs) \
504 { return __lhs.get() OPERATOR __rhs.get(); } \
509 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
510 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
511 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<)
512 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(<=)
513 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>)
514 _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(>=)
517 template<typename _Tp>
520 {
return __lhs.get() ==
reinterpret_cast<void*
>(__rhs); }
522 template<
typename _Tp>
524 operator==(
int __lhs,
const _Pointer_adapter<_Tp>& __rhs)
525 {
return __rhs.get() ==
reinterpret_cast<void*
>(__lhs); }
527 template<
typename _Tp>
529 operator!=(
const _Pointer_adapter<_Tp>& __lhs,
int __rhs)
530 {
return __lhs.get() !=
reinterpret_cast<void*
>(__rhs); }
532 template<
typename _Tp>
534 operator!=(
int __lhs,
const _Pointer_adapter<_Tp>& __rhs)
535 {
return __rhs.get() !=
reinterpret_cast<void*
>(__lhs); }
541 template<
typename _Tp>
545 {
return __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) || __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)); }
559 template<
typename _Tp>
561 operator>(
const _Pointer_adapter<_Tp>& __lhs,
562 const _Pointer_adapter<_Tp>& __rhs)
563 {
return !(__lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs)); }
565 template<
typename _Tp>
567 operator>=(
const _Pointer_adapter<_Tp>& __lhs,
568 const _Pointer_adapter<_Tp>& __rhs)
569 {
return !(__lhs._Tp::operator<(__rhs)); }
572 template<
typename _CharT,
typename _Traits,
typename _StoreT>
575 const _Pointer_adapter<_StoreT>& __p)
576 {
return (__os << __p.get()); }
579 _GLIBCXX_END_NAMESPACE_VERSION
582 #if __cplusplus >= 201103L
583 namespace std _GLIBCXX_VISIBILITY(default)
585 _GLIBCXX_BEGIN_NAMESPACE_VERSION
587 template<
typename _Storage_policy>
588 struct pointer_traits<
__gnu_cxx::_Pointer_adapter<_Storage_policy>>
593 typedef typename pointer::element_type element_type;
595 typedef typename pointer::difference_type difference_type;
597 template<
typename _Up>
599 typename pointer_traits<_Storage_policy>::template rebind<_Up>>;
601 static pointer pointer_to(
typename pointer::reference __r) noexcept
605 #if __cpp_lib_concepts
606 template<
typename _Policy>
607 struct indirectly_readable_traits<
__gnu_cxx::_Pointer_adapter<_Policy>>
610 =
typename __gnu_cxx::_Pointer_adapter<_Policy>::value_type;
613 _GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
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...