1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP___MEMORY_POINTER_TRAITS_H 11 #define _LIBCPP___MEMORY_POINTER_TRAITS_H 12 13 #include <__config> 14 #include <__memory/addressof.h> 15 #include <type_traits> 16 17 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 18 #pragma GCC system_header 19 #endif 20 21 _LIBCPP_BEGIN_NAMESPACE_STD 22 23 template <class _Tp, class = void> 24 struct __has_element_type : false_type {}; 25 26 template <class _Tp> 27 struct __has_element_type<_Tp, 28 typename __void_t<typename _Tp::element_type>::type> : true_type {}; 29 30 template <class _Ptr, bool = __has_element_type<_Ptr>::value> 31 struct __pointer_traits_element_type; 32 33 template <class _Ptr> 34 struct __pointer_traits_element_type<_Ptr, true> 35 { 36 typedef _LIBCPP_NODEBUG typename _Ptr::element_type type; 37 }; 38 39 template <template <class, class...> class _Sp, class _Tp, class ..._Args> 40 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> 41 { 42 typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::element_type type; 43 }; 44 45 template <template <class, class...> class _Sp, class _Tp, class ..._Args> 46 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> 47 { 48 typedef _LIBCPP_NODEBUG _Tp type; 49 }; 50 51 template <class _Tp, class = void> 52 struct __has_difference_type : false_type {}; 53 54 template <class _Tp> 55 struct __has_difference_type<_Tp, 56 typename __void_t<typename _Tp::difference_type>::type> : true_type {}; 57 58 template <class _Ptr, bool = __has_difference_type<_Ptr>::value> 59 struct __pointer_traits_difference_type 60 { 61 typedef _LIBCPP_NODEBUG ptrdiff_t type; 62 }; 63 64 template <class _Ptr> 65 struct __pointer_traits_difference_type<_Ptr, true> 66 { 67 typedef _LIBCPP_NODEBUG typename _Ptr::difference_type type; 68 }; 69 70 template <class _Tp, class _Up> 71 struct __has_rebind 72 { 73 private: 74 struct __two {char __lx; char __lxx;}; 75 template <class _Xp> static __two __test(...); 76 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 77 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); 78 _LIBCPP_SUPPRESS_DEPRECATED_POP 79 public: 80 static const bool value = sizeof(__test<_Tp>(0)) == 1; 81 }; 82 83 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 84 struct __pointer_traits_rebind 85 { 86 #ifndef _LIBCPP_CXX03_LANG 87 typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type; 88 #else 89 typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up>::other type; 90 #endif 91 }; 92 93 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 94 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> 95 { 96 #ifndef _LIBCPP_CXX03_LANG 97 typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up> type; 98 #else 99 typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type; 100 #endif 101 }; 102 103 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 104 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> 105 { 106 typedef _Sp<_Up, _Args...> type; 107 }; 108 109 template <class _Ptr> 110 struct _LIBCPP_TEMPLATE_VIS pointer_traits 111 { 112 typedef _Ptr pointer; 113 typedef typename __pointer_traits_element_type<pointer>::type element_type; 114 typedef typename __pointer_traits_difference_type<pointer>::type difference_type; 115 116 #ifndef _LIBCPP_CXX03_LANG 117 template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type; 118 #else 119 template <class _Up> struct rebind 120 {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;}; 121 #endif // _LIBCPP_CXX03_LANG 122 123 private: 124 struct __nat {}; 125 public: 126 _LIBCPP_INLINE_VISIBILITY 127 static pointer pointer_to(typename conditional<is_void<element_type>::value, 128 __nat, element_type>::type& __r) 129 {return pointer::pointer_to(__r);} 130 }; 131 132 template <class _Tp> 133 struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*> 134 { 135 typedef _Tp* pointer; 136 typedef _Tp element_type; 137 typedef ptrdiff_t difference_type; 138 139 #ifndef _LIBCPP_CXX03_LANG 140 template <class _Up> using rebind = _Up*; 141 #else 142 template <class _Up> struct rebind {typedef _Up* other;}; 143 #endif 144 145 private: 146 struct __nat {}; 147 public: 148 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 149 static pointer pointer_to(typename conditional<is_void<element_type>::value, 150 __nat, element_type>::type& __r) _NOEXCEPT 151 {return _VSTD::addressof(__r);} 152 }; 153 154 template <class _From, class _To> 155 struct __rebind_pointer { 156 #ifndef _LIBCPP_CXX03_LANG 157 typedef typename pointer_traits<_From>::template rebind<_To> type; 158 #else 159 typedef typename pointer_traits<_From>::template rebind<_To>::other type; 160 #endif 161 }; 162 163 // to_address 164 165 template <class _Pointer, class = void> 166 struct __to_address_helper; 167 168 template <class _Tp> 169 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 170 _Tp* __to_address(_Tp* __p) _NOEXCEPT { 171 static_assert(!is_function<_Tp>::value, "_Tp is a function type"); 172 return __p; 173 } 174 175 // enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers 176 template <class _Pointer, class = __enable_if_t< 177 !is_pointer<_Pointer>::value && !is_array<_Pointer>::value && !is_function<_Pointer>::value 178 > > 179 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 180 typename decay<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>::type 181 __to_address(const _Pointer& __p) _NOEXCEPT { 182 return __to_address_helper<_Pointer>::__call(__p); 183 } 184 185 template <class _Pointer, class> 186 struct __to_address_helper { 187 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 188 static decltype(_VSTD::__to_address(declval<const _Pointer&>().operator->())) 189 __call(const _Pointer& __p) _NOEXCEPT { 190 return _VSTD::__to_address(__p.operator->()); 191 } 192 }; 193 194 template <class _Pointer> 195 struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))> { 196 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 197 static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>())) 198 __call(const _Pointer& __p) _NOEXCEPT { 199 return pointer_traits<_Pointer>::to_address(__p); 200 } 201 }; 202 203 #if _LIBCPP_STD_VER > 17 204 template <class _Tp> 205 inline _LIBCPP_INLINE_VISIBILITY constexpr 206 auto to_address(_Tp *__p) noexcept { 207 return _VSTD::__to_address(__p); 208 } 209 210 template <class _Pointer> 211 inline _LIBCPP_INLINE_VISIBILITY constexpr 212 auto to_address(const _Pointer& __p) noexcept { 213 return _VSTD::__to_address(__p); 214 } 215 #endif 216 217 _LIBCPP_END_NAMESPACE_STD 218 219 #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H 220