39 #pragma GCC system_header 48 #if __cplusplus >= 201103L 52 #if __cplusplus > 201703L 56 namespace __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); \ 429 // END of _CXX_POINTER_ARITH_OPERATOR_SET macro 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(); } \ 500 // End GCC_CXX_POINTER_COMPARISON_OPERATION_SET Macro 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>
568 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
569 const _Pointer_adapter<_StoreT>& __p)
570 {
return (__os << __p.get()); }
573 _GLIBCXX_END_NAMESPACE_VERSION
576 #if __cplusplus >= 201103L 577 namespace 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
Template class basic_ostream.
GNU extensions for public use.
Random-access iterators support a superset of bidirectional iterator operations.
ISO C++ entities toplevel namespace is std.
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...
A storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset valu...
A storage policy for use with _Pointer_adapter<> which yields a standard pointer. ...