Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/11/bits/refwrap.h
$ cat -n /usr/include/c++/11/bits/refwrap.h 1 // Implementation of std::reference_wrapper -*- C++ -*- 2 3 // Copyright (C) 2004-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 /** @file include/bits/refwrap.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{functional} 28 */ 29 30 #ifndef _GLIBCXX_REFWRAP_H 31 #define _GLIBCXX_REFWRAP_H 1 32 33 #pragma GCC system_header 34 35 #if __cplusplus < 201103L 36 # include <bits/c++0x_warning.h> 37 #else 38 39 #include <bits/move.h> 40 #include <bits/invoke.h> 41 #include <bits/stl_function.h> // for unary_function and binary_function 42 43 namespace std _GLIBCXX_VISIBILITY(default) 44 { 45 _GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 /// @cond undocumented 48 49 /** 50 * Derives from @c unary_function or @c binary_function, or perhaps 51 * nothing, depending on the number of arguments provided. The 52 * primary template is the basis case, which derives nothing. 53 */ 54 template<typename _Res, typename... _ArgTypes> 55 struct _Maybe_unary_or_binary_function { }; 56 57 /// Derives from @c unary_function, as appropriate. 58 template<typename _Res, typename _T1> 59 struct _Maybe_unary_or_binary_function<_Res, _T1> 60 : std::unary_function<_T1, _Res> { }; 61 62 /// Derives from @c binary_function, as appropriate. 63 template<typename _Res, typename _T1, typename _T2> 64 struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> 65 : std::binary_function<_T1, _T2, _Res> { }; 66 67 template<typename _Signature> 68 struct _Mem_fn_traits; 69 70 template<typename _Res, typename _Class, typename... _ArgTypes> 71 struct _Mem_fn_traits_base 72 { 73 using __result_type = _Res; 74 using __maybe_type 75 = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; 76 using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>; 77 }; 78 79 #define _GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL) \ 80 template<typename _Res, typename _Class, typename... _ArgTypes> \ 81 struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF> \ 82 : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \ 83 { \ 84 using __vararg = false_type; \ 85 }; \ 86 template<typename _Res, typename _Class, typename... _ArgTypes> \ 87 struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF> \ 88 : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \ 89 { \ 90 using __vararg = true_type; \ 91 }; 92 93 #define _GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL) \ 94 _GLIBCXX_MEM_FN_TRAITS2( , _REF, _LVAL, _RVAL) \ 95 _GLIBCXX_MEM_FN_TRAITS2(const , _REF, _LVAL, _RVAL) \ 96 _GLIBCXX_MEM_FN_TRAITS2(volatile , _REF, _LVAL, _RVAL) \ 97 _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL) 98 99 _GLIBCXX_MEM_FN_TRAITS( , true_type, true_type) 100 _GLIBCXX_MEM_FN_TRAITS(&, true_type, false_type) 101 _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) 102 103 #if __cplusplus > 201402L 104 _GLIBCXX_MEM_FN_TRAITS(noexcept, true_type, true_type) 105 _GLIBCXX_MEM_FN_TRAITS(& noexcept, true_type, false_type) 106 _GLIBCXX_MEM_FN_TRAITS(&& noexcept, false_type, true_type) 107 #endif 108 109 #undef _GLIBCXX_MEM_FN_TRAITS 110 #undef _GLIBCXX_MEM_FN_TRAITS2 111 112 /// If we have found a result_type, extract it. 113 template<typename _Functor, typename = __void_t<>> 114 struct _Maybe_get_result_type 115 { }; 116 117 template<typename _Functor> 118 struct _Maybe_get_result_type<_Functor, 119 __void_t<typename _Functor::result_type>> 120 { typedef typename _Functor::result_type result_type; }; 121 122 /** 123 * Base class for any function object that has a weak result type, as 124 * defined in 20.8.2 [func.require] of C++11. 125 */ 126 template<typename _Functor> 127 struct _Weak_result_type_impl 128 : _Maybe_get_result_type<_Functor> 129 { }; 130 131 /// Retrieve the result type for a function type. 132 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 133 struct _Weak_result_type_impl<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> 134 { typedef _Res result_type; }; 135 136 /// Retrieve the result type for a varargs function type. 137 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 138 struct _Weak_result_type_impl<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL> 139 { typedef _Res result_type; }; 140 141 /// Retrieve the result type for a function pointer. 142 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 143 struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> 144 { typedef _Res result_type; }; 145 146 /// Retrieve the result type for a varargs function pointer. 147 template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> 148 struct 149 _Weak_result_type_impl<_Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL> 150 { typedef _Res result_type; }; 151 152 // Let _Weak_result_type_impl perform the real work. 153 template<typename _Functor, 154 bool = is_member_function_pointer<_Functor>::value> 155 struct _Weak_result_type_memfun 156 : _Weak_result_type_impl<_Functor> 157 { }; 158 159 // A pointer to member function has a weak result type. 160 template<typename _MemFunPtr> 161 struct _Weak_result_type_memfun<_MemFunPtr, true> 162 { 163 using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; 164 }; 165 166 // A pointer to data member doesn't have a weak result type. 167 template<typename _Func, typename _Class> 168 struct _Weak_result_type_memfun<_Func _Class::*, false> 169 { }; 170 171 /** 172 * Strip top-level cv-qualifiers from the function object and let 173 * _Weak_result_type_memfun perform the real work. 174 */ 175 template<typename _Functor> 176 struct _Weak_result_type 177 : _Weak_result_type_memfun<typename remove_cv<_Functor>::type> 178 { }; 179 180 #if __cplusplus <= 201703L 181 // Detect nested argument_type. 182 template<typename _Tp, typename = __void_t<>> 183 struct _Refwrap_base_arg1 184 { }; 185 186 // Nested argument_type. 187 template<typename _Tp> 188 struct _Refwrap_base_arg1<_Tp, 189 __void_t<typename _Tp::argument_type>> 190 { 191 typedef typename _Tp::argument_type argument_type; 192 }; 193 194 // Detect nested first_argument_type and second_argument_type. 195 template<typename _Tp, typename = __void_t<>> 196 struct _Refwrap_base_arg2 197 { }; 198 199 // Nested first_argument_type and second_argument_type. 200 template<typename _Tp> 201 struct _Refwrap_base_arg2<_Tp, 202 __void_t<typename _Tp::first_argument_type, 203 typename _Tp::second_argument_type>> 204 { 205 typedef typename _Tp::first_argument_type first_argument_type; 206 typedef typename _Tp::second_argument_type second_argument_type; 207 }; 208 209 /** 210 * Derives from unary_function or binary_function when it 211 * can. Specializations handle all of the easy cases. The primary 212 * template determines what to do with a class type, which may 213 * derive from both unary_function and binary_function. 214 */ 215 template<typename _Tp> 216 struct _Reference_wrapper_base 217 : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> 218 { }; 219 220 // - a function type (unary) 221 template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM> 222 struct _Reference_wrapper_base<_Res(_T1) _GLIBCXX_NOEXCEPT_QUAL> 223 : unary_function<_T1, _Res> 224 { }; 225 226 template<typename _Res, typename _T1> 227 struct _Reference_wrapper_base<_Res(_T1) const> 228 : unary_function<_T1, _Res> 229 { }; 230 231 template<typename _Res, typename _T1> 232 struct _Reference_wrapper_base<_Res(_T1) volatile> 233 : unary_function<_T1, _Res> 234 { }; 235 236 template<typename _Res, typename _T1> 237 struct _Reference_wrapper_base<_Res(_T1) const volatile> 238 : unary_function<_T1, _Res> 239 { }; 240 241 // - a function type (binary) 242 template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM> 243 struct _Reference_wrapper_base<_Res(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL> 244 : binary_function<_T1, _T2, _Res> 245 { }; 246 247 template<typename _Res, typename _T1, typename _T2> 248 struct _Reference_wrapper_base<_Res(_T1, _T2) const> 249 : binary_function<_T1, _T2, _Res> 250 { }; 251 252 template<typename _Res, typename _T1, typename _T2> 253 struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> 254 : binary_function<_T1, _T2, _Res> 255 { }; 256 257 template<typename _Res, typename _T1, typename _T2> 258 struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> 259 : binary_function<_T1, _T2, _Res> 260 { }; 261 262 // - a function pointer type (unary) 263 template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM> 264 struct _Reference_wrapper_base<_Res(*)(_T1) _GLIBCXX_NOEXCEPT_QUAL> 265 : unary_function<_T1, _Res> 266 { }; 267 268 // - a function pointer type (binary) 269 template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM> 270 struct _Reference_wrapper_base<_Res(*)(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL> 271 : binary_function<_T1, _T2, _Res> 272 { }; 273 274 template<typename _Tp, bool = is_member_function_pointer<_Tp>::value> 275 struct _Reference_wrapper_base_memfun 276 : _Reference_wrapper_base<_Tp> 277 { }; 278 279 template<typename _MemFunPtr> 280 struct _Reference_wrapper_base_memfun<_MemFunPtr, true> 281 : _Mem_fn_traits<_MemFunPtr>::__maybe_type 282 { 283 using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; 284 }; 285 #endif // ! C++20 286 287 /// @endcond 288 289 /** 290 * @brief Primary class template for reference_wrapper. 291 * @ingroup functors 292 */ 293 template<typename _Tp> 294 class reference_wrapper 295 #if __cplusplus <= 201703L 296 // In C++20 std::reference_wrapper<T> allows T to be incomplete, 297 // so checking for nested types could result in ODR violations. 298 : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type> 299 #endif 300 { 301 _Tp* _M_data; 302 303 _GLIBCXX20_CONSTEXPR 304 static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } 305 306 static void _S_fun(_Tp&&) = delete; 307 308 template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>> 309 using __not_same 310 = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type; 311 312 public: 313 typedef _Tp type; 314 315 // _GLIBCXX_RESOLVE_LIB_DEFECTS 316 // 2993. reference_wrapper<T> conversion from T&& 317 // 3041. Unnecessary decay in reference_wrapper 318 template<typename _Up, typename = __not_same<_Up>, typename 319 = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> 320 _GLIBCXX20_CONSTEXPR 321 reference_wrapper(_Up&& __uref) 322 noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) 323 : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) 324 { } 325 326 reference_wrapper(const reference_wrapper&) = default; 327 328 reference_wrapper& 329 operator=(const reference_wrapper&) = default; 330 331 _GLIBCXX20_CONSTEXPR 332 operator _Tp&() const noexcept 333 { return this->get(); } 334 335 _GLIBCXX20_CONSTEXPR 336 _Tp& 337 get() const noexcept 338 { return *_M_data; } 339 340 template<typename... _Args> 341 _GLIBCXX20_CONSTEXPR 342 typename result_of<_Tp&(_Args&&...)>::type 343 operator()(_Args&&... __args) const 344 { 345 #if __cplusplus > 201703L 346 if constexpr (is_object_v<type>) 347 static_assert(sizeof(type), "type must be complete"); 348 #endif 349 return std::__invoke(get(), std::forward<_Args>(__args)...); 350 } 351 }; 352 353 #if __cpp_deduction_guides 354 template<typename _Tp> 355 reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; 356 #endif 357 358 /// @relates reference_wrapper @{ 359 360 /// Denotes a reference should be taken to a variable. 361 template<typename _Tp> 362 _GLIBCXX20_CONSTEXPR 363 inline reference_wrapper<_Tp> 364 ref(_Tp& __t) noexcept 365 { return reference_wrapper<_Tp>(__t); } 366 367 /// Denotes a const reference should be taken to a variable. 368 template<typename _Tp> 369 _GLIBCXX20_CONSTEXPR 370 inline reference_wrapper<const _Tp> 371 cref(const _Tp& __t) noexcept 372 { return reference_wrapper<const _Tp>(__t); } 373 374 template<typename _Tp> 375 void ref(const _Tp&&) = delete; 376 377 template<typename _Tp> 378 void cref(const _Tp&&) = delete; 379 380 /// std::ref overload to prevent wrapping a reference_wrapper 381 template<typename _Tp> 382 _GLIBCXX20_CONSTEXPR 383 inline reference_wrapper<_Tp> 384 ref(reference_wrapper<_Tp> __t) noexcept 385 { return __t; } 386 387 /// std::cref overload to prevent wrapping a reference_wrapper 388 template<typename _Tp> 389 _GLIBCXX20_CONSTEXPR 390 inline reference_wrapper<const _Tp> 391 cref(reference_wrapper<_Tp> __t) noexcept 392 { return { __t.get() }; } 393 394 /// @} 395 396 _GLIBCXX_END_NAMESPACE_VERSION 397 } // namespace std 398 399 #endif // C++11 400 401 #endif // _GLIBCXX_REFWRAP_H
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
