Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/experimental/bits/net.h
$ cat -n /usr/include/c++/13/experimental/bits/net.h 1 // Networking implementation details -*- C++ -*- 2 3 // Copyright (C) 2015-2023 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 experimental/bits/net.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{experimental/net} 28 */ 29 30 #ifndef _GLIBCXX_EXPERIMENTAL_NET_H 31 #define _GLIBCXX_EXPERIMENTAL_NET_H 1 32 33 #pragma GCC system_header 34 35 #if __cplusplus >= 201402L 36 37 #include <type_traits> 38 #include <system_error> 39 #include <experimental/netfwd> 40 41 #if __cplusplus > 201703L 42 # include <concepts> 43 #endif 44 45 namespace std _GLIBCXX_VISIBILITY(default) 46 { 47 _GLIBCXX_BEGIN_NAMESPACE_VERSION 48 namespace experimental 49 { 50 namespace net 51 { 52 inline namespace v1 53 { 54 55 /** @addtogroup networking-ts 56 * @{ 57 */ 58 59 template<typename _CompletionToken, typename _Signature, typename> 60 class async_result; 61 62 /// @cond undocumented 63 64 // A type denoted by DEDUCED in the TS. 65 template<typename _CompletionToken, typename _Signature> 66 using __deduced_t = typename 67 async_result<decay_t<_CompletionToken>, _Signature, void>::return_type; 68 69 // Trait to check for construction from const/non-const lvalue/rvalue. 70 template<typename _Tp> 71 using __is_value_constructible = typename __and_< 72 is_copy_constructible<_Tp>, is_move_constructible<_Tp>, 73 is_constructible<_Tp, _Tp&>, is_constructible<_Tp, const _Tp&&> 74 >::type; 75 76 struct __throw_on_error 77 { 78 explicit 79 __throw_on_error(const char* __msg) : _M_msg(__msg) { } 80 81 ~__throw_on_error() noexcept(false) 82 { 83 if (_M_ec) 84 _GLIBCXX_THROW_OR_ABORT(system_error(_M_ec, _M_msg)); 85 } 86 87 __throw_on_error(const __throw_on_error&) = delete; 88 __throw_on_error& operator=(const __throw_on_error&) = delete; 89 90 operator error_code&() noexcept { return _M_ec; } 91 92 const char* _M_msg; 93 error_code _M_ec; 94 }; 95 96 /// @endcond 97 98 // Base class for types meeting both GettableSocketOption and 99 // SettableSocketOption requirements. 100 // The bool parameter allows __sockopt_base<bool> to have a 101 // __sockopt_base<int, B> base class (so that its _M_value is an int) 102 // but to have that be a distinct type from __sockopt_base<int>. 103 template<typename _Tp, bool = true> 104 struct __sockopt_base 105 { 106 __sockopt_base() = default; 107 108 explicit 109 __sockopt_base(_Tp __val) noexcept(noexcept(_Tp(std::declval<_Tp&>()))) 110 : _M_value(__val) 111 { } 112 113 template<typename _Protocol> 114 void* 115 data(const _Protocol&) noexcept 116 { return std::addressof(_M_value); } 117 118 template<typename _Protocol> 119 const void* 120 data(const _Protocol&) const noexcept 121 { return std::addressof(_M_value); } 122 123 template<typename _Protocol> 124 size_t 125 size(const _Protocol&) const noexcept 126 { return sizeof(_M_value); } 127 128 template<typename _Protocol> 129 void 130 resize(const _Protocol&, size_t __s) 131 { 132 if (__s != sizeof(_M_value)) 133 __throw_length_error("invalid value for socket option resize"); 134 } 135 136 protected: 137 _Tp _M_value { }; 138 }; 139 140 // Base class for types meeting BooleanSocketOption requirements. 141 template<> 142 struct __sockopt_base<bool> : __sockopt_base<int, false> 143 { 144 __sockopt_base() = default; 145 146 explicit 147 __sockopt_base(bool __val) noexcept 148 : __sockopt_base<int, false>(__val) 149 { } 150 151 bool value() const noexcept { return this->_M_value; } 152 explicit operator bool() const noexcept { return value(); } 153 bool operator!() const noexcept { return !value(); } 154 }; 155 156 // Base class for types meeting IntegerSocketOption requirements. 157 template<> 158 struct __sockopt_base<int> : __sockopt_base<int, false> 159 { 160 using __sockopt_base<int, false>::__sockopt_base; 161 162 int value() const noexcept { return this->_M_value; } 163 }; 164 165 template<typename _Derived, typename _Tp = int> 166 struct __sockopt_crtp : __sockopt_base<_Tp> 167 { 168 using __sockopt_base<_Tp>::__sockopt_base; 169 170 _Derived& 171 operator=(_Tp __value) noexcept(noexcept(__value = __value)) 172 { 173 __sockopt_base<_Tp>::_M_value = __value; 174 return static_cast<_Derived&>(*this); 175 } 176 177 template<typename _Protocol> 178 int 179 level(const _Protocol&) const noexcept 180 { return _Derived::_S_level; } 181 182 template<typename _Protocol> 183 int 184 name(const _Protocol&) const noexcept 185 { return _Derived::_S_name; } 186 }; 187 188 namespace __detail 189 { 190 #if __cpp_lib_concepts 191 template<typename _Tp> 192 concept __protocol_like 193 = copyable<_Tp> && requires { typename _Tp::endpoint; }; 194 195 // Endpoint requirements for non-extensible implementations. 196 template<typename _Tp> 197 concept __endpoint_base = semiregular<_Tp> 198 && requires { typename _Tp::protocol_type; } 199 && __protocol_like<typename _Tp::protocol_type> 200 && requires(const _Tp __a) { 201 { __a.protocol() } -> same_as<typename _Tp::protocol_type>; 202 }; 203 204 // Endpoint requirements for extensible implementations. 205 template<typename _Tp> 206 concept __endpoint = __endpoint_base<_Tp> 207 && requires (const _Tp& __a, _Tp& __b, size_t __s) 208 { 209 { __a.data() } -> same_as<const void*>; 210 { __b.data() } -> same_as<void*>; 211 { __b.size() } -> same_as<size_t>; 212 __b.resize(__s); 213 { __a.capacity() } -> same_as<size_t>; 214 }; 215 216 // Protocol requirements for non-extensible implementations. 217 template<typename _Tp> 218 concept __protocol_base = __protocol_like<_Tp> 219 && __endpoint_base<typename _Tp::endpoint> 220 && same_as<typename _Tp::endpoint::protocol_type, _Tp>; 221 222 // Protocol requirements for extensible implementations. 223 template<typename _Tp> 224 concept __protocol = __protocol_base<_Tp> 225 && __endpoint<typename _Tp::endpoint> 226 && requires (const _Tp __a) { 227 { __a.family() } -> same_as<int>; 228 { __a.type() } -> same_as<int>; 229 { __a.protocol() } -> same_as<int>; 230 }; 231 232 template<typename _Tp> 233 concept __acceptable_protocol = __protocol<_Tp> 234 && requires { typename _Tp::socket; } 235 && move_constructible<typename _Tp::socket> 236 && derived_from<typename _Tp::socket, basic_socket<_Tp>>; 237 238 template<typename _Tp> 239 concept __inet_protocol = __acceptable_protocol<_Tp> 240 && equality_comparable<_Tp> && requires { 241 { _Tp::v4() } -> same_as<_Tp>; 242 { _Tp::v6() } -> same_as<_Tp>; 243 typename _Tp::resolver; 244 } 245 && same_as<typename _Tp::resolver, ip::basic_resolver<_Tp>>; 246 247 #else 248 // Check Endpoint requirements for extensible implementations 249 template<typename _Tp, typename = void> 250 struct __is_endpoint : false_type 251 { }; 252 253 template<typename _Tp> 254 auto 255 __endpoint_reqs(const _Tp* __a = nullptr, _Tp* __b = nullptr) 256 -> enable_if_t<__and_< 257 is_default_constructible<_Tp>, __is_value_constructible<_Tp>, 258 is_same<decltype(__a->protocol()), typename _Tp::protocol_type>, 259 is_same<decltype(__a->data()), const void*>, 260 is_same<decltype(__b->data()), void*>, 261 is_same<decltype(__a->size()), size_t>, 262 is_same<decltype(__a->capacity()), size_t> 263 >::value, 264 __void_t< typename _Tp::protocol_type::endpoint, 265 decltype(__b->resize(std::declval<size_t>())) >>; 266 267 template<typename _Tp> 268 struct __is_endpoint<_Tp, decltype(__detail::__endpoint_reqs<_Tp>())> 269 : true_type 270 { }; 271 272 // Check Protocol requirements for extensible implementations. 273 template<typename _Tp, typename = void> 274 struct __is_protocol 275 : false_type { }; 276 277 template<typename _Tp> 278 auto 279 __protocol_reqs(const _Tp* __a = nullptr) 280 -> enable_if_t<__and_< 281 is_copy_constructible<_Tp>, is_copy_assignable<_Tp>, 282 __is_endpoint<typename _Tp::endpoint>, 283 is_same<decltype(__a->family()), int>, 284 is_same<decltype(__a->type()), int>, 285 is_same<decltype(__a->protocol()), int> 286 >::value>; 287 288 template<typename _Tp> 289 struct __is_protocol<_Tp, decltype(__detail::__protocol_reqs<_Tp>())> 290 : true_type 291 { }; 292 293 // Check AcceptableProtocol requirements 294 template<typename _Tp, typename = void> 295 struct __is_acceptable_protocol 296 : false_type { }; 297 298 template<typename _Tp> 299 struct __is_acceptable_protocol<_Tp, __void_t<typename _Tp::socket>> 300 : __and_<__is_protocol<_Tp>, is_move_constructible<typename _Tp::socket>, 301 is_convertible<typename _Tp::socket*, basic_socket<_Tp>*>>::type 302 { }; 303 304 // Check InternetProtocol requirements 305 template<typename _Tp, typename = void> 306 struct __is_inet_protocol 307 : false_type { }; 308 309 template<typename _Tp> 310 auto 311 __inet_proto_reqs(const _Tp* __a = nullptr) 312 -> enable_if_t<__and_< 313 __is_acceptable_protocol<_Tp>, 314 is_same<typename _Tp::resolver, ip::basic_resolver<_Tp>>, 315 is_same<decltype(_Tp::v4()), _Tp>, 316 is_same<decltype(_Tp::v6()), _Tp>, 317 is_convertible<decltype(*__a == *__a), bool>, 318 is_convertible<decltype(*__a != *__a), bool> 319 >::value>; 320 321 template<typename _Tp> 322 struct __is_inet_protocol<_Tp, decltype(__inet_proto_reqs<_Tp>())> 323 : true_type { }; 324 325 // Variable templates for requirements (with same names as concepts above). 326 327 template<typename _Tp> 328 constexpr bool __endpoint = __is_endpoint<_Tp>::value; 329 template<typename _Tp> 330 constexpr bool __protocol = __is_protocol<_Tp>::value; 331 template<typename _Tp> 332 constexpr bool __acceptable_protocol = __is_acceptable_protocol<_Tp>::value; 333 #endif 334 } // namespace __detail 335 336 /// @} 337 338 } // namespace v1 339 } // namespace net 340 } // namespace experimental 341 _GLIBCXX_END_NAMESPACE_VERSION 342 } // namespace std 343 344 #endif // C++14 345 346 #endif // _GLIBCXX_EXPERIMENTAL_NET_H
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
