Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:44
📄 algorithm // <experimental/algorithm> -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/algorithm * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_ALGORITHM #define _GLIBCXX_EXPERIMENTAL_ALGORITHM 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <algorithm> #include <experimental/bits/lfts_config.h> #include <experimental/random> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _ForwardIterator, typename _Searcher> inline _ForwardIterator search(_ForwardIterator __first, _ForwardIterator __last, const _Searcher& __searcher) { return __searcher(__first, __last); } #define __cpp_lib_experimental_sample 201402 /// Take a random sample from a population. template<typename _PopulationIterator, typename _SampleIterator, typename _Distance, typename _UniformRandomNumberGenerator> _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, _SampleIterator __out, _Distance __n, _UniformRandomNumberGenerator&& __g) { using __pop_cat = typename std::iterator_traits<_PopulationIterator>::iterator_category; using __samp_cat = typename std::iterator_traits<_SampleIterator>::iterator_category; static_assert( __or_<is_convertible<__pop_cat, forward_iterator_tag>, is_convertible<__samp_cat, random_access_iterator_tag>>::value, "output range must use a RandomAccessIterator when input range" " does not meet the ForwardIterator requirements"); static_assert(is_integral<_Distance>::value, "sample size must be an integer type"); typename iterator_traits<_PopulationIterator>::difference_type __d = __n; return _GLIBCXX_STD_A:: __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d, std::forward<_UniformRandomNumberGenerator>(__g)); } template<typename _PopulationIterator, typename _SampleIterator, typename _Distance> inline _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, _SampleIterator __out, _Distance __n) { return experimental::sample(__first, __last, __out, __n, _S_randint_engine()); } template<typename _RandomAccessIterator> inline void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::shuffle(__first, __last, _S_randint_engine()); } } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_ALGORITHM	3.6 KB	2025-09-15 15:41
📄 any // <experimental/any> -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/any * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_ANY #define _GLIBCXX_EXPERIMENTAL_ANY 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <typeinfo> #include <new> #include <utility> #include <type_traits> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { /* * @defgroup any Type-safe container of any type * @ingroup libfund-ts * * A type-safe container for single values of value types, as * described in n3804 "Any Library Proposal (Revision 3)". * * @{ / #define __cpp_lib_experimental_any 201411 /* * @brief Exception class thrown by a failed @c any_cast * @ingroup exceptions / class bad_any_cast : public bad_cast { public: virtual const char what() const noexcept { return "bad any_cast"; } }; /// @cond undocumented [[gnu::noreturn]] inline void __throw_bad_any_cast() { #if __cpp_exceptions throw bad_any_cast{}; #else __builtin_abort(); #endif } /// @endcond /** * @brief A type-safe container of any type. * * An @c any object's state is either empty or it stores a contained object * of CopyConstructible type. / class any { // Holds either pointer to a heap object or the contained object itself. union _Storage { // This constructor intentionally doesn't initialize anything. _Storage() = default; // Prevent trivial copies of this type, buffer might hold a non-POD. _Storage(const _Storage&) = delete; _Storage& operator=(const _Storage&) = delete; void _M_ptr; aligned_storage<sizeof(_M_ptr), alignof(void)>::type _M_buffer; }; template<typename _Tp, typename _Safe = is_nothrow_move_constructible<_Tp>, bool _Fits = (sizeof(_Tp) <= sizeof(_Storage)) && (alignof(_Tp) <= alignof(_Storage))> using _Internal = std::integral_constant<bool, _Safe::value && _Fits>; template<typename _Tp> struct _Manager_internal; // uses small-object optimization template<typename _Tp> struct _Manager_external; // creates contained object on the heap template<typename _Tp> using _Manager = conditional_t<_Internal<_Tp>::value, _Manager_internal<_Tp>, _Manager_external<_Tp>>; template<typename _Tp, typename _Decayed = decay_t<_Tp>> using _Decay = enable_if_t<!is_same<_Decayed, any>::value, _Decayed>; public: // construct/destruct /// Default constructor, creates an empty object. any() noexcept : _M_manager(nullptr) { } /// Copy constructor, copies the state of @p __other any(const any& __other) { if (__other.empty()) _M_manager = nullptr; else { _Arg __arg; __arg._M_any = this; __other._M_manager(_Op_clone, &__other, &__arg); } } /* * @brief Move constructor, transfer the state from @p __other * * @post @c __other.empty() (this postcondition is a GNU extension) / any(any&& __other) noexcept { if (__other.empty()) _M_manager = nullptr; else { _Arg __arg; __arg._M_any = this; __other._M_manager(_Op_xfer, &__other, &__arg); } } /// Construct with a copy of @p __value as the contained object. template <typename _ValueType, typename _Tp = _Decay<_ValueType>, typename _Mgr = _Manager<_Tp>, typename enable_if<is_constructible<_Tp, _ValueType&&>::value, bool>::type = true> any(_ValueType&& __value) : _M_manager(&_Mgr::_S_manage) { _Mgr::_S_create(_M_storage, std::forward<_ValueType>(__value)); static_assert(is_copy_constructible<_Tp>::value, "The contained object must be CopyConstructible"); } /// Construct with a copy of @p __value as the contained object. template <typename _ValueType, typename _Tp = _Decay<_ValueType>, typename _Mgr = _Manager<_Tp>, typename enable_if<!is_constructible<_Tp, _ValueType&&>::value, bool>::type = false> any(_ValueType&& __value) : _M_manager(&_Mgr::_S_manage) { _Mgr::_S_create(_M_storage, __value); static_assert(is_copy_constructible<_Tp>::value, "The contained object must be CopyConstructible"); } /// Destructor, calls @c clear() ~any() { clear(); } // assignments /// Copy the state of another object. any& operator=(const any& __rhs) { this = any(__rhs); return this; } /* * @brief Move assignment operator * * @post @c __rhs.empty() (not guaranteed for other implementations) / any& operator=(any&& __rhs) noexcept { if (__rhs.empty()) clear(); else if (this != &__rhs) { clear(); _Arg __arg; __arg._M_any = this; __rhs._M_manager(_Op_xfer, &__rhs, &__arg); } return this; } /// Store a copy of @p __rhs as the contained object. template<typename _ValueType> enable_if_t<!is_same<any, decay_t<_ValueType>>::value, any&> operator=(_ValueType&& __rhs) { this = any(std::forward<_ValueType>(__rhs)); return this; } // modifiers /// If not empty, destroy the contained object. void clear() noexcept { if (!empty()) { _M_manager(_Op_destroy, this, nullptr); _M_manager = nullptr; } } /// Exchange state with another object. void swap(any& __rhs) noexcept { if (empty() && __rhs.empty()) return; if (!empty() && !__rhs.empty()) { if (this == &__rhs) return; any __tmp; _Arg __arg; __arg._M_any = &__tmp; __rhs._M_manager(_Op_xfer, &__rhs, &__arg); __arg._M_any = &__rhs; _M_manager(_Op_xfer, this, &__arg); __arg._M_any = this; __tmp._M_manager(_Op_xfer, &__tmp, &__arg); } else { any* __empty = empty() ? this : &__rhs; any* __full = empty() ? &__rhs : this; _Arg __arg; __arg._M_any = __empty; __full->_M_manager(_Op_xfer, __full, &__arg); } } // observers /// Reports whether there is a contained object or not. _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_manager == nullptr; } #if __cpp_rtti /// The @c typeid of the contained object, or @c typeid(void) if empty. const type_info& type() const noexcept { if (empty()) return typeid(void); _Arg __arg; _M_manager(_Op_get_type_info, this, &__arg); return __arg._M_typeinfo; } #endif template<typename _Tp> static constexpr bool __is_valid_cast() { return __or_<is_reference<_Tp>, is_copy_constructible<_Tp>>::value; } private: enum _Op { _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer }; union _Arg { void _M_obj; const std::type_info* _M_typeinfo; any* _M_any; }; void (_M_manager)(_Op, const any, _Arg); _Storage _M_storage; template<typename _Tp> friend enable_if_t<is_object<_Tp>::value, void> __any_caster(const any* __any); // Manage in-place contained object. template<typename _Tp> struct _Manager_internal { static void _S_manage(_Op __which, const any* __anyp, _Arg* __arg); template<typename _Up> static void _S_create(_Storage& __storage, _Up&& __value) { void* __addr = &__storage._M_buffer; ::new (__addr) _Tp(std::forward<_Up>(__value)); } }; // Manage external contained object. template<typename _Tp> struct _Manager_external { static void _S_manage(_Op __which, const any* __anyp, _Arg* __arg); template<typename _Up> static void _S_create(_Storage& __storage, _Up&& __value) { __storage._M_ptr = new _Tp(std::forward<_Up>(__value)); } }; }; /// Exchange the states of two @c any objects. inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); } /** * @brief Access the contained object. * * @tparam _ValueType A const-reference or CopyConstructible type. * @param __any The object to access. * @return The contained object. * @throw bad_any_cast If <code> * __any.type() != typeid(remove_reference_t<_ValueType>) * </code> / template<typename _ValueType> inline _ValueType any_cast(const any& __any) { static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); auto __p = any_cast<add_const_t<remove_reference_t<_ValueType>>>(&__any); if (__p) return __p; __throw_bad_any_cast(); } /** * @brief Access the contained object. * * @tparam _ValueType A reference or CopyConstructible type. * @param __any The object to access. * @return The contained object. * @throw bad_any_cast If <code> * __any.type() != typeid(remove_reference_t<_ValueType>) * </code> * * @{ / template<typename _ValueType> inline _ValueType any_cast(any& __any) { static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); auto __p = any_cast<remove_reference_t<_ValueType>>(&__any); if (__p) return __p; __throw_bad_any_cast(); } template<typename _ValueType, typename enable_if<!is_move_constructible<_ValueType>::value \|\| is_lvalue_reference<_ValueType>::value, bool>::type = true> inline _ValueType any_cast(any&& __any) { static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); auto __p = any_cast<remove_reference_t<_ValueType>>(&__any); if (__p) return __p; __throw_bad_any_cast(); } template<typename _ValueType, typename enable_if<is_move_constructible<_ValueType>::value && !is_lvalue_reference<_ValueType>::value, bool>::type = false> inline _ValueType any_cast(any&& __any) { static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); auto __p = any_cast<remove_reference_t<_ValueType>>(&__any); if (__p) return std::move(__p); __throw_bad_any_cast(); } /// @} /// @cond undocumented template<typename _Tp> enable_if_t<is_object<_Tp>::value, void> __any_caster(const any __any) { // any_cast<T> returns non-null if __any->type() == typeid(T) and // typeid(T) ignores cv-qualifiers so remove them: using _Up = remove_cv_t<_Tp>; // The contained value has a decayed type, so if decay_t<U> is not U, // then it's not possible to have a contained value of type U. using __does_not_decay = is_same<decay_t<_Up>, _Up>; // Only copy constructible types can be used for contained values. using __is_copyable = is_copy_constructible<_Up>; // If the type _Tp could never be stored in an any we don't want to // instantiate _Manager<_Tp>, so use _Manager<any::_Op> instead, which // is explicitly specialized and has a no-op _S_manage function. using _Vp = conditional_t<__and_<__does_not_decay, __is_copyable>::value, _Up, any::_Op>; // First try comparing function addresses, which works without RTTI if (__any->_M_manager == &any::_Manager<_Vp>::_S_manage #if __cpp_rtti \|\| __any->type() == typeid(_Tp) #endif ) { any::_Arg __arg; __any->_M_manager(any::_Op_access, __any, &__arg); return __arg._M_obj; } return nullptr; } // This overload exists so that std::any_cast<void()()>(a) is well-formed. template<typename _Tp> enable_if_t<!is_object<_Tp>::value, _Tp> __any_caster(const any) noexcept { return nullptr; } /// @endcond /* * @brief Access the contained object. * * @tparam _ValueType The type of the contained object. * @param __any A pointer to the object to access. * @return The address of the contained object if <code> * __any != nullptr && __any.type() == typeid(_ValueType) * </code>, otherwise a null pointer. * * @{ / template<typename _ValueType> inline const _ValueType any_cast(const any* __any) noexcept { if (__any) return static_cast<_ValueType>(__any_caster<_ValueType>(__any)); return nullptr; } template<typename _ValueType> inline _ValueType any_cast(any* __any) noexcept { if (__any) return static_cast<_ValueType>(__any_caster<_ValueType>(__any)); return nullptr; } /// @} template<typename _Tp> void any::_Manager_internal<_Tp>:: _S_manage(_Op __which, const any __any, _Arg* __arg) { // The contained object is in _M_storage._M_buffer auto __ptr = reinterpret_cast<const _Tp>(&__any->_M_storage._M_buffer); switch (__which) { case _Op_access: __arg->_M_obj = const_cast<_Tp>(__ptr); break; case _Op_get_type_info: #if __cpp_rtti __arg->_M_typeinfo = &typeid(_Tp); #endif break; case _Op_clone: ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(__ptr); __arg->_M_any->_M_manager = __any->_M_manager; break; case _Op_destroy: __ptr->~_Tp(); break; case _Op_xfer: ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp (std::move(const_cast<_Tp>(__ptr))); __ptr->~_Tp(); __arg->_M_any->_M_manager = __any->_M_manager; const_cast<any>(__any)->_M_manager = nullptr; break; } } template<typename _Tp> void any::_Manager_external<_Tp>:: _S_manage(_Op __which, const any* __any, _Arg* __arg) { // The contained object is _M_storage._M_ptr auto __ptr = static_cast<const _Tp>(__any->_M_storage._M_ptr); switch (__which) { case _Op_access: __arg->_M_obj = const_cast<_Tp>(__ptr); break; case _Op_get_type_info: #if __cpp_rtti __arg->_M_typeinfo = &typeid(_Tp); #endif break; case _Op_clone: __arg->_M_any->_M_storage._M_ptr = new _Tp(__ptr); __arg->_M_any->_M_manager = __any->_M_manager; break; case _Op_destroy: delete __ptr; break; case _Op_xfer: __arg->_M_any->_M_storage._M_ptr = __any->_M_storage._M_ptr; __arg->_M_any->_M_manager = __any->_M_manager; const_cast<any>(__any)->_M_manager = nullptr; break; } } // Dummy specialization used by __any_caster. template<> struct any::_Manager_internal<any::_Op> { static void _S_manage(_Op, const any, _Arg*) { } }; /// @} group any } // namespace fundamentals_v1 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_ANY	15.64 KB	2025-09-15 15:41
📄 array // <experimental/array> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/array * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_ARRAY #define _GLIBCXX_EXPERIMENTAL_ARRAY 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <array> #include <experimental/type_traits> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_make_array 201505 /* * @defgroup make_array Array creation functions * @ingroup libfund-ts * * Array creation functions as described in N4529, * Working Draft, C++ Extensions for Library Fundamentals, Version 2 * * @{ */ template<typename _Dest, typename... _Types> struct __make_array_elem { using type = _Dest; }; template<typename... _Types> struct __make_array_elem<void, _Types...> : common_type<_Types...> { template <typename> struct __is_reference_wrapper : false_type {}; template <typename _Up> struct __is_reference_wrapper<reference_wrapper<_Up>> : true_type {}; static_assert(!__or_<__is_reference_wrapper<decay_t<_Types>>...>::value, "make_array must be used with an explicit target type when" "any of the arguments is a reference_wrapper"); }; /// Create a std::array from a variable-length list of arguments. template <typename _Dest = void, typename... _Types> constexpr array<typename __make_array_elem<_Dest, _Types...>::type, sizeof...(_Types)> make_array(_Types&&... __t) { return {{ std::forward<_Types>(__t)... }}; } template <typename _Tp, size_t _Nm, size_t... _Idx> constexpr array<remove_cv_t<_Tp>, _Nm> __to_array(_Tp (&__a)[_Nm], index_sequence<_Idx...>) { return {{__a[_Idx]...}}; } /// Create a std::array from an array. template <typename _Tp, size_t _Nm> constexpr array<remove_cv_t<_Tp>, _Nm> to_array(_Tp (&__a)[_Nm]) noexcept(is_nothrow_constructible<remove_cv_t<_Tp>, _Tp&>::value) { return experimental::__to_array(__a, make_index_sequence<_Nm>{}); } /// @} group make_array } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_ARRAY	3.29 KB	2025-09-15 15:41
📁 bits	-	2026-03-21 15:44
📄 buffer // <experimental/buffer> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/buffer * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_BUFFER #define _GLIBCXX_EXPERIMENTAL_BUFFER 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <array> #include <string> #include <system_error> #include <vector> #include <cstring> #include <experimental/string_view> #include <experimental/bits/net.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @addtogroup networking-ts * @{ / enum class stream_errc { // TODO decide values eof = 1, not_found = 2 }; const error_category& stream_category() noexcept // TODO not inline { struct __cat : error_category { const char name() const noexcept { return "stream"; } std::string message(int __e) const { if (__e == (int)stream_errc::eof) return "EOF"; else if (__e == (int)stream_errc::not_found) return "not found"; return "stream"; } virtual void __message(int) { } // TODO dual ABI XXX }; static __cat __c; return __c; } inline error_code make_error_code(stream_errc __e) noexcept { return error_code(static_cast<int>(__e), stream_category()); } inline error_condition make_error_condition(stream_errc __e) noexcept { return error_condition(static_cast<int>(__e), stream_category()); } class mutable_buffer { public: // constructors: mutable_buffer() noexcept : _M_data(), _M_size() { } mutable_buffer(void* __p, size_t __n) noexcept : _M_data(__p), _M_size(__n) { } // members: void* data() const noexcept { return _M_data; } size_t size() const noexcept { return _M_size; } private: void* _M_data; size_t _M_size; }; class const_buffer { public: // constructors: const_buffer() noexcept : _M_data(), _M_size() { } const_buffer(const void* __p, size_t __n) noexcept : _M_data(__p), _M_size(__n) { } const_buffer(const mutable_buffer& __b) noexcept : _M_data(__b.data()), _M_size(__b.size()) { } // members: const void* data() const noexcept { return _M_data; } size_t size() const noexcept { return _M_size; } private: const void* _M_data; size_t _M_size; }; /** @brief buffer sequence access * * Uniform access to types that meet the BufferSequence requirements. * @{ / inline const mutable_buffer buffer_sequence_begin(const mutable_buffer& __b) { return std::addressof(__b); } inline const const_buffer* buffer_sequence_begin(const const_buffer& __b) { return std::addressof(__b); } inline const mutable_buffer* buffer_sequence_end(const mutable_buffer& __b) { return std::addressof(__b) + 1; } inline const const_buffer* buffer_sequence_end(const const_buffer& __b) { return std::addressof(__b) + 1; } template<typename _Cont> auto buffer_sequence_begin(_Cont& __c) -> decltype(__c.begin()) { return __c.begin(); } template<typename _Cont> auto buffer_sequence_begin(const _Cont& __c) -> decltype(__c.begin()) { return __c.begin(); } template<typename _Cont> auto buffer_sequence_end(_Cont& __c) -> decltype(__c.end()) { return __c.end(); } template<typename _Cont> auto buffer_sequence_end(const _Cont& __c) -> decltype(__c.end()) { return __c.end(); } /// @} /** @brief buffer type traits * * @{ / template<typename _Tp, typename _Buffer, typename _Begin = decltype(net::buffer_sequence_begin(std::declval<_Tp&>())), typename _End = decltype(net::buffer_sequence_end(std::declval<_Tp&>()))> using __buffer_sequence = enable_if_t<__and_< __is_value_constructible<_Tp>, is_same<_Begin, _End>, is_convertible<typename iterator_traits<_Begin>::value_type, _Buffer> >::value>; template<typename _Tp, typename _Buffer, typename = void> struct __is_buffer_sequence : false_type { }; template<typename _Tp, typename _Buffer> struct __is_buffer_sequence<_Tp, _Buffer, __buffer_sequence<_Tp, _Buffer>> : true_type { }; template<typename _Tp> struct is_mutable_buffer_sequence : __is_buffer_sequence<_Tp, mutable_buffer>::type { }; template<typename _Tp> struct is_const_buffer_sequence : __is_buffer_sequence<_Tp, const_buffer>::type { }; template<typename _Tp> constexpr bool is_mutable_buffer_sequence_v = is_mutable_buffer_sequence<_Tp>::value; template<typename _Tp> constexpr bool is_const_buffer_sequence_v = is_const_buffer_sequence<_Tp>::value; template<typename _Tp, typename = void> struct __is_dynamic_buffer_impl : false_type { }; // Check DynamicBuffer requirements. template<typename _Tp, typename _Up = remove_const_t<_Tp>> auto __dynamic_buffer_reqs(_Up __x = 0, const _Up* __x1 = 0, size_t __n = 0) -> enable_if_t<__and_< is_move_constructible<_Up>, is_const_buffer_sequence<typename _Tp::const_buffers_type>, is_mutable_buffer_sequence<typename _Tp::mutable_buffers_type>, is_same<decltype(__x1->size()), size_t>, is_same<decltype(__x1->max_size()), size_t>, is_same<decltype(__x1->capacity()), size_t>, is_same<decltype(__x1->data()), typename _Tp::const_buffers_type>, is_same<decltype(__x->prepare(__n)), typename _Tp::mutable_buffers_type>, is_void<decltype(__x->commit(__n), __x->consume(__n), void())> >::value>; template<typename _Tp> struct __is_dynamic_buffer_impl<_Tp, decltype(__dynamic_buffer_reqs<_Tp>())> : true_type { }; template<typename _Tp> struct is_dynamic_buffer : __is_dynamic_buffer_impl<_Tp>::type { }; template<typename _Tp> constexpr bool is_dynamic_buffer_v = is_dynamic_buffer<_Tp>::value; /// @} /// buffer size template<typename _ConstBufferSequence> size_t buffer_size(const _ConstBufferSequence& __buffers) noexcept { size_t __total_size = 0; auto __i = net::buffer_sequence_begin(__buffers); const auto __end = net::buffer_sequence_end(__buffers); for (; __i != __end; ++__i) __total_size += const_buffer(__i).size(); return __total_size; } template<typename _ConstBufferSequence> bool __buffer_empty(const _ConstBufferSequence& __buffers) noexcept { auto __i = net::buffer_sequence_begin(__buffers); const auto __end = net::buffer_sequence_end(__buffers); for (; __i != __end; ++__i) if (const_buffer(__i).size() != 0) return false; return true; } // buffer copy: template<typename _MutableBufferSequence, typename _ConstBufferSequence> size_t buffer_copy(const _MutableBufferSequence& __dest, const _ConstBufferSequence& __source, size_t __max_size) noexcept { size_t __total_size = 0; auto __to_i = net::buffer_sequence_begin(__dest); const auto __to_end = net::buffer_sequence_end(__dest); auto __from_i = net::buffer_sequence_begin(__source); const auto __from_end = net::buffer_sequence_end(__source); mutable_buffer __to; const_buffer __from; while (((__from_i != __from_end && __to_i != __to_end) \|\| (__from.size() && __to.size())) && __total_size < __max_size) { if (__from.size() == 0) __from = const_buffer{__from_i++}; if (__to.size() == 0) __to = mutable_buffer{__to_i++}; size_t __n = std::min(__from.size(), __to.size()); __n = std::min(__n, __max_size - __total_size); std::memcpy(__to.data(), __from.data(), __n); __from = { (const char)__from.data() + __n, __from.size() - __n }; __to = { (char)__to.data() + __n, __to.size() - __n }; __total_size += __n; } return __total_size; } template<typename _MutableBufferSequence, typename _ConstBufferSequence> inline size_t buffer_copy(const _MutableBufferSequence& __dest, const _ConstBufferSequence& __source) noexcept { return net::buffer_copy(__dest, __source, size_t(-1)); } // buffer arithmetic: inline mutable_buffer operator+(const mutable_buffer& __b, size_t __n) noexcept { if (__n > __b.size()) __n = __b.size(); return { static_cast<char>(__b.data()) + __n, __b.size() - __n }; } inline mutable_buffer operator+(size_t __n, const mutable_buffer& __b) noexcept { return __b + __n; } inline const_buffer operator+(const const_buffer& __b, size_t __n) noexcept { if (__n > __b.size()) __n = __b.size(); return { static_cast<const char>(__b.data()) + __n, __b.size() - __n }; } inline const_buffer operator+(size_t __n, const const_buffer& __b) noexcept { return __b + __n; } // buffer creation: inline mutable_buffer buffer(void* __p, size_t __n) noexcept { return { __p, __n }; } inline const_buffer buffer(const void* __p, size_t __n) noexcept { return { __p, __n }; } inline mutable_buffer buffer(const mutable_buffer& __b) noexcept { return __b; } inline mutable_buffer buffer(const mutable_buffer& __b, size_t __n) noexcept { return { __b.data(), std::min(__b.size(), __n) }; } inline const_buffer buffer(const const_buffer& __b) noexcept { return __b; } inline const_buffer buffer(const const_buffer& __b, size_t __n) noexcept { return { __b.data(), std::min(__b.size(), __n) }; } template<typename _Tp> inline mutable_buffer __to_mbuf(_Tp* __data, size_t __n) { return { __n ? __data : nullptr, __n * sizeof(_Tp) }; } template<typename _Tp> inline const_buffer __to_cbuf(const _Tp* __data, size_t __n) { return { __n ? __data : nullptr, __n * sizeof(_Tp) }; } template<typename _Tp, size_t _Nm> inline mutable_buffer buffer(_Tp (&__data)[_Nm]) noexcept { return net::__to_mbuf(__data, _Nm); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(const _Tp (&__data)[_Nm]) noexcept { return net::__to_cbuf(__data, _Nm); } template<typename _Tp, size_t _Nm> inline mutable_buffer buffer(array<_Tp, _Nm>& __data) noexcept { return net::__to_mbuf(__data.data(), _Nm); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(array<const _Tp, _Nm>& __data) noexcept { return net::__to_cbuf(__data.data(), __data.size()); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(const array<_Tp, _Nm>& __data) noexcept { return net::__to_cbuf(__data.data(), __data.size()); } template<typename _Tp, typename _Allocator> inline mutable_buffer buffer(vector<_Tp, _Allocator>& __data) noexcept { return net::__to_mbuf(__data.data(), __data.size()); } template<typename _Tp, typename _Allocator> inline const_buffer buffer(const vector<_Tp, _Allocator>& __data) noexcept { return net::__to_cbuf(__data.data(), __data.size()); } template<typename _CharT, typename _Traits, typename _Allocator> inline mutable_buffer buffer(basic_string<_CharT, _Traits, _Allocator>& __data) noexcept { return net::__to_mbuf(&__data.front(), __data.size()); } template<typename _CharT, typename _Traits, typename _Allocator> inline const_buffer buffer(const basic_string<_CharT, _Traits, _Allocator>& __data) noexcept { return net::__to_cbuf(&__data.front(), __data.size()); } template<typename _CharT, typename _Traits> inline const_buffer buffer(basic_string_view<_CharT, _Traits> __data) noexcept { return net::__to_cbuf(__data.data(), __data.size()); } template<typename _Tp, size_t _Nm> inline mutable_buffer buffer(_Tp (&__data)[_Nm], size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(const _Tp (&__data)[_Nm], size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, size_t _Nm> inline mutable_buffer buffer(array<_Tp, _Nm>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(array<const _Tp, _Nm>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, size_t _Nm> inline const_buffer buffer(const array<_Tp, _Nm>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, typename _Allocator> inline mutable_buffer buffer(vector<_Tp, _Allocator>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _Tp, typename _Allocator> inline const_buffer buffer(const vector<_Tp, _Allocator>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_Tp)); } template<typename _CharT, typename _Traits, typename _Allocator> inline mutable_buffer buffer(basic_string<_CharT, _Traits, _Allocator>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_CharT)); } template<typename _CharT, typename _Traits, typename _Allocator> inline const_buffer buffer(const basic_string<_CharT, _Traits, _Allocator>& __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_CharT)); } template<typename _CharT, typename _Traits> inline const_buffer buffer(basic_string_view<_CharT, _Traits> __data, size_t __n) noexcept { return buffer(net::buffer(__data), __n * sizeof(_CharT)); } template<typename _Sequence> class __dynamic_buffer_base { public: // types: using const_buffers_type = const_buffer; using mutable_buffers_type = mutable_buffer; // constructors: explicit __dynamic_buffer_base(_Sequence& __seq) noexcept : _M_seq(__seq), _M_size(__seq.size()), _M_max_size(__seq.max_size()) { } __dynamic_buffer_base(_Sequence& __seq, size_t __maximum_size) noexcept : _M_seq(__seq), _M_size(__seq.size()), _M_max_size(__maximum_size) { __glibcxx_assert(__seq.size() <= __maximum_size); } __dynamic_buffer_base(__dynamic_buffer_base&&) = default; // members: size_t size() const noexcept { return _M_size; } size_t max_size() const noexcept { return _M_max_size; } size_t capacity() const noexcept { return _M_seq.capacity(); } const_buffers_type data() const noexcept { return net::buffer(_M_seq, _M_size); } mutable_buffers_type prepare(size_t __n) { if ((_M_size + __n) > _M_max_size) __throw_length_error("dynamic_vector_buffer::prepare"); _M_seq.resize(_M_size + __n); return buffer(net::buffer(_M_seq) + _M_size, __n); } void commit(size_t __n) { _M_size += std::min(__n, _M_seq.size() - _M_size); _M_seq.resize(_M_size); } void consume(size_t __n) { size_t __m = std::min(__n, _M_size); _M_seq.erase(_M_seq.begin(), _M_seq.begin() + __m); _M_size -= __m; } private: _Sequence& _M_seq; size_t _M_size; const size_t _M_max_size; }; template<typename _Tp, typename _Allocator> class dynamic_vector_buffer : public __dynamic_buffer_base<vector<_Tp, _Allocator>> { public: using __dynamic_buffer_base<vector<_Tp, _Allocator>>::__dynamic_buffer_base; }; template<typename _CharT, typename _Traits, typename _Allocator> class dynamic_string_buffer : public __dynamic_buffer_base<basic_string<_CharT, _Traits, _Allocator>> { public: using __dynamic_buffer_base<basic_string<_CharT, _Traits, _Allocator>>:: __dynamic_buffer_base; }; // dynamic buffer creation: template<typename _Tp, typename _Allocator> inline dynamic_vector_buffer<_Tp, _Allocator> dynamic_buffer(vector<_Tp, _Allocator>& __vec) noexcept { return dynamic_vector_buffer<_Tp, _Allocator>{__vec}; } template<typename _Tp, typename _Allocator> inline dynamic_vector_buffer<_Tp, _Allocator> dynamic_buffer(vector<_Tp, _Allocator>& __vec, size_t __n) noexcept { return {__vec, __n}; } template<typename _CharT, typename _Traits, typename _Allocator> inline dynamic_string_buffer<_CharT, _Traits, _Allocator> dynamic_buffer(basic_string<_CharT, _Traits, _Allocator>& __str) noexcept { return dynamic_string_buffer<_CharT, _Traits, _Allocator>{__str}; } template<typename _CharT, typename _Traits, typename _Allocator> inline dynamic_string_buffer<_CharT, _Traits, _Allocator> dynamic_buffer(basic_string<_CharT, _Traits, _Allocator>& __str, size_t __n) noexcept { return {__str, __n}; } class transfer_all { public: size_t operator()(const error_code& __ec, size_t) const { return !__ec ? 1500 : 0; } }; class transfer_at_least { public: explicit transfer_at_least(size_t __m) : _M_minimum(__m) { } size_t operator()(const error_code& __ec, size_t __n) const { return !__ec && __n < _M_minimum ? _M_minimum - __n : 0; } private: size_t _M_minimum; }; class transfer_exactly { public: explicit transfer_exactly(size_t __e) : _M_exact(__e) { } size_t operator()(const error_code& __ec, size_t __n) const { size_t _Nm = -1; return !__ec && __n < _M_exact ? std::min(_M_exact - __n, _Nm) : 0; } private: size_t _M_exact; }; /** @brief synchronous read operations * @{ / template<typename _SyncReadStream, typename _MutableBufferSequence, typename _CompletionCondition> enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value, size_t> read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers, _CompletionCondition __completion_condition, error_code& __ec) { __ec.clear(); auto __i = net::buffer_sequence_begin(__buffers); auto __end = net::buffer_sequence_end(__buffers); mutable_buffer __to; size_t __total = 0; size_t __n; while ((__n = __completion_condition(__ec, __total)) && (__i != __end \|\| __to.size())) { if (__to.size() == 0) __to = mutable_buffer(__i++); __n = __stream.read_some(buffer(__to, __n), __ec); __to = __to + __n; __total += __n; } return __total; } template<typename _SyncReadStream, typename _MutableBufferSequence> inline enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value, size_t> read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers) { error_code __ec; return net::read(__stream, __buffers, transfer_all{}, __ec); } template<typename _SyncReadStream, typename _MutableBufferSequence> inline enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value, size_t> read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers, error_code& __ec) { return net::read(__stream, __buffers, transfer_all{}, __ec); } template<typename _SyncReadStream, typename _MutableBufferSequence, typename _CompletionCondition> inline enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value, size_t> read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers, _CompletionCondition __completion_condition) { error_code __ec; return net::read(__stream, __buffers, __completion_condition, __ec); } template<typename _SyncReadStream, typename _DynamicBuffer, typename _CompletionCondition> enable_if_t<is_dynamic_buffer<decay_t<_DynamicBuffer>>::value, size_t> read(_SyncReadStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition, error_code& __ec) { const size_t __limit = 64; __ec.clear(); size_t __cap = std::max(__b.capacity() - __b.size(), __limit); size_t __total = 0; size_t __n; while ((__n = __completion_condition(__ec, __total)) && __b.size() != __b.max_size()) { __n = std::min(__n, __b.max_size() - __b.size()); size_t __cap = std::max(__b.capacity() - __b.size(), __limit); mutable_buffer __to = __b.prepare(std::min(__cap, __n)); __n = __stream.read_some(__to, __ec); __to = __to + __n; __total += __n; __b.commit(__n); } return __total; } template<typename _SyncReadStream, typename _DynamicBuffer> inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t> read(_SyncReadStream& __stream, _DynamicBuffer&& __b) { error_code __ec; return net::read(__stream, __b, transfer_all{}, __ec); } template<typename _SyncReadStream, typename _DynamicBuffer> inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t> read(_SyncReadStream& __stream, _DynamicBuffer&& __b, error_code& __ec) { return net::read(__stream, __b, transfer_all{}, __ec); } template<typename _SyncReadStream, typename _DynamicBuffer, typename _CompletionCondition> inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t> read(_SyncReadStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition) { error_code __ec; return net::read(__stream, __b, __completion_condition, __ec); } /// @} /** @brief asynchronous read operations * @{ / template<typename _AsyncReadStream, typename _MutableBufferSequence, typename _CompletionCondition, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_read(_AsyncReadStream& __stream, const _MutableBufferSequence& __buffers, _CompletionCondition __completion_condition, _CompletionToken&& __token) { error_code __ec; } template<typename _AsyncReadStream, typename _MutableBufferSequence, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, size_t)> async_read(_AsyncReadStream& __stream, const _MutableBufferSequence& __buffers, _CompletionToken&& __token) { return net::async_read(__stream, __buffers, transfer_all{}, std::forward<_CompletionToken>(__token)); } template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionCondition, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_read(_AsyncReadStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition, _CompletionToken&& __token) { error_code __ec; } template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, size_t)> async_read(_AsyncReadStream& __stream, _DynamicBuffer&& __b, _CompletionToken&& __token) { return net::async_read(__stream, __b, transfer_all{}, std::forward<_CompletionToken>(__token)); } /// @} #if 0 /* @brief synchronous write operations: * @{ / template<typename _SyncWriteStream, typename _ConstBufferSequence> size_t write(_SyncWriteStream& __stream, const _ConstBufferSequence& __buffers); template<typename _SyncWriteStream, typename _ConstBufferSequence> size_t write(_SyncWriteStream& __stream, const _ConstBufferSequence& __buffers, error_code& __ec); template<typename _SyncWriteStream, typename _ConstBufferSequence, typename _CompletionCondition> size_t write(_SyncWriteStream& __stream, const _ConstBufferSequence& __buffers, _CompletionCondition __completion_condition); template<typename _SyncWriteStream, typename _ConstBufferSequence, typename _CompletionCondition> size_t write(_SyncWriteStream& __stream, const _ConstBufferSequence& __buffers, _CompletionCondition __completion_condition, error_code& __ec); template<typename _SyncWriteStream, typename _DynamicBuffer> size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b); template<typename _SyncWriteStream, typename _DynamicBuffer> size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b, error_code& __ec); template<typename _SyncWriteStream, typename _DynamicBuffer, typename _CompletionCondition> size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition); template<typename _SyncWriteStream, typename _DynamicBuffer, typename _CompletionCondition> size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition, error_code& __ec); /// @} /* @brief asynchronous write operations * @{ / template<typename _AsyncWriteStream, typename _ConstBufferSequence, typename _CompletionToken> DEDUCED async_write(_AsyncWriteStream& __stream, const _ConstBufferSequence& __buffers, _CompletionToken&& __token); template<typename _AsyncWriteStream, typename _ConstBufferSequence, typename _CompletionCondition, typename _CompletionToken> DEDUCED async_write(_AsyncWriteStream& __stream, const _ConstBufferSequence& __buffers, _CompletionCondition __completion_condition, _CompletionToken&& __token); template<typename _AsyncWriteStream, typename _DynamicBuffer, typename _CompletionToken> DEDUCED async_write(_AsyncWriteStream& __stream, _DynamicBuffer&& __b, _CompletionToken&& __token); template<typename _AsyncWriteStream, typename _DynamicBuffer, typename _CompletionCondition, typename _CompletionToken> DEDUCED async_write(_AsyncWriteStream& __stream, _DynamicBuffer&& __b, _CompletionCondition __completion_condition, _CompletionToken&& __token); /// @} /* @brief synchronous delimited read operations * @{ / template<typename _SyncReadStream, typename _DynamicBuffer> size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, char __delim); template<typename _SyncReadStream, typename _DynamicBuffer> size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, char __delim, error_code& __ec); template<typename _SyncReadStream, typename _DynamicBuffer> size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, string_view __delim); template<typename _SyncReadStream, typename _DynamicBuffer> size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, string_view __delim, error_code& __ec); /// @} /* @brief asynchronous delimited read operations * @{ */ template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionToken> DEDUCED async_read_until(_AsyncReadStream& __s, _DynamicBuffer&& __b, char __delim, _CompletionToken&& __token); template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionToken> DEDUCED async_read_until(_AsyncReadStream& __s, _DynamicBuffer&& __b, string_view __delim, _CompletionToken&& __token); /// @} #endif /// @} } // namespace v1 } // namespace net } // namespace experimental template<> struct is_error_code_enum<experimental::net::v1::stream_errc> : public true_type {}; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_BUFFER	28.05 KB	2025-09-15 15:41
📄 chrono // Variable Templates For chrono -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/chrono * This is a TS C++ Library header. * @ingroup libfund-ts */ // // N3932 Variable Templates For Type Traits (Revision 1) // #ifndef _GLIBCXX_EXPERIMENTAL_CHRONO #define _GLIBCXX_EXPERIMENTAL_CHRONO 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <chrono> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace chrono { namespace experimental { inline namespace fundamentals_v1 { // See C++14 20.12.4, customization traits template <typename _Rep> constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value; } // namespace fundamentals_v1 } // namespace experimental } // namespace chrono _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_CHRONO	1.91 KB	2025-09-15 15:41
📄 deque // <experimental/deque> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/deque * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_DEQUE #define _GLIBCXX_EXPERIMENTAL_DEQUE 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <deque> #include <algorithm> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Tp, typename _Alloc, typename _Predicate> inline void erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred) { __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); } template<typename _Tp, typename _Alloc, typename _Up> inline void erase(deque<_Tp, _Alloc>& __cont, const _Up& __value) { __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); } namespace pmr { template<typename _Tp> using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_DEQUE	2.24 KB	2025-09-15 15:41
📄 executor // <experimental/executor> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/executor * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_EXECUTOR #define _GLIBCXX_EXPERIMENTAL_EXECUTOR 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <algorithm> #include <condition_variable> #include <functional> #include <future> #include <list> #include <queue> #include <thread> #include <tuple> #include <unordered_map> #include <utility> #include <experimental/netfwd> #include <bits/unique_ptr.h> #include <experimental/bits/net.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @addtogroup networking-ts * @{ / /// Customization point for asynchronous operations. template<typename _CompletionToken, typename _Signature, typename = void> class async_result; /// Convenience utility to help implement asynchronous operations. template<typename _CompletionToken, typename _Signature> class async_completion; template<typename _Tp, typename _ProtoAlloc, typename = __void_t<>> struct __associated_allocator_impl { using type = _ProtoAlloc; static type _S_get(const _Tp&, const _ProtoAlloc& __a) noexcept { return __a; } }; template<typename _Tp, typename _ProtoAlloc> struct __associated_allocator_impl<_Tp, _ProtoAlloc, __void_t<typename _Tp::allocator_type>> { using type = typename _Tp::allocator_type; static type _S_get(const _Tp& __t, const _ProtoAlloc&) noexcept { return __t.get_allocator(); } }; /// Helper to associate an allocator with a type. template<typename _Tp, typename _ProtoAllocator = allocator<void>> struct associated_allocator : __associated_allocator_impl<_Tp, _ProtoAllocator> { static auto get(const _Tp& __t, const _ProtoAllocator& __a = _ProtoAllocator()) noexcept { using _Impl = __associated_allocator_impl<_Tp, _ProtoAllocator>; return _Impl::_S_get(__t, __a); } }; /// Alias template for associated_allocator. template<typename _Tp, typename _ProtoAllocator = allocator<void>> using associated_allocator_t = typename associated_allocator<_Tp, _ProtoAllocator>::type; // get_associated_allocator: template<typename _Tp> inline associated_allocator_t<_Tp> get_associated_allocator(const _Tp& __t) noexcept { return associated_allocator<_Tp>::get(__t); } template<typename _Tp, typename _ProtoAllocator> inline associated_allocator_t<_Tp, _ProtoAllocator> get_associated_allocator(const _Tp& __t, const _ProtoAllocator& __a) noexcept { return associated_allocator<_Tp, _ProtoAllocator>::get(__t, __a); } enum class fork_event { prepare, parent, child }; /// An extensible, type-safe, polymorphic set of services. class execution_context; class service_already_exists : public logic_error { public: // _GLIBCXX_RESOLVE_LIB_DEFECTS // 3414. service_already_exists has no usable constructors service_already_exists() : logic_error("service already exists") { } }; template<typename _Tp> struct is_executor; struct executor_arg_t { }; constexpr executor_arg_t executor_arg = executor_arg_t(); /// Trait for determining whether to construct an object with an executor. template<typename _Tp, typename _Executor> struct uses_executor; template<typename _Tp, typename _Executor, typename = __void_t<>> struct __associated_executor_impl { using type = _Executor; static type _S_get(const _Tp&, const _Executor& __e) noexcept { return __e; } }; template<typename _Tp, typename _Executor> struct __associated_executor_impl<_Tp, _Executor, __void_t<typename _Tp::executor_type>> { using type = typename _Tp::executor_type; static type _S_get(const _Tp& __t, const _Executor&) noexcept { return __t.get_executor(); } }; /// Helper to associate an executor with a type. template<typename _Tp, typename _Executor = system_executor> struct associated_executor : __associated_executor_impl<_Tp, _Executor> { static auto get(const _Tp& __t, const _Executor& __e = _Executor()) noexcept { return __associated_executor_impl<_Tp, _Executor>::_S_get(__t, __e); } }; template<typename _Tp, typename _Executor = system_executor> using associated_executor_t = typename associated_executor<_Tp, _Executor>::type; template<typename _ExecutionContext> using __is_exec_context = is_convertible<_ExecutionContext&, execution_context&>; template<typename _Tp> using __executor_t = typename _Tp::executor_type; // get_associated_executor: template<typename _Tp> inline associated_executor_t<_Tp> get_associated_executor(const _Tp& __t) noexcept { return associated_executor<_Tp>::get(__t); } template<typename _Tp, typename _Executor> inline enable_if_t<is_executor<_Executor>::value, associated_executor_t<_Tp, _Executor>> get_associated_executor(const _Tp& __t, const _Executor& __ex) { return associated_executor<_Tp, _Executor>::get(__t, __ex); } template<typename _Tp, typename _ExecutionContext> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, associated_executor_t<_Tp, __executor_t<_ExecutionContext>>> get_associated_executor(const _Tp& __t, _ExecutionContext& __ctx) noexcept { return net::get_associated_executor(__t, __ctx.get_executor()); } /// Helper to bind an executor to an object or function. template<typename _Tp, typename _Executor> class executor_binder; template<typename _Tp, typename _Executor, typename _Signature> class async_result<executor_binder<_Tp, _Executor>, _Signature>; template<typename _Tp, typename _Executor, typename _ProtoAllocator> struct associated_allocator<executor_binder<_Tp, _Executor>, _ProtoAllocator>; template<typename _Tp, typename _Executor, typename _Executor1> struct associated_executor<executor_binder<_Tp, _Executor>, _Executor1>; // bind_executor: template<typename _Executor, typename _Tp> inline enable_if_t<is_executor<_Executor>::value, executor_binder<decay_t<_Tp>, _Executor>> bind_executor(const _Executor& __ex, _Tp&& __t) { return { std::forward<_Tp>(__t), __ex }; } template<typename _ExecutionContext, typename _Tp> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, executor_binder<decay_t<_Tp>, __executor_t<_ExecutionContext>>> bind_executor(_ExecutionContext& __ctx, _Tp&& __t) { return { __ctx.get_executor(), forward<_Tp>(__t) }; } /// A scope-guard type to record when work is started and finished. template<typename _Executor> class executor_work_guard; // make_work_guard: template<typename _Executor> inline enable_if_t<is_executor<_Executor>::value, executor_work_guard<_Executor>> make_work_guard(const _Executor& __ex) { return executor_work_guard<_Executor>(__ex); } template<typename _ExecutionContext> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, executor_work_guard<__executor_t<_ExecutionContext>>> make_work_guard(_ExecutionContext& __ctx) { return net::make_work_guard(__ctx.get_executor()); } template<typename _Tp> inline enable_if_t<__not_<__or_<is_executor<_Tp>, __is_exec_context<_Tp>>>::value, executor_work_guard<associated_executor_t<_Tp>>> make_work_guard(const _Tp& __t) { return net::get_associated_executor(__t); } template<typename _Tp, typename _Up> auto make_work_guard(const _Tp& __t, _Up&& __u) -> decltype(net::make_work_guard( net::get_associated_executor(__t, forward<_Up>(__u)))) { return net::make_work_guard( net::get_associated_executor(__t, forward<_Up>(__u))); } /// Allows function objects to execute on any thread. class system_executor; /// The execution context associated with system_executor objects. class system_context; inline bool operator==(const system_executor&, const system_executor&) { return true; } inline bool operator!=(const system_executor&, const system_executor&) { return false; } /// Exception thrown by empty executors. class bad_executor; /// Polymorphic wrapper for types satisfying the Executor requirements. class executor; bool operator==(const executor&, const executor&) noexcept; bool operator==(const executor&, nullptr_t) noexcept; bool operator==(nullptr_t, const executor&) noexcept; bool operator!=(const executor&, const executor&) noexcept; bool operator!=(const executor&, nullptr_t) noexcept; bool operator!=(nullptr_t, const executor&) noexcept; void swap(executor&, executor&) noexcept; // dispatch: template<typename _CompletionToken> __deduced_t<_CompletionToken, void()> dispatch(_CompletionToken&& __token); template<typename _Executor, typename _CompletionToken> __deduced_t<_CompletionToken, void()> dispatch(const _Executor& __ex, _CompletionToken&& __token); template<typename _ExecutionContext, typename _CompletionToken> __deduced_t<_CompletionToken, void()> dispatch(_ExecutionContext& __ctx, _CompletionToken&& __token); // post: template<typename _CompletionToken> __deduced_t<_CompletionToken, void()> post(_CompletionToken&& __token); template<typename _Executor, typename _CompletionToken> enable_if_t<is_executor<_Executor>::value, __deduced_t<_CompletionToken, void()>> post(const _Executor& __ex, _CompletionToken&& __token); template<typename _ExecutionContext, typename _CompletionToken> enable_if_t<__is_exec_context<_ExecutionContext>::value, __deduced_t<_CompletionToken, void()>> post(_ExecutionContext& __ctx, _CompletionToken&& __token); // defer: template<typename _CompletionToken> __deduced_t<_CompletionToken, void()> defer(_CompletionToken&& __token); template<typename _Executor, typename _CompletionToken> __deduced_t<_CompletionToken, void()> defer(const _Executor& __ex, _CompletionToken&& __token); template<typename _ExecutionContext, typename _CompletionToken> __deduced_t<_CompletionToken, void()> defer(_ExecutionContext& __ctx, _CompletionToken&& __token); template<typename _Executor> class strand; template<typename _Executor> bool operator==(const strand<_Executor>& __a, const strand<_Executor>& __b); template<typename _Executor> bool operator!=(const strand<_Executor>& __a, const strand<_Executor>& __b) { return !(__a == __b); } template<typename _CompletionToken, typename _Signature, typename> class async_result { public: using completion_handler_type = _CompletionToken; using return_type = void; explicit async_result(completion_handler_type&) {} async_result(const async_result&) = delete; async_result& operator=(const async_result&) = delete; return_type get() {} }; template<typename _CompletionToken, typename _Signature> class async_completion { using __result_type = async_result<decay_t<_CompletionToken>, _Signature>; public: using completion_handler_type = typename __result_type::completion_handler_type; private: using __handler_type = conditional_t< is_same<_CompletionToken, completion_handler_type>::value, completion_handler_type&, completion_handler_type>; public: explicit async_completion(_CompletionToken& __t) : completion_handler(std::forward<__handler_type>(__t)), result(completion_handler) { } async_completion(const async_completion&) = delete; async_completion& operator=(const async_completion&) = delete; __handler_type completion_handler; __result_type result; }; class execution_context { public: class service { protected: // construct / copy / destroy: explicit service(execution_context& __owner) : _M_context(__owner) { } service(const service&) = delete; service& operator=(const service&) = delete; virtual ~service() { } // TODO should not be inline // service observers: execution_context& context() const noexcept { return _M_context; } private: // service operations: virtual void shutdown() noexcept = 0; virtual void notify_fork(fork_event) { } friend class execution_context; execution_context& _M_context; }; // construct / copy / destroy: execution_context() { } execution_context(const execution_context&) = delete; execution_context& operator=(const execution_context&) = delete; virtual ~execution_context() { shutdown(); destroy(); } // execution context operations: void notify_fork(fork_event __e) { auto __l = [=](auto& __svc) { __svc._M_ptr->notify_fork(__e); }; if (__e == fork_event::prepare) std::for_each(_M_services.rbegin(), _M_services.rend(), __l); else std::for_each(_M_services.begin(), _M_services.end(), __l); } protected: // execution context protected operations: void shutdown() { std::for_each(_M_services.rbegin(), _M_services.rend(), [=](auto& __svc) { if (__svc._M_active) { __svc._M_ptr->shutdown(); __svc._M_active = false; } }); } void destroy() { while (_M_services.size()) _M_services.pop_back(); _M_keys.clear(); } protected: template<typename _Service> static void _S_deleter(service __svc) { delete static_cast<_Service>(__svc); } struct _ServicePtr { template<typename _Service> explicit _ServicePtr(_Service __svc) : _M_ptr(__svc, &_S_deleter<_Service>), _M_active(true) { } std::unique_ptr<service, void()(service)> _M_ptr; bool _M_active; }; #if defined(_GLIBCXX_HAS_GTHREADS) using mutex_type = std::mutex; #else struct mutex_type { void lock() const { } void unlock() const { } }; #endif mutable mutex_type _M_mutex; // Sorted in order of beginning of service object lifetime. std::list<_ServicePtr> _M_services; template<typename _Service, typename... _Args> service* _M_add_svc(_Args&&... __args) { _M_services.push_back( _ServicePtr{new _Service{this, std::forward<_Args>(__args)...}} ); return _M_services.back()._M_ptr.get(); } using __key_type = void()(); template<typename _Key> static __key_type _S_key() { return reinterpret_cast<__key_type>(&_S_key<_Key>); } std::unordered_map<__key_type, service> _M_keys; template<typename _Service> friend typename _Service::key_type& use_service(execution_context&); template<typename _Service, typename... _Args> friend _Service& make_service(execution_context&, _Args&&...); template<typename _Service> friend bool has_service(const execution_context&) noexcept; }; // service access: template<typename _Service> typename _Service::key_type& use_service(execution_context& __ctx) { using _Key = typename _Service::key_type; static_assert(is_base_of<execution_context::service, _Key>::value, "a service type must derive from execution_context::service"); static_assert(is_base_of<_Key, _Service>::value, "a service type must match or derive from its key_type"); auto __key = execution_context::_S_key<_Key>(); lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); auto& __svc = __ctx._M_keys[__key]; if (__svc == nullptr) { __try { __svc = __ctx._M_add_svc<_Service>(); } __catch(...) { __ctx._M_keys.erase(__key); __throw_exception_again; } } return static_cast<_Key&>(__svc); } template<typename _Service, typename... _Args> _Service& make_service(execution_context& __ctx, _Args&&... __args) { using _Key = typename _Service::key_type; static_assert(is_base_of<execution_context::service, _Key>::value, "a service type must derive from execution_context::service"); static_assert(is_base_of<_Key, _Service>::value, "a service type must match or derive from its key_type"); auto __key = execution_context::_S_key<_Key>(); lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); auto& __svc = __ctx._M_keys[__key]; if (__svc != nullptr) throw service_already_exists(); __try { __svc = __ctx._M_add_svc<_Service>(std::forward<_Args>(__args)...); } __catch(...) { __ctx._M_keys.erase(__key); __throw_exception_again; } return static_cast<_Service&>(__svc); } template<typename _Service> inline bool has_service(const execution_context& __ctx) noexcept { using _Key = typename _Service::key_type; static_assert(is_base_of<execution_context::service, _Key>::value, "a service type must derive from execution_context::service"); static_assert(is_base_of<_Key, _Service>::value, "a service type must match or derive from its key_type"); lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); return __ctx._M_keys.count(execution_context::_S_key<_Key>()); } template<typename _Tp, typename = __void_t<>> struct __is_executor_impl : false_type { }; // Check Executor requirements. template<typename _Tp, typename _Up = remove_const_t<_Tp>> auto __executor_reqs(_Up __x = 0, const _Up* __cx = 0, void(__f)() = 0, const allocator<int>& __a = {}) -> enable_if_t<__is_value_constructible<_Tp>::value, __void_t< decltype(__cx == __cx), decltype(__cx != __cx), decltype(__x->context()), decltype(__x->on_work_started()), decltype(__x->on_work_finished()), decltype(__x->dispatch(std::move(__f), __a)), decltype(__x->post(std::move(__f), __a)), decltype(__x->defer(std::move(__f), __a)) >>; template<typename _Tp> struct __is_executor_impl<_Tp, decltype(__executor_reqs<_Tp>())> : true_type { }; template<typename _Tp> struct is_executor : __is_executor_impl<_Tp> { }; template<typename _Tp> constexpr bool is_executor_v = is_executor<_Tp>::value; template<typename _Tp, typename _Executor, typename = __void_t<>> struct __uses_executor_impl : false_type { }; template<typename _Tp, typename _Executor> struct __uses_executor_impl<_Tp, _Executor, __void_t<typename _Tp::executor_type>> : is_convertible<_Executor, typename _Tp::executor_type> { }; template<typename _Tp, typename _Executor> struct uses_executor : __uses_executor_impl<_Tp, _Executor>::type { }; template<typename _Tp, typename _Executor> constexpr bool uses_executor_v = uses_executor<_Tp, _Executor>::value; template<typename _Tp, typename _Executor> class executor_binder { struct __use_exec { }; public: // types: using target_type = _Tp; using executor_type = _Executor; // construct / copy / destroy: executor_binder(_Tp __t, const _Executor& __ex) : executor_binder(__use_exec{}, std::move(__t), __ex) { } executor_binder(const executor_binder&) = default; executor_binder(executor_binder&&) = default; template<typename _Up, typename _OtherExecutor> executor_binder(const executor_binder<_Up, _OtherExecutor>& __other) : executor_binder(__use_exec{}, __other.get(), __other.get_executor()) { } template<typename _Up, typename _OtherExecutor> executor_binder(executor_binder<_Up, _OtherExecutor>&& __other) : executor_binder(__use_exec{}, std::move(__other.get()), __other.get_executor()) { } template<typename _Up, typename _OtherExecutor> executor_binder(executor_arg_t, const _Executor& __ex, const executor_binder<_Up, _OtherExecutor>& __other) : executor_binder(__use_exec{}, __other.get(), __ex) { } template<typename _Up, typename _OtherExecutor> executor_binder(executor_arg_t, const _Executor& __ex, executor_binder<_Up, _OtherExecutor>&& __other) : executor_binder(__use_exec{}, std::move(__other.get()), __ex) { } ~executor_binder(); // executor binder access: _Tp& get() noexcept { return _M_target; } const _Tp& get() const noexcept { return _M_target; } executor_type get_executor() const noexcept { return _M_ex; } // executor binder invocation: template<class... _Args> result_of_t<_Tp&(_Args&&...)> operator()(_Args&&... __args) { return std::__invoke(get(), std::forward<_Args>(__args)...); } template<class... _Args> result_of_t<const _Tp&(_Args&&...)> operator()(_Args&&... __args) const { return std::__invoke(get(), std::forward<_Args>(__args)...); } private: template<typename _Up> using __use_exec_cond = __and_<uses_executor<_Tp, _Executor>, is_constructible<_Tp, executor_arg_t, _Executor, _Up>>; template<typename _Up, typename _Exec, typename = enable_if_t<__use_exec_cond<_Up>::value>> executor_binder(__use_exec, _Up&& __u, _Exec&& __ex) : _M_ex(std::forward<_Exec>(__ex)), _M_target(executor_arg, _M_ex, std::forward<_Up>(__u)) { } template<typename _Up, typename _Exec, typename = enable_if_t<!__use_exec_cond<_Up>::value>> executor_binder(__use_exec, _Up&& __u, const _Exec& __ex) : _M_ex(std::forward<_Exec>(__ex)), _M_target(std::forward<_Up>(__u)) { } _Executor _M_ex; _Tp _M_target; }; template<typename _Tp, typename _Executor, typename _Signature> class async_result<executor_binder<_Tp, _Executor>, _Signature> { using __inner = async_result<_Tp, _Signature>; public: using completion_handler_type = executor_binder<typename __inner::completion_handler_type, _Executor>; using return_type = typename __inner::return_type; explicit async_result(completion_handler_type& __h) : _M_target(__h.get()) { } async_result(const async_result&) = delete; async_result& operator=(const async_result&) = delete; return_type get() { return _M_target.get(); } private: __inner _M_target; }; template<typename _Tp, typename _Executor, typename _ProtoAlloc> struct associated_allocator<executor_binder<_Tp, _Executor>, _ProtoAlloc> { using type = associated_allocator_t<_Tp, _ProtoAlloc>; static type get(const executor_binder<_Tp, _Executor>& __b, const _ProtoAlloc& __a = _ProtoAlloc()) noexcept { return associated_allocator<_Tp, _ProtoAlloc>::get(__b.get(), __a); } }; template<typename _Tp, typename _Executor, typename _Executor1> struct associated_executor<executor_binder<_Tp, _Executor>, _Executor1> { using type = _Executor; static type get(const executor_binder<_Tp, _Executor>& __b, const _Executor1& = _Executor1()) noexcept { return __b.get_executor(); } }; template<typename _Executor> class executor_work_guard { public: // types: using executor_type = _Executor; // construct / copy / destroy: explicit executor_work_guard(const executor_type& __ex) noexcept : _M_ex(__ex), _M_owns(true) { _M_ex.on_work_started(); } executor_work_guard(const executor_work_guard& __other) noexcept : _M_ex(__other._M_ex), _M_owns(__other._M_owns) { if (_M_owns) _M_ex.on_work_started(); } executor_work_guard(executor_work_guard&& __other) noexcept : _M_ex(__other._M_ex), _M_owns(__other._M_owns) { __other._M_owns = false; } executor_work_guard& operator=(const executor_work_guard&) = delete; ~executor_work_guard() { if (_M_owns) _M_ex.on_work_finished(); } // executor work guard observers: executor_type get_executor() const noexcept { return _M_ex; } bool owns_work() const noexcept { return _M_owns; } // executor work guard modifiers: void reset() noexcept { if (_M_owns) _M_ex.on_work_finished(); _M_owns = false; } private: _Executor _M_ex; bool _M_owns; }; class system_context : public execution_context { public: // types: using executor_type = system_executor; // construct / copy / destroy: system_context() = delete; system_context(const system_context&) = delete; system_context& operator=(const system_context&) = delete; ~system_context() { stop(); join(); } // system_context operations: executor_type get_executor() noexcept; void stop() { lock_guard<mutex_type> __lock(_M_mtx); _M_stopped = true; _M_cv.notify_all(); } bool stopped() const noexcept { lock_guard<mutex_type> __lock(_M_mtx); return _M_stopped; } void join() { if (_M_thread.joinable()) _M_thread.join(); } private: friend system_executor; struct __tag { explicit __tag() = default; }; system_context(__tag) { } #ifndef _GLIBCXX_HAS_GTHREADS struct thread { bool joinable() const { return false; } void join() { } }; struct condition_variable { void notify_all() { } }; #endif thread _M_thread; mutable mutex_type _M_mtx; // XXX can we reuse base's _M_mutex? condition_variable _M_cv; queue<function<void()>> _M_tasks; bool _M_stopped = false; #ifdef _GLIBCXX_HAS_GTHREADS void _M_run() { while (true) { function<void()> __f; { unique_lock<mutex_type> __lock(_M_mtx); _M_cv.wait(__lock, [this]{ return _M_stopped \|\| !_M_tasks.empty(); }); if (_M_stopped) return; __f = std::move(_M_tasks.front()); _M_tasks.pop(); } __f(); } } #endif void _M_post(std::function<void()> __f __attribute__((__unused__))) { lock_guard<mutex_type> __lock(_M_mtx); if (_M_stopped) return; #ifdef _GLIBCXX_HAS_GTHREADS if (!_M_thread.joinable()) _M_thread = std::thread(&system_context::_M_run, this); _M_tasks.push(std::move(__f)); // XXX allocator not used _M_cv.notify_one(); #else __throw_system_error(EOPNOTSUPP); #endif } static system_context& _S_get() noexcept { static system_context __sc(__tag{}); return __sc; } }; class system_executor { public: // executor operations: system_executor() { } system_context& context() const noexcept { return system_context::_S_get(); } void on_work_started() const noexcept { } void on_work_finished() const noexcept { } template<typename _Func, typename _ProtoAlloc> void dispatch(_Func&& __f, const _ProtoAlloc& __a) const { decay_t<_Func>{std::forward<_Func>(__f)}(); } template<typename _Func, typename _ProtoAlloc> void post(_Func&& __f, const _ProtoAlloc&) const // XXX allocator not used { system_context::_S_get()._M_post(std::forward<_Func>(__f)); } template<typename _Func, typename _ProtoAlloc> void defer(_Func&& __f, const _ProtoAlloc& __a) const { post(std::forward<_Func>(__f), __a); } }; inline system_executor system_context::get_executor() noexcept { return {}; } class bad_executor : public std::exception { virtual const char what() const noexcept { return "bad executor"; } }; inline void __throw_bad_executor() // TODO make non-inline { #if __cpp_exceptions throw bad_executor(); #else __builtin_abort(); #endif } class executor { public: // construct / copy / destroy: executor() noexcept = default; executor(nullptr_t) noexcept { } executor(const executor&) noexcept = default; executor(executor&&) noexcept = default; template<typename _Executor> executor(_Executor __e) : _M_target(make_shared<_Tgt1<_Executor>>(std::move(__e))) { } template<typename _Executor, typename _ProtoAlloc> executor(allocator_arg_t, const _ProtoAlloc& __a, _Executor __e) : _M_target(allocate_shared<_Tgt2<_Executor, _ProtoAlloc>>(__a, std::move(__e), __a)) { } executor& operator=(const executor&) noexcept = default; executor& operator=(executor&&) noexcept = default; executor& operator=(nullptr_t) noexcept { _M_target = nullptr; return this; } template<typename _Executor> executor& operator=(_Executor __e) { executor(std::move(__e)).swap(this); return this; } ~executor() = default; // executor modifiers: void swap(executor& __other) noexcept { _M_target.swap(__other._M_target); } template<typename _Executor, typename _Alloc> void assign(_Executor __e, const _Alloc& __a) { executor(allocator_arg, __a, std::move(__e)).swap(this); } // executor operations: execution_context& context() const noexcept { __glibcxx_assert( _M_target ); return _M_target->context(); } void on_work_started() const noexcept { __glibcxx_assert( _M_target ); return _M_target->on_work_started(); } void on_work_finished() const noexcept { __glibcxx_assert( _M_target ); return _M_target->on_work_finished(); } template<typename _Func, typename _Alloc> void dispatch(_Func&& __f, const _Alloc& __a) const { if (!_M_target) __throw_bad_executor(); // _M_target->dispatch({allocator_arg, __a, std::forward<_Func>(__f)}); _M_target->dispatch(std::forward<_Func>(__f)); } template<typename _Func, typename _Alloc> void post(_Func&& __f, const _Alloc& __a) const { if (!_M_target) __throw_bad_executor(); // _M_target->post({allocator_arg, __a, std::forward<_Func>(__f)}); _M_target->post(std::forward<_Func>(__f)); } template<typename _Func, typename _Alloc> void defer(_Func&& __f, const _Alloc& __a) const { if (!_M_target) __throw_bad_executor(); // _M_target->defer({allocator_arg, __a, std::forward<_Func>(__f)}); _M_target->defer(std::forward<_Func>(__f)); } // executor capacity: explicit operator bool() const noexcept { return static_cast<bool>(_M_target); } // executor target access: #if __cpp_rtti const type_info& target_type() const noexcept { if (_M_target) return static_cast<const type_info>(_M_target->target_type()); return typeid(void); } #endif template<typename _Executor> _Executor* target() noexcept { void* __p = nullptr; if (_M_target) { if (_M_target->_M_func == &_Tgt1<remove_cv_t<_Executor>>::_S_func) __p = _M_target->_M_func(_M_target.get(), nullptr); #if __cpp_rtti else __p = _M_target->target(&typeid(_Executor)); #endif } return static_cast<_Executor>(__p); } template<typename _Executor> const _Executor target() const noexcept { const void* __p = nullptr; if (_M_target) { if (_M_target->_M_func == &_Tgt1<remove_cv_t<_Executor>>::_S_func) return (_Executor)_M_target->_M_func(_M_target.get(), nullptr); #if __cpp_rtti else __p = _M_target->target(&typeid(_Executor)); #endif } return static_cast<const _Executor>(__p); } private: struct _Tgt { virtual void on_work_started() const noexcept = 0; virtual void on_work_finished() const noexcept = 0; virtual execution_context& context() const noexcept = 0; virtual void dispatch(std::function<void()>) const = 0; virtual void post(std::function<void()>) const = 0; virtual void defer(std::function<void()>) const = 0; virtual const void* target_type() const noexcept = 0; virtual void* target(const void) noexcept = 0; virtual bool _M_equals(_Tgt) const noexcept = 0; using _Func = void* (_Tgt, const _Tgt); _Func* _M_func; // Provides access to target without RTTI }; template<typename _Ex> struct _Tgt1 : _Tgt { explicit _Tgt1(_Ex&& __ex) : _M_ex(std::move(__ex)) { this->_M_func = &_S_func; } void on_work_started() const noexcept override { _M_ex.on_work_started(); } void on_work_finished() const noexcept override { _M_ex.on_work_finished(); } execution_context& context() const noexcept override { return _M_ex.context(); } void dispatch(std::function<void()> __f) const override { _M_ex.dispatch(std::move(__f), allocator<void>()); } void post(std::function<void()> __f) const override { _M_ex.post(std::move(__f), allocator<void>()); } void defer(std::function<void()> __f) const override { _M_ex.defer(std::move(__f), allocator<void>()); } const void* target_type() const noexcept override { #if __cpp_rtti return &typeid(_Ex); #else return nullptr; #endif } void* target(const void* __ti) noexcept override { #if __cpp_rtti if (static_cast<const type_info>(__ti) == typeid(_Ex)) return std::__addressof(_M_ex); #endif return nullptr; } bool _M_equals(_Tgt* __tgt) const noexcept override { #if __cpp_rtti if (const void* __p = __tgt->target(&typeid(_Ex))) return static_cast<const _Ex>(__p) == _M_ex; #endif return false; } _Ex _M_ex [[__no_unique_address__]]; static void* _S_func(_Tgt* __p, const _Tgt* __q) noexcept { auto& __ex = static_cast<_Tgt1>(__p)->_M_ex; if (__q) { if (__ex == static_cast<const _Tgt1>(__q)->_M_ex) return __p; else return nullptr; } else return std::__addressof(__ex); } }; template<typename _Ex, typename _Alloc> struct _Tgt2 : _Tgt1<_Ex> { explicit _Tgt2(_Ex&& __ex, const _Alloc& __a) : _Tgt1<_Ex>(std::move(__ex)), _M_alloc(__a) { } void dispatch(std::function<void()> __f) const override { this->_M_ex.dispatch(std::move(__f), _M_alloc); } void post(std::function<void()> __f) const override { this->_M_ex.post(std::move(__f), _M_alloc); } void defer(std::function<void()> __f) const override { this->_M_ex.defer(std::move(__f), _M_alloc); } _Alloc _M_alloc [[__no_unique_address__]]; }; // Partial specialization for std::allocator<T>. // Don't store the allocator. template<typename _Ex, typename _Tp> struct _Tgt2<_Ex, std::allocator<_Tp>> : _Tgt1<_Ex> { }; friend bool operator==(const executor& __a, const executor& __b) noexcept { _Tgt* __ta = __a._M_target.get(); _Tgt* __tb = __b._M_target.get(); if (__ta == __tb) return true; if (!__ta \|\| !__tb) return false; if (__ta->_M_func == __tb->_M_func) return __ta->_M_func(__ta, __tb); return __ta->_M_equals(__tb); } shared_ptr<_Tgt> _M_target; }; template<> struct is_executor<executor> : true_type { }; /// executor comparisons inline bool operator==(const executor& __e, nullptr_t) noexcept { return !__e; } inline bool operator==(nullptr_t, const executor& __e) noexcept { return !__e; } inline bool operator!=(const executor& __a, const executor& __b) noexcept { return !(__a == __b); } inline bool operator!=(const executor& __e, nullptr_t) noexcept { return (bool)__e; } inline bool operator!=(nullptr_t, const executor& __e) noexcept { return (bool)__e; } /// Swap two executor objects. inline void swap(executor& __a, executor& __b) noexcept { __a.swap(__b); } template<typename _CompletionHandler> struct __dispatcher { explicit __dispatcher(_CompletionHandler& __h) : _M_h(std::move(__h)), _M_w(net::make_work_guard(_M_h)) { } void operator()() { auto __alloc = net::get_associated_allocator(_M_h); _M_w.get_executor().dispatch(std::move(_M_h), __alloc); _M_w.reset(); } _CompletionHandler _M_h; decltype(net::make_work_guard(_M_h)) _M_w; }; template<typename _CompletionHandler> inline __dispatcher<_CompletionHandler> __make_dispatcher(_CompletionHandler& __h) { return __dispatcher<_CompletionHandler>{__h}; } // dispatch: template<typename _CompletionToken> inline __deduced_t<_CompletionToken, void()> dispatch(_CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __ex = net::get_associated_executor(__cmpl.completion_handler); auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.dispatch(std::move(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _Executor, typename _CompletionToken> inline enable_if_t<is_executor<_Executor>::value, __deduced_t<_CompletionToken, void()>> dispatch(const _Executor& __ex, _CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.dispatch(net::__make_dispatcher(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _ExecutionContext, typename _CompletionToken> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, __deduced_t<_CompletionToken, void()>> dispatch(_ExecutionContext& __ctx, _CompletionToken&& __token) { return net::dispatch(__ctx.get_executor(), forward<_CompletionToken>(__token)); } // post: template<typename _CompletionToken> inline __deduced_t<_CompletionToken, void()> post(_CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __ex = net::get_associated_executor(__cmpl.completion_handler); auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.post(std::move(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _Executor, typename _CompletionToken> inline enable_if_t<is_executor<_Executor>::value, __deduced_t<_CompletionToken, void()>> post(const _Executor& __ex, _CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.post(net::__make_dispatcher(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _ExecutionContext, typename _CompletionToken> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, __deduced_t<_CompletionToken, void()>> post(_ExecutionContext& __ctx, _CompletionToken&& __token) { return net::post(__ctx.get_executor(), forward<_CompletionToken>(__token)); } // defer: template<typename _CompletionToken> inline __deduced_t<_CompletionToken, void()> defer(_CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __ex = net::get_associated_executor(__cmpl.completion_handler); auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.defer(std::move(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _Executor, typename _CompletionToken> inline enable_if_t<is_executor<_Executor>::value, __deduced_t<_CompletionToken, void()>> defer(const _Executor& __ex, _CompletionToken&& __token) { async_completion<_CompletionToken, void()> __cmpl{__token}; auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); __ex.defer(net::__make_dispatcher(__cmpl.completion_handler), __alloc); return __cmpl.result.get(); } template<typename _ExecutionContext, typename _CompletionToken> inline enable_if_t<__is_exec_context<_ExecutionContext>::value, __deduced_t<_CompletionToken, void()>> defer(_ExecutionContext& __ctx, _CompletionToken&& __token) { return net::defer(__ctx.get_executor(), forward<_CompletionToken>(__token)); } template<typename _Executor> class strand { public: // types: using inner_executor_type = _Executor; // construct / copy / destroy: strand(); // TODO make state explicit strand(_Executor __ex) : _M_inner_ex(__ex) { } // TODO make state template<typename _Alloc> strand(allocator_arg_t, const _Alloc& __a, _Executor __ex) : _M_inner_ex(__ex) { } // TODO make state strand(const strand& __other) noexcept : _M_state(__other._M_state), _M_inner_ex(__other._M_inner_ex) { } strand(strand&& __other) noexcept : _M_state(std::move(__other._M_state)), _M_inner_ex(std::move(__other._M_inner_ex)) { } template<typename _OtherExecutor> strand(const strand<_OtherExecutor>& __other) noexcept : _M_state(__other._M_state), _M_inner_ex(__other._M_inner_ex) { } template<typename _OtherExecutor> strand(strand<_OtherExecutor>&& __other) noexcept : _M_state(std::move(__other._M_state)), _M_inner_ex(std::move(__other._M_inner_ex)) { } strand& operator=(const strand& __other) noexcept { static_assert(is_copy_assignable<_Executor>::value, "inner executor type must be CopyAssignable"); // TODO lock __other // TODO copy state _M_inner_ex = __other._M_inner_ex; return this; } strand& operator=(strand&& __other) noexcept { static_assert(is_move_assignable<_Executor>::value, "inner executor type must be MoveAssignable"); // TODO move state _M_inner_ex = std::move(__other._M_inner_ex); return this; } template<typename _OtherExecutor> strand& operator=(const strand<_OtherExecutor>& __other) noexcept { static_assert(is_convertible<_OtherExecutor, _Executor>::value, "inner executor type must be compatible"); // TODO lock __other // TODO copy state _M_inner_ex = __other._M_inner_ex; return this; } template<typename _OtherExecutor> strand& operator=(strand<_OtherExecutor>&& __other) noexcept { static_assert(is_convertible<_OtherExecutor, _Executor>::value, "inner executor type must be compatible"); // TODO move state _M_inner_ex = std::move(__other._M_inner_ex); return this; } ~strand() { // the task queue outlives this object if non-empty // TODO create circular ref in queue? } // strand operations: inner_executor_type get_inner_executor() const noexcept { return _M_inner_ex; } bool running_in_this_thread() const noexcept { return _M_state->running_in_this_thread(); } execution_context& context() const noexcept { return _M_inner_ex.context(); } void on_work_started() const noexcept { _M_inner_ex.on_work_started(); } void on_work_finished() const noexcept { _M_inner_ex.on_work_finished(); } template<typename _Func, typename _Alloc> void dispatch(_Func&& __f, const _Alloc& __a) const { if (running_in_this_thread()) decay_t<_Func>{std::forward<_Func>(__f)}(); else post(std::forward<_Func>(__f), __a); } template<typename _Func, typename _Alloc> void post(_Func&& __f, const _Alloc& __a) const; // TODO template<typename _Func, typename _Alloc> void defer(_Func&& __f, const _Alloc& __a) const { post(std::forward<_Func>(__f), __a); } private: friend bool operator==(const strand& __a, const strand& __b) { return __a._M_state == __b._M_state; } // TODO add synchronised queue struct _State { #if defined(_GLIBCXX_HAS_GTHREADS) bool running_in_this_thread() const noexcept { return std::this_thread::get_id() == _M_running_on; } std::thread::id _M_running_on; #else bool running_in_this_thread() const { return true; } #endif }; shared_ptr<_State> _M_state; _Executor _M_inner_ex; }; #if defined(_GLIBCXX_HAS_GTHREADS) // Completion token for asynchronous operations initiated with use_future. template<typename _Func, typename _Alloc> struct __use_future_ct { std::tuple<_Func, _Alloc> _M_t; }; template<typename _Func, typename _Tp> struct __use_future_ct<_Func, std::allocator<_Tp>> { _Func _M_f; }; template<typename _ProtoAllocator = allocator<void>> class use_future_t { public: // use_future_t types: using allocator_type = _ProtoAllocator; // use_future_t members: constexpr use_future_t() noexcept(is_nothrow_default_constructible<_ProtoAllocator>::value) : _M_alloc() { } explicit use_future_t(const _ProtoAllocator& __a) noexcept : _M_alloc(__a) { } template<typename _OtherAllocator> use_future_t<_OtherAllocator> rebind(const _OtherAllocator& __a) const noexcept { return use_future_t<_OtherAllocator>(__a); } allocator_type get_allocator() const noexcept { return _M_alloc; } template<typename _Func> auto operator()(_Func&& __f) const { using _Token = __use_future_ct<decay_t<_Func>, _ProtoAllocator>; return _Token{ {std::forward<_Func>(__f), _M_alloc} }; } private: _ProtoAllocator _M_alloc; }; template<typename _Tp> class use_future_t<std::allocator<_Tp>> { public: // use_future_t types: using allocator_type = std::allocator<_Tp>; // use_future_t members: constexpr use_future_t() noexcept = default; explicit use_future_t(const allocator_type& __a) noexcept { } template<class _Up> use_future_t<std::allocator<_Up>> rebind(const std::allocator<_Up>& __a) const noexcept { return use_future_t<std::allocator<_Up>>(__a); } allocator_type get_allocator() const noexcept { return {}; } template<typename _Func> auto operator()(_Func&& __f) const { using _Token = __use_future_ct<decay_t<_Func>, allocator_type>; return _Token{std::forward<_Func>(__f)}; } }; constexpr use_future_t<> use_future = use_future_t<>(); template<typename _Func, typename _Alloc, typename _Res, typename... _Args> class async_result<__use_future_ct<_Func, _Alloc>, _Res(_Args...)>; template<typename _Result, typename _Executor> struct __use_future_ex; // Completion handler for asynchronous operations initiated with use_future. template<typename _Func, typename... _Args> struct __use_future_ch { template<typename _Alloc> explicit __use_future_ch(__use_future_ct<_Func, _Alloc>&& __token) : _M_f{ std::move(std::get<0>(__token._M_t)) }, _M_promise{ std::get<1>(__token._M_t) } { } template<typename _Tp> explicit __use_future_ch(__use_future_ct<_Func, std::allocator<_Tp>>&& __token) : _M_f{ std::move(__token._M_f) } { } void operator()(_Args&&... __args) { __try { _M_promise.set_value(_M_f(std::forward<_Args>(__args)...)); } __catch(__cxxabiv1::__forced_unwind&) { __throw_exception_again; } __catch(...) { _M_promise.set_exception(std::current_exception()); } } using __result = result_of_t<_Func(decay_t<_Args>...)>; future<__result> get_future() { return _M_promise.get_future(); } private: template<typename _Result, typename _Executor> friend struct __use_future_ex; _Func _M_f; mutable promise<__result> _M_promise; }; // Specialization of async_result for operations initiated with use_future. template<typename _Func, typename _Alloc, typename _Res, typename... _Args> class async_result<__use_future_ct<_Func, _Alloc>, _Res(_Args...)> { public: using completion_handler_type = __use_future_ch<_Func, _Args...>; using return_type = future<typename completion_handler_type::__result>; explicit async_result(completion_handler_type& __h) : _M_future(__h.get_future()) { } async_result(const async_result&) = delete; async_result& operator=(const async_result&) = delete; return_type get() { return std::move(_M_future); } private: return_type _M_future; }; template<typename _Result, typename _Executor> struct __use_future_ex { template<typename _Handler> __use_future_ex(const _Handler& __h, _Executor __ex) : _M_t(__h._M_promise, __ex) { } template<typename _Fn, typename _Alloc> void dispatch(_Fn&& __fn) { __try { std::get<1>(_M_t).dispatch(std::forward<_Fn>(__fn)); } __catch(__cxxabiv1::__forced_unwind&) { __throw_exception_again; } __catch(...) { std::get<0>(_M_t).set_exception(std::current_exception()); } } template<typename _Fn, typename _Alloc> void post(_Fn&& __fn) { __try { std::get<1>(_M_t).post(std::forward<_Fn>(__fn)); } __catch(__cxxabiv1::__forced_unwind&) { __throw_exception_again; } __catch(...) { std::get<0>(_M_t).set_exception(std::current_exception()); } } template<typename _Fn, typename _Alloc> void defer(_Fn&& __fn) { __try { std::get<1>(_M_t).defer(std::forward<_Fn>(__fn)); } __catch(__cxxabiv1::__forced_unwind&) { __throw_exception_again; } __catch(...) { std::get<0>(_M_t).set_exception(std::current_exception()); } } private: tuple<promise<_Result>&, _Executor> _M_t; }; template<typename _Func, typename... _Args, typename _Executor> struct associated_executor<__use_future_ch<_Func, _Args...>, _Executor> { private: using __handler = __use_future_ch<_Func, _Args...>; using type = __use_future_ex<typename __handler::__result, _Executor>; static type get(const __handler& __h, const _Executor& __ex) { return { __h, __ex }; } }; #if 0 // [async.use.future.traits] template<typename _Allocator, typename _Ret, typename... _Args> class handler_type<use_future_t<_Allocator>, _Ret(_Args...)> // TODO uglify name { template<typename... _Args> struct __is_error_result : false_type { }; template<typename... _Args> struct __is_error_result<error_code, _Args...> : true_type { }; template<typename... _Args> struct __is_error_result<exception_ptr, _Args...> : true_type { }; static exception_ptr _S_exptr(exception_ptr& __ex) { return std::move(__ex); } static exception_ptr _S_exptr(const error_code& __ec) { return make_exception_ptr(system_error(__ec)); } template<bool _IsError, typename... _UArgs> struct _Type; // N == 0 template<bool _IsError> struct _Type<_IsError> { std::promise<void> _M_promise; void operator()() { _M_promise.set_value(); } }; // N == 1, U0 is error_code or exception_ptr template<typename _UArg0> struct _Type<true, _UArg0> { std::promise<void> _M_promise; template<typename _Arg0> void operator()(_Arg0&& __a0) { if (__a0) _M_promise.set_exception(_S_exptr(__a0)); else _M_promise.set_value(); } }; // N == 1, U0 is not error_code or exception_ptr template<typename _UArg0> struct _Type<false, _UArg0> { std::promise<_UArg0> _M_promise; template<typename _Arg0> void operator()(_Arg0&& __a0) { _M_promise.set_value(std::forward<_Arg0>(__a0)); } }; // N == 2, U0 is error_code or exception_ptr template<typename _UArg0, typename _UArg1> struct _Type<true, _UArg0, _UArg1> { std::promise<_UArg1> _M_promise; template<typename _Arg0, typename _Arg1> void operator()(_Arg0&& __a0, _Arg1&& __a1) { if (__a0) _M_promise.set_exception(_S_exptr(__a0)); else _M_promise.set_value(std::forward<_Arg1>(__a1)); } }; // N >= 2, U0 is not error_code or exception_ptr template<typename... _UArgs> struct _Type<false, _UArgs...> { static_assert(sizeof...(_UArgs) > 1, "wrong partial specialization"); std::promise<tuple<_UArgs...>> _M_promise; template<typename... _Args> void operator()(_Args&&... __args) { _M_promise.set_value( std::forward_as_tuple(std::forward<_Args>(__args)...)); } }; // N > 2, U0 is error_code or exception_ptr template<typename _UArg0, typename... _UArgs> struct _Type<true, _UArg0, _UArgs...> { static_assert(sizeof...(_UArgs) > 1, "wrong partial specialization"); std::promise<tuple<_UArgs...>> _M_promise; template<typename _Arg0, typename... _Args> void operator()(_Arg0&& __a0, _Args&&... __args) { if (__a0) _M_promise.set_exception(_S_exptr(__a0)); else _M_promise.set_value( std::forward_as_tuple(std::forward<_Args>(__args)...)); } }; public: using type = _Type<__is_error_result<_Args...>::value, decay_t<_Args>...>; }; template<typename _Alloc, typename _Ret, typename... _Args> struct async_result<use_future_t<_Alloc>, _Ret(_Args...)> { using completion_handler_type = typename handler_type<use_future_t<_Alloc>, _Ret(_Args...)>::type; using return_type = void; // XXX TODO ???; explicit async_result(completion_handler_type& __h) : _M_handler(__h) { } auto get() { return _M_handler._M_provider.get_future(); } async_result(const async_result&) = delete; async_result& operator=(const async_result&) = delete; return_type get() { return _M_handler._M_promise.get_future(); } private: completion_handler_type& _M_handler; }; // TODO specialize associated_executor for // async_result<use_future_t<A>, Sig>::completion_handler_type // to use a __use_future_ex // (probably need to move _Type outside of handler_type so we don't have // a non-deduced context) #endif // [async.packaged.task.specializations] template<typename _Ret, typename... _Args, typename _Signature> class async_result<packaged_task<_Ret(_Args...)>, _Signature> { public: using completion_handler_type = packaged_task<_Ret(_Args...)>; using return_type = future<_Ret>; explicit async_result(completion_handler_type& __h) : _M_future(__h.get_future()) { } async_result(const async_result&) = delete; async_result& operator=(const async_result&) = delete; return_type get() { return std::move(_M_future); } private: return_type _M_future; }; #endif // _GLIBCXX_HAS_GTHREADS /// @} } // namespace v1 } // namespace net } // namespace experimental template<typename _Alloc> struct uses_allocator<experimental::net::executor, _Alloc> : true_type {}; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_EXECUTOR	54.7 KB	2025-09-15 15:41
📄 filesystem // <experimental/filesystem> -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/filesystem * This is a TS C++ Library header. * @ingroup filesystem-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_FILESYSTEM #define _GLIBCXX_EXPERIMENTAL_FILESYSTEM 1 #pragma GCC system_header #if __cplusplus >= 201103L #include <experimental/bits/fs_fwd.h> #include <experimental/bits/fs_path.h> #include <experimental/bits/fs_dir.h> #include <experimental/bits/fs_ops.h> #define __cpp_lib_experimental_filesystem 201406 #endif // C++11 #endif // _GLIBCXX_EXPERIMENTAL_FILESYSTEM	1.55 KB	2025-09-15 15:41
📄 forward_list // <experimental/forward_list> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/forward_list * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_FORWARD_LIST #define _GLIBCXX_EXPERIMENTAL_FORWARD_LIST 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <forward_list> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Tp, typename _Alloc, typename _Predicate> inline void erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred) { __cont.remove_if(__pred); } template<typename _Tp, typename _Alloc, typename _Up> inline void erase(forward_list<_Tp, _Alloc>& __cont, const _Up& __value) { using __elem_type = typename forward_list<_Tp, _Alloc>::value_type; std::experimental::erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; }); } namespace pmr { template<typename _Tp> using forward_list = std::forward_list<_Tp, polymorphic_allocator<_Tp>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_FORWARD_LIST	2.31 KB	2025-09-15 15:41
📄 functional // <experimental/functional> -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/functional * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_FUNCTIONAL #define _GLIBCXX_EXPERIMENTAL_FUNCTIONAL 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <functional> #include <tuple> #include <iterator> #include <unordered_map> #include <vector> #include <array> #include <bits/stl_algo.h> #ifdef _GLIBCXX_PARALLEL # include <parallel/algorithm> // For std::__parallel::search #endif #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { // See C++14 20.9.9, Function object binders /// Variable template for std::is_bind_expression template<typename _Tp> constexpr bool is_bind_expression_v = std::is_bind_expression<_Tp>::value; /// Variable template for std::is_placeholder template<typename _Tp> constexpr int is_placeholder_v = std::is_placeholder<_Tp>::value; #define __cpp_lib_experimental_boyer_moore_searching 201411 // Searchers template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>> class default_searcher { public: default_searcher(_ForwardIterator1 __pat_first, _ForwardIterator1 __pat_last, _BinaryPredicate __pred = _BinaryPredicate()) : _M_m(__pat_first, __pat_last, std::move(__pred)) { } template<typename _ForwardIterator2> _ForwardIterator2 operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const { return std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m), std::get<2>(_M_m)); } private: std::tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m; }; template<typename _Key, typename _Tp, typename _Hash, typename _Pred> struct __boyer_moore_map_base { template<typename _RAIter> __boyer_moore_map_base(_RAIter __pat, size_t __patlen, _Hash&& __hf, _Pred&& __pred) : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) } { if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) _M_bad_char[__pat[__i]] = __patlen - 1 - __i; } using __diff_type = _Tp; __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __iter = _M_bad_char.find(__key); if (__iter == _M_bad_char.end()) return __not_found; return __iter->second; } _Pred _M_pred() const { return _M_bad_char.key_eq(); } _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char; }; template<typename _Tp, size_t _Len, typename _Pred> struct __boyer_moore_array_base { template<typename _RAIter, typename _Unused> __boyer_moore_array_base(_RAIter __pat, size_t __patlen, _Unused&&, _Pred&& __pred) : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) } { std::get<0>(_M_bad_char).fill(__patlen); if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) { auto __ch = __pat[__i]; using _UCh = std::make_unsigned_t<decltype(__ch)>; auto __uch = static_cast<_UCh>(__ch); std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i; } } using __diff_type = _Tp; template<typename _Key> __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __ukey = static_cast<std::make_unsigned_t<_Key>>(__key); if (__ukey >= _Len) return __not_found; return std::get<0>(_M_bad_char)[__ukey]; } const _Pred& _M_pred() const { return std::get<1>(_M_bad_char); } std::tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char; }; // Use __boyer_moore_array_base when pattern consists of narrow characters // (or std::byte) and uses std::equal_to as the predicate. template<typename _RAIter, typename _Hash, typename _Pred, typename _Val = typename iterator_traits<_RAIter>::value_type, typename _Diff = typename iterator_traits<_RAIter>::difference_type> using __boyer_moore_base_t = std::conditional_t<std::__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>; template<typename _RAIter, typename _Hash = std::hash<typename std::iterator_traits<_RAIter>::value_type>, typename _BinaryPredicate = std::equal_to<>> class boyer_moore_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()); template<typename _RandomAccessIterator2> _RandomAccessIterator2 operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const; private: bool _M_is_prefix(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __suffixlen = __len - __pos; for (__diff_type __i = 0; __i < __suffixlen; ++__i) if (!__pred(__word[__i], __word[__pos + __i])) return false; return true; } __diff_type _M_suffix_length(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __i = 0; while (__pred(__word[__pos - __i], __word[__len - 1 - __i]) && __i < __pos) { ++__i; } return __i; } template<typename _Tp> __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; _GLIBCXX_STD_C::vector<__diff_type> _M_good_suffix; }; template<typename _RAIter, typename _Hash = std::hash<typename std::iterator_traits<_RAIter>::value_type>, typename _BinaryPredicate = std::equal_to<>> class boyer_moore_horspool_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_horspool_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end) { } template<typename _RandomAccessIterator2> _RandomAccessIterator2 operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { const auto& __pred = this->_M_pred(); auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return __first; auto __len = __last - __first; while (__len >= __patlen) { for (auto __scan = __patlen - 1; __pred(__first[__scan], _M_pat[__scan]); --__scan) if (__scan == 0) return __first; auto __shift = _M_bad_char_shift(__first[__patlen - 1]); __len -= __shift; __first += __shift; } return __last; } private: template<typename _Tp> __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; }; /// Generator function for default_searcher template<typename _ForwardIterator, typename _BinaryPredicate = std::equal_to<>> inline default_searcher<_ForwardIterator, _BinaryPredicate> make_default_searcher(_ForwardIterator __pat_first, _ForwardIterator __pat_last, _BinaryPredicate __pred = _BinaryPredicate()) { return { __pat_first, __pat_last, __pred }; } /// Generator function for boyer_moore_searcher template<typename _RAIter, typename _Hash = std::hash<typename std::iterator_traits<_RAIter>::value_type>, typename _BinaryPredicate = equal_to<>> inline boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate> make_boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) { return { __pat_first, __pat_last, std::move(__hf), std::move(__pred) }; } /// Generator function for boyer_moore_horspool_searcher template<typename _RAIter, typename _Hash = std::hash<typename std::iterator_traits<_RAIter>::value_type>, typename _BinaryPredicate = equal_to<>> inline boyer_moore_horspool_searcher<_RAIter, _Hash, _BinaryPredicate> make_boyer_moore_horspool_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) { return { __pat_first, __pat_last, std::move(__hf), std::move(__pred) }; } template<typename _RAIter, typename _Hash, typename _BinaryPredicate> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf, _BinaryPredicate __pred) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat) { auto __patlen = __pat_end - __pat; if (__patlen == 0) return; __diff_type __last_prefix = __patlen - 1; for (__diff_type __p = __patlen - 1; __p >= 0; --__p) { if (_M_is_prefix(__pat, __patlen, __p + 1)) __last_prefix = __p + 1; _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p); } for (__diff_type __p = 0; __p < __patlen - 1; ++__p) { auto __slen = _M_suffix_length(__pat, __patlen, __p); auto __pos = __patlen - 1 - __slen; if (!__pred(__pat[__p - __slen], __pat[__pos])) _M_good_suffix[__pos] = __patlen - 1 - __p + __slen; } } template<typename _RAIter, typename _Hash, typename _BinaryPredicate> template<typename _RandomAccessIterator2> _RandomAccessIterator2 boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return __first; const auto& __pred = this->_M_pred(); __diff_type __i = __patlen - 1; auto __stringlen = __last - __first; while (__i < __stringlen) { __diff_type __j = __patlen - 1; while (__j >= 0 && __pred(__first[__i], _M_pat[__j])) { --__i; --__j; } if (__j < 0) return __first + __i + 1; __i += std::max(_M_bad_char_shift(__first[__i]), _M_good_suffix[__j]); } return __last; } } // namespace fundamentals_v1 inline namespace fundamentals_v2 { #define __cpp_lib_experimental_not_fn 201406 /// [func.not_fn] Function template not_fn template<typename _Fn> inline auto not_fn(_Fn&& __fn) noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value) { return std::_Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0}; } } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_FUNCTIONAL	12 KB	2025-09-15 15:41
📄 internet // <experimental/internet> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/internet * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_INTERNET #define _GLIBCXX_EXPERIMENTAL_INTERNET #pragma GCC system_header #if __cplusplus >= 201402L #include <experimental/netfwd> #include <experimental/io_context> #include <experimental/bits/net.h> #include <array> #include <forward_list> #include <sstream> #include <cstdint> #include <experimental/string_view> #ifdef _GLIBCXX_HAVE_UNISTD_H # include <unistd.h> #endif #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H # include <sys/socket.h> // AF_INET, AF_INET6, SOCK_DGRAM, SOCK_STREAM #endif #ifdef _GLIBCXX_HAVE_ARPA_INET_H # include <arpa/inet.h> // inet_ntop #endif #ifdef _GLIBCXX_HAVE_NETINET_IN_H # include <netinet/in.h> // IPPROTO_IP, IPPROTO_IPV6, in_addr, in6_addr #endif #ifdef _GLIBCXX_HAVE_NETINET_TCP_H # include <netinet/tcp.h> // TCP_NODELAY #endif #ifdef _GLIBCXX_HAVE_NETDB_H # include <netdb.h> // getaddrinfo etc. #endif #if defined _WIN32 && __has_include(<ws2tcpip.h>) # include <ws2tcpip.h> #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { namespace ip { /* @addtogroup networking-ts * @{ / /* Error codes for resolver errors. * @{ / enum class resolver_errc : int { #ifdef _GLIBCXX_HAVE_NETDB_H host_not_found = EAI_NONAME, host_not_found_try_again = EAI_AGAIN, service_not_found = EAI_SERVICE #endif }; /// Error category for resolver errors. inline const error_category& resolver_category() noexcept // TODO non-inline { struct __cat : error_category { const char name() const noexcept { return "resolver"; } std::string message(int __e) const { #ifdef _GLIBCXX_HAVE_NETDB_H return ::gai_strerror(__e); #else return "name resolution requires <netdb.h>"; #endif } virtual void __message(int) { } // TODO dual ABI XXX }; static __cat __c; return __c; } inline error_code make_error_code(resolver_errc __e) noexcept { return error_code(static_cast<int>(__e), resolver_category()); } inline error_condition make_error_condition(resolver_errc __e) noexcept { return error_condition(static_cast<int>(__e), resolver_category()); } /// @} using port_type = uint_least16_t; ///< Type used for port numbers. using scope_id_type = uint_least32_t; ///< Type used for IPv6 scope IDs. /// Convenience alias for constraining allocators for strings. template<typename _Alloc> using __string_with = enable_if_t<std::is_same<typename _Alloc::value_type, char>::value, std::basic_string<char, std::char_traits<char>, _Alloc>>; constexpr errc __unsupported_err() noexcept { #if defined EAFNOSUPPORT return std::errc::address_family_not_supported; #else return std::errc::operation_not_supported; #endif } /** Tag indicating conversion between IPv4 and IPv4-mapped IPv6 addresses. * @{ / struct v4_mapped_t {}; constexpr v4_mapped_t v4_mapped; /// @} /// An IPv4 address. class address_v4 { public: // types: using uint_type = uint_least32_t; struct bytes_type : array<unsigned char, 4> { template<typename... _Tp> explicit constexpr bytes_type(_Tp... __tp) : array<unsigned char, 4>{{static_cast<unsigned char>(__tp)...}} { #if UCHAR_MAX > 0xFF for (auto __b : this) if (__b > 0xFF) __throw_out_of_range("invalid address_v4::bytes_type value"); #endif } }; // constructors: constexpr address_v4() noexcept : _M_addr(0) { } constexpr address_v4(const address_v4& a) noexcept = default; constexpr address_v4(const bytes_type& __b) : _M_addr((__b[0] << 24) \| (__b[1] << 16) \| (__b[2] << 8) \| __b[3]) { } explicit constexpr address_v4(uint_type __val) : _M_addr(_S_hton_32(__val)) { #if UINT_LEAST32_MAX > 0xFFFFFFFF if (__val > 0xFFFFFFFF) __throw_out_of_range("invalid address_v4::uint_type value"); #endif } // assignment: address_v4& operator=(const address_v4& a) noexcept = default; // members: constexpr bool is_unspecified() const noexcept { return to_uint() == 0; } constexpr bool is_loopback() const noexcept { return (to_uint() & 0xFF000000) == 0x7F000000; } constexpr bool is_multicast() const noexcept { return (to_uint() & 0xF0000000) == 0xE0000000; } constexpr bytes_type to_bytes() const noexcept { return bytes_type{ (_M_addr >> 24) & 0xFF, (_M_addr >> 16) & 0xFF, (_M_addr >> 8) & 0xFF, _M_addr & 0xFF }; } constexpr uint_type to_uint() const noexcept { return _S_ntoh_32(_M_addr); } template<typename _Allocator = allocator<char>> __string_with<_Allocator> to_string(const _Allocator& __a = _Allocator()) const { #ifdef _GLIBCXX_HAVE_ARPA_INET_H __string_with<_Allocator> __str(__a); __str.resize(INET_ADDRSTRLEN); if (inet_ntop(AF_INET, &_M_addr, &__str.front(), __str.size())) __str.erase(__str.find('\0')); else __str.resize(0); return __str; #else std::__throw_system_error((int)__unsupported_err()); #endif } // static members: static constexpr address_v4 any() noexcept { return address_v4{}; } static constexpr address_v4 loopback() noexcept { return address_v4{0x7F000001}; } static constexpr address_v4 broadcast() noexcept { return address_v4{0xFFFFFFFF}; } private: template<typename _InternetProtocol> friend class basic_endpoint; friend address_v4 make_address_v4(const char, error_code&) noexcept; #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ static constexpr uint16_t _S_hton_16(uint16_t __h) { return __h; } static constexpr uint16_t _S_ntoh_16(uint16_t __n) { return __n; } static constexpr uint32_t _S_hton_32(uint32_t __h) { return __h; } static constexpr uint32_t _S_ntoh_32(uint32_t __n) { return __n; } #else static constexpr uint16_t _S_hton_16(uint16_t __h) { return __builtin_bswap16(__h); } static constexpr uint16_t _S_ntoh_16(uint16_t __n) { return __builtin_bswap16(__n); } static constexpr uint32_t _S_hton_32(uint32_t __h) { return __builtin_bswap32(__h); } static constexpr uint32_t _S_ntoh_32(uint32_t __n) { return __builtin_bswap32(__n); } #endif #ifdef _GLIBCXX_HAVE_ARPA_INET_H in_addr_t _M_addr; // network byte order #else uint32_t _M_addr; #endif }; /// An IPv6 address. class address_v6 { public: // types: struct bytes_type : array<unsigned char, 16> { template<typename... _Tp> explicit constexpr bytes_type(_Tp... __t) : array<unsigned char, 16>{{static_cast<unsigned char>(__t)...}} { } }; // constructors: constexpr address_v6() noexcept : _M_bytes(), _M_scope_id() { } constexpr address_v6(const address_v6& __a) noexcept = default; constexpr address_v6(const bytes_type& __bytes, scope_id_type __scope = 0) : _M_bytes(__bytes), _M_scope_id(__scope) { } // assignment: address_v6& operator=(const address_v6& __a) noexcept = default; // members: void scope_id(scope_id_type __id) noexcept { _M_scope_id = __id; } constexpr scope_id_type scope_id() const noexcept { return _M_scope_id; } constexpr bool is_unspecified() const noexcept { for (int __i = 0; __i < 16; ++__i) if (_M_bytes[__i] != 0x00) return false; return _M_scope_id == 0; } constexpr bool is_loopback() const noexcept { for (int __i = 0; __i < 15; ++__i) if (_M_bytes[__i] != 0x00) return false; return _M_bytes[15] == 0x01 && _M_scope_id == 0; } constexpr bool is_multicast() const noexcept { return _M_bytes[0] == 0xFF; } constexpr bool is_link_local() const noexcept { return _M_bytes[0] == 0xFE && (_M_bytes[1] & 0xC0) == 0x80; } constexpr bool is_site_local() const noexcept { return _M_bytes[0] == 0xFE && (_M_bytes[1] & 0xC0) == 0xC0; } constexpr bool is_v4_mapped() const noexcept { const bytes_type& __b = _M_bytes; return __b[0] == 0 && __b[1] == 0 && __b[ 2] == 0 && __b[ 3] == 0 && __b[4] == 0 && __b[5] == 0 && __b[ 6] == 0 && __b[ 7] == 0 && __b[8] == 0 && __b[9] == 0 && __b[10] == 0xFF && __b[11] == 0xFF; } constexpr bool is_multicast_node_local() const noexcept { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x01; } constexpr bool is_multicast_link_local() const noexcept { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x02; } constexpr bool is_multicast_site_local() const noexcept { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x05; } constexpr bool is_multicast_org_local() const noexcept { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x08; } constexpr bool is_multicast_global() const noexcept { return is_multicast() && (_M_bytes[1] & 0x0F) == 0x0b; } constexpr bytes_type to_bytes() const noexcept { return _M_bytes; } template<typename _Allocator = allocator<char>> __string_with<_Allocator> to_string(const _Allocator& __a = _Allocator()) const { #ifdef _GLIBCXX_HAVE_ARPA_INET_H __string_with<_Allocator> __str(__a); __str.resize(INET6_ADDRSTRLEN + (_M_scope_id ? 11 : 0)); char const __p = &__str.front(); if (inet_ntop(AF_INET6, &_M_bytes, __p, __str.size())) { auto __end = __str.find('\0'); if (unsigned long __scope = _M_scope_id) { __end += #if _GLIBCXX_USE_C99_STDIO __builtin_snprintf(__p + __end, __str.size() - __end, "%%%lu", __scope); #else __builtin_sprintf(__p + __end, "%%%lu", __scope); #endif } __str.erase(__end); } else __str.resize(0); return __str; #else std::__throw_system_error((int)__unsupported_err()); #endif } // static members: static constexpr address_v6 any() noexcept { return {}; } static constexpr address_v6 loopback() noexcept { return {bytes_type{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}; } private: template<typename _InternetProtocol> friend class basic_endpoint; friend constexpr bool operator==(const address_v6&, const address_v6&) noexcept; friend constexpr bool operator< (const address_v6&, const address_v6&) noexcept; bytes_type _M_bytes; scope_id_type _M_scope_id; }; /// Exception type thrown on misuse of IPv4 addresses as IPv6 or vice versa. class bad_address_cast : public bad_cast { public: bad_address_cast() { } const char* what() const noexcept { return "bad address cast"; } }; /// An IPv4 or IPv6 address. class address { public: // constructors: constexpr address() noexcept : _M_v4(), _M_is_v4(true) { } #if __cpp_constexpr_dynamic_alloc constexpr #endif address(const address& __a) noexcept : _M_uninit(), _M_is_v4(__a._M_is_v4) { if (_M_is_v4) std::_Construct(std::addressof(_M_v4), __a.to_v4()); else std::_Construct(std::addressof(_M_v6), __a.to_v6()); } constexpr address(const address_v4& __a) noexcept : _M_v4(__a), _M_is_v4(true) { } constexpr address(const address_v6& __a) noexcept : _M_v6(__a), _M_is_v4(false) { } // assignment: address& operator=(const address& __a) noexcept { if (__a._M_is_v4) this = __a.to_v4(); else this = __a.to_v6(); return this; } address& operator=(const address_v4& __a) noexcept { std::_Construct(std::addressof(_M_v4), __a); _M_is_v4 = true; return this; } address& operator=(const address_v6& __a) noexcept { std::_Construct(std::addressof(_M_v6), __a); _M_is_v4 = false; return this; } // members: constexpr bool is_v4() const noexcept { return _M_is_v4; } constexpr bool is_v6() const noexcept { return !_M_is_v4; } constexpr address_v4 to_v4() const { if (!is_v4()) _GLIBCXX_THROW_OR_ABORT(bad_address_cast()); return _M_v4; } constexpr address_v6 to_v6() const { if (!is_v6()) _GLIBCXX_THROW_OR_ABORT(bad_address_cast()); return _M_v6; } constexpr bool is_unspecified() const noexcept { return _M_is_v4 ? _M_v4.is_unspecified() : _M_v6.is_unspecified(); } constexpr bool is_loopback() const noexcept { return _M_is_v4 ? _M_v4.is_loopback() : _M_v6.is_loopback(); } constexpr bool is_multicast() const noexcept { return _M_is_v4 ? _M_v4.is_multicast() : _M_v6.is_multicast(); } template<typename _Allocator = allocator<char>> __string_with<_Allocator> to_string(const _Allocator& __a = _Allocator()) const { if (_M_is_v4) return to_v4().to_string(__a); return to_v6().to_string(__a); } private: template<typename _InternetProtocol> friend class basic_endpoint; friend constexpr bool operator==(const address&, const address&) noexcept; friend constexpr bool operator<(const address&, const address&) noexcept; union { address_v4 _M_v4; address_v6 _M_v6; bool _M_uninit; }; bool _M_is_v4; }; /* ip::address_v4 comparisons * @{ / constexpr bool operator==(const address_v4& __a, const address_v4& __b) noexcept { return __a.to_uint() == __b.to_uint(); } constexpr bool operator!=(const address_v4& __a, const address_v4& __b) noexcept { return !(__a == __b); } constexpr bool operator< (const address_v4& __a, const address_v4& __b) noexcept { return __a.to_uint() < __b.to_uint(); } constexpr bool operator> (const address_v4& __a, const address_v4& __b) noexcept { return __b < __a; } constexpr bool operator<=(const address_v4& __a, const address_v4& __b) noexcept { return !(__b < __a); } constexpr bool operator>=(const address_v4& __a, const address_v4& __b) noexcept { return !(__a < __b); } /// @} /* ip::address_v6 comparisons * @{ / constexpr bool operator==(const address_v6& __a, const address_v6& __b) noexcept { const auto& __aa = __a._M_bytes; const auto& __bb = __b._M_bytes; int __i = 0; for (; __i < 16 && __aa[__i] == __bb[__i]; ++__i) ; return __i == 16 ? __a.scope_id() == __b.scope_id() : false; } constexpr bool operator!=(const address_v6& __a, const address_v6& __b) noexcept { return !(__a == __b); } constexpr bool operator< (const address_v6& __a, const address_v6& __b) noexcept { const auto& __aa = __a._M_bytes; const auto& __bb = __b._M_bytes; int __i = 0; for (; __i < 16 && __aa[__i] == __bb[__i]; ++__i) ; return __i == 16 ? __a.scope_id() < __b.scope_id() : __aa[__i] < __bb[__i]; } constexpr bool operator> (const address_v6& __a, const address_v6& __b) noexcept { return __b < __a; } constexpr bool operator<=(const address_v6& __a, const address_v6& __b) noexcept { return !(__b < __a); } constexpr bool operator>=(const address_v6& __a, const address_v6& __b) noexcept { return !(__a < __b); } /// @} /* ip::address comparisons * @{ / constexpr bool operator==(const address& __a, const address& __b) noexcept { if (__a.is_v4()) return __b.is_v4() ? __a._M_v4 == __b._M_v4 : false; return __b.is_v4() ? false : __a._M_v6 == __b._M_v6; } constexpr bool operator!=(const address& __a, const address& __b) noexcept { return !(__a == __b); } constexpr bool operator< (const address& __a, const address& __b) noexcept { if (__a.is_v4()) return __b.is_v4() ? __a._M_v4 < __b._M_v4 : true; return __b.is_v4() ? false : __a._M_v6 < __b._M_v6; } constexpr bool operator> (const address& __a, const address& __b) noexcept { return __b < __a; } constexpr bool operator<=(const address& __a, const address& __b) noexcept { return !(__b < __a); } constexpr bool operator>=(const address& __a, const address& __b) noexcept { return !(__a < __b); } /// @} /* ip::address_v4 creation * @{ / constexpr address_v4 make_address_v4(const address_v4::bytes_type& __b) { return address_v4{__b}; } constexpr address_v4 make_address_v4(address_v4::uint_type __val) { return address_v4{__val}; } constexpr address_v4 make_address_v4(v4_mapped_t, const address_v6& __a) { if (!__a.is_v4_mapped()) _GLIBCXX_THROW_OR_ABORT(bad_address_cast()); const auto __v6b = __a.to_bytes(); return address_v4::bytes_type(__v6b[12], __v6b[13], __v6b[14], __v6b[15]); } inline address_v4 make_address_v4(const char __str, error_code& __ec) noexcept { #ifdef _GLIBCXX_HAVE_ARPA_INET_H address_v4 __a; const int __res = ::inet_pton(AF_INET, __str, &__a._M_addr); if (__res == 1) { __ec.clear(); return __a; } if (__res == 0) __ec = std::make_error_code(std::errc::invalid_argument); else __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(__unsupported_err()); #endif return {}; } inline address_v4 make_address_v4(const char* __str) { return make_address_v4(__str, __throw_on_error{"make_address_v4"}); } inline address_v4 make_address_v4(const string& __str, error_code& __ec) noexcept { return make_address_v4(__str.c_str(), __ec); } inline address_v4 make_address_v4(const string& __str) { return make_address_v4(__str.c_str()); } inline address_v4 make_address_v4(string_view __str, error_code& __ec) noexcept { char __buf[16]; // INET_ADDRSTRLEN isn't defined on Windows auto __len = __str.copy(__buf, sizeof(__buf)); if (__len == sizeof(__buf)) { __ec = std::make_error_code(std::errc::invalid_argument); return {}; } __ec.clear(); __buf[__len] = '\0'; return make_address_v4(__buf, __ec); } inline address_v4 make_address_v4(string_view __str) { return make_address_v4(__str, __throw_on_error{"make_address_v4"}); } /// @} /** ip::address_v6 creation * @{ / constexpr address_v6 make_address_v6(const address_v6::bytes_type& __b, scope_id_type __scope = 0) { return address_v6{__b, __scope}; } constexpr address_v6 make_address_v6(v4_mapped_t, const address_v4& __a) noexcept { const address_v4::bytes_type __v4b = __a.to_bytes(); address_v6::bytes_type __v6b(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, __v4b[0], __v4b[1], __v4b[2], __v4b[3]); return address_v6(__v6b); } inline address_v6 __make_address_v6(const char __addr, const char* __scope, error_code& __ec) { #ifdef _GLIBCXX_HAVE_ARPA_INET_H address_v6::bytes_type __b; const int __res = ::inet_pton(AF_INET6, __addr, __b.data()); if (__res == 1) { __ec.clear(); if (!__scope) { return { __b }; } char* __eptr; unsigned long __val = std::strtoul(__scope, &__eptr, 10); if (__eptr != __scope && !__eptr && __val <= numeric_limits<scope_id_type>::max()) { return { __b, static_cast<scope_id_type>(__val) }; } __ec = std::make_error_code(std::errc::invalid_argument); } else if (__res == 0) __ec = std::make_error_code(std::errc::invalid_argument); else __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(__unsupported_err()); #endif return {}; } inline address_v6 make_address_v6(const char __str, error_code& __ec) noexcept { auto __p = __builtin_strchr(__str, '%'); if (__p == nullptr) return __make_address_v6(__str, nullptr, __ec); char __buf[64]; char* __out = __buf; bool __skip_leading_zero = true; while (__str < __p && __out < std::end(__buf)) { if (!__skip_leading_zero \|\| __str != '0') { if (__str == ':' \|\| __str == '.') __skip_leading_zero = true; else __skip_leading_zero = false; __out = __str; } __str++; } if (__out == std::end(__buf)) { __ec = std::make_error_code(std::errc::invalid_argument); return {}; } else { __out = '\0'; return __make_address_v6(__buf, __p + 1, __ec); } } inline address_v6 make_address_v6(const char* __str) { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); } inline address_v6 make_address_v6(const string& __str, error_code& __ec) noexcept { auto __pos = __str.find('%'); if (__pos == string::npos) return __make_address_v6(__str.c_str(), nullptr, __ec); char __buf[64]; char* __out = __buf; bool __skip_leading_zero = true; size_t __n = 0; while (__n < __pos && __out < std::end(__buf)) { if (!__skip_leading_zero \|\| __str[__n] != '0') { if (__str[__n] == ':' \|\| __str[__n] == '.') __skip_leading_zero = true; else __skip_leading_zero = false; __out = __str[__n]; } __n++; } if (__out == std::end(__buf)) { __ec = std::make_error_code(std::errc::invalid_argument); return {}; } else { __out = '\0'; return __make_address_v6(__buf, __str.c_str() + __pos + 1, __ec); } } inline address_v6 make_address_v6(const string& __str) { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); } inline address_v6 make_address_v6(string_view __str, error_code& __ec) noexcept { char __buf[64]; char* __out = __buf; char* __scope = nullptr; bool __skip_leading_zero = true; size_t __n = 0; while (__n < __str.length() && __out < std::end(__buf)) { if (__str[__n] == '%') { if (__scope) __out = std::end(__buf); else { __out = '\0'; __scope = ++__out; __skip_leading_zero = true; } } else if (!__skip_leading_zero \|\| __str[__n] != '0') { if (__str[__n] == ':' \|\| __str[__n] == '.') __skip_leading_zero = true; else __skip_leading_zero = false; __out = __str[__n]; __out++; } __n++; } if (__out == std::end(__buf)) { __ec = std::make_error_code(std::errc::invalid_argument); return {}; } else { __out = '\0'; return __make_address_v6(__buf, __scope, __ec); } } inline address_v6 make_address_v6(string_view __str) { return make_address_v6(__str, __throw_on_error{"make_address_v6"}); } /// @} /* ip::address creation * @{ / inline address make_address(const char __str, error_code& __ec) noexcept { address __a; address_v6 __v6a = make_address_v6(__str, __ec); if (!__ec) __a = __v6a; else { address_v4 __v4a = make_address_v4(__str, __ec); if (!__ec) __a = __v4a; } return __a; } inline address make_address(const char* __str) { return make_address(__str, __throw_on_error{"make_address"}); } inline address make_address(const string& __str, error_code& __ec) noexcept; // TODO inline address make_address(const string& __str) { return make_address(__str, __throw_on_error{"make_address"}); } inline address make_address(string_view __str, error_code& __ec) noexcept { if (__str.rfind('\0') != string_view::npos) return make_address(__str.data(), __ec); return make_address(__str.to_string(), __ec); // TODO don't allocate } inline address make_address(string_view __str) { return make_address(__str, __throw_on_error{"make_address"}); } /// @} /// ip::address I/O template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const address& __a) { return __os << __a.to_string(); } /// ip::address_v4 I/O template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const address_v4& __a) { return __os << __a.to_string(); } /// ip::address_v6 I/O template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const address_v6& __a) { return __os << __a.to_string(); } template<typename> class basic_address_iterator; // not defined template<> class basic_address_iterator<address_v4> { public: // types: using value_type = address_v4; using difference_type = ptrdiff_t; using pointer = const address_v4; using reference = const address_v4&; using iterator_category = input_iterator_tag; // constructors: basic_address_iterator(const address_v4& __a) noexcept : _M_address(__a) { } // members: reference operator() const noexcept { return _M_address; } pointer operator->() const noexcept { return &_M_address; } basic_address_iterator& operator++() noexcept { _M_address = value_type(_M_address.to_uint() + 1); return this; } basic_address_iterator operator++(int) noexcept { auto __tmp = this; ++this; return __tmp; } basic_address_iterator& operator--() noexcept { _M_address = value_type(_M_address.to_uint() - 1); return this; } basic_address_iterator operator--(int) noexcept { auto __tmp = this; --this; return __tmp; } bool operator==(const basic_address_iterator& __rhs) const noexcept { return _M_address == __rhs._M_address; } bool operator!=(const basic_address_iterator& __rhs) const noexcept { return _M_address != __rhs._M_address; } private: address_v4 _M_address; }; using address_v4_iterator = basic_address_iterator<address_v4>; template<> class basic_address_iterator<address_v6> { public: // types: using value_type = address_v6; using difference_type = ptrdiff_t; using pointer = const address_v6; using reference = const address_v6&; using iterator_category = input_iterator_tag; // constructors: basic_address_iterator(const address_v6& __a) noexcept : _M_address(__a) { } // members: reference operator() const noexcept { return _M_address; } pointer operator->() const noexcept { return &_M_address; } basic_address_iterator& operator++() noexcept; // TODO basic_address_iterator operator++(int) noexcept { auto __tmp = this; ++this; return __tmp; } basic_address_iterator& operator--() noexcept; // TODO basic_address_iterator operator--(int) noexcept { auto __tmp = this; --this; return __tmp; } bool operator==(const basic_address_iterator& __rhs) const noexcept { return _M_address == __rhs._M_address; } bool operator!=(const basic_address_iterator& __rhs) const noexcept { return _M_address != __rhs._M_address; } private: address_v6 _M_address; }; using address_v6_iterator = basic_address_iterator<address_v6>; template<typename> class basic_address_range; // not defined /** An IPv6 address range. * @{ / template<> class basic_address_range<address_v4> { public: // types: using iterator = basic_address_iterator<address_v4>; // constructors: basic_address_range() noexcept : _M_begin({}), _M_end({}) { } basic_address_range(const address_v4& __first, const address_v4& __last) noexcept : _M_begin(__first), _M_end(__last) { } // members: iterator begin() const noexcept { return _M_begin; } iterator end() const noexcept { return _M_end; } _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_begin == _M_end; } size_t size() const noexcept { return _M_end->to_uint() - _M_begin->to_uint(); } iterator find(const address_v4& __addr) const noexcept { if (_M_begin <= __addr && __addr < _M_end) return iterator{__addr}; return end(); } private: iterator _M_begin; iterator _M_end; }; using address_v4_range = basic_address_range<address_v4>; /// @} /* An IPv6 address range. * @{ / template<> class basic_address_range<address_v6> { public: // types: using iterator = basic_address_iterator<address_v6>; // constructors: basic_address_range() noexcept : _M_begin({}), _M_end({}) { } basic_address_range(const address_v6& __first, const address_v6& __last) noexcept : _M_begin(__first), _M_end(__last) { } // members: iterator begin() const noexcept { return _M_begin; } iterator end() const noexcept { return _M_end; } _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_begin == _M_end; } iterator find(const address_v6& __addr) const noexcept { if (_M_begin <= __addr && __addr < _M_end) return iterator{__addr}; return end(); } private: iterator _M_begin; iterator _M_end; }; using address_v6_range = basic_address_range<address_v6>; /// @} bool operator==(const network_v4& __a, const network_v4& __b) noexcept; bool operator==(const network_v6& __a, const network_v6& __b) noexcept; /// An IPv4 network address. class network_v4 { public: // constructors: constexpr network_v4() noexcept : _M_addr(), _M_prefix_len(0) { } constexpr network_v4(const address_v4& __addr, int __prefix_len) : _M_addr(__addr), _M_prefix_len(__prefix_len) { if (_M_prefix_len < 0 \|\| _M_prefix_len > 32) __throw_out_of_range("network_v4: invalid prefix length"); } constexpr network_v4(const address_v4& __addr, const address_v4& __mask) : _M_addr(__addr), _M_prefix_len(__builtin_popcount(__mask.to_uint())) { if (_M_prefix_len != 0) { address_v4::uint_type __mask_uint = __mask.to_uint(); if (__builtin_ctz(__mask_uint) != (32 - _M_prefix_len)) __throw_invalid_argument("network_v4: invalid mask"); if ((__mask_uint & 0x80000000) == 0) __throw_invalid_argument("network_v4: invalid mask"); } } // members: constexpr address_v4 address() const noexcept { return _M_addr; } constexpr int prefix_length() const noexcept { return _M_prefix_len; } constexpr address_v4 netmask() const noexcept { address_v4::uint_type __val = address_v4::broadcast().to_uint(); __val >>= (32 - _M_prefix_len); __val <<= (32 - _M_prefix_len); return address_v4{__val}; } constexpr address_v4 network() const noexcept { return address_v4{_M_addr.to_uint() & netmask().to_uint()}; } constexpr address_v4 broadcast() const noexcept { return address_v4{_M_addr.to_uint() \| ~netmask().to_uint()}; } address_v4_range hosts() const noexcept { if (is_host()) return { address(), ++address_v4_iterator(address()) }; return { network(), broadcast() }; } constexpr network_v4 canonical() const noexcept { return network_v4(network(), prefix_length()); } constexpr bool is_host() const noexcept { return _M_prefix_len == 32; } constexpr bool is_subnet_of(const network_v4& __other) const noexcept { if (__other.prefix_length() < prefix_length()) { network_v4 __net(address(), __other.prefix_length()); return __net.canonical() == __other.canonical(); } return false; } template<typename _Allocator = allocator<char>> __string_with<_Allocator> to_string(const _Allocator& __a = _Allocator()) const { return address().to_string(__a) + '/' + std::to_string(prefix_length()); } private: address_v4 _M_addr; int _M_prefix_len; }; /// An IPv6 network address. class network_v6 { public: // constructors: constexpr network_v6() noexcept : _M_addr(), _M_prefix_len(0) { } constexpr network_v6(const address_v6& __addr, int __prefix_len) : _M_addr(__addr), _M_prefix_len(__prefix_len) { if (_M_prefix_len < 0 \|\| _M_prefix_len > 128) __throw_out_of_range("network_v6: invalid prefix length"); } // members: constexpr address_v6 address() const noexcept { return _M_addr; } constexpr int prefix_length() const noexcept { return _M_prefix_len; } constexpr address_v6 network() const noexcept; // TODO address_v6_range hosts() const noexcept { if (is_host()) return { address(), ++address_v6_iterator(address()) }; return {}; // { network(), XXX broadcast() XXX }; // TODO } constexpr network_v6 canonical() const noexcept { return network_v6{network(), prefix_length()}; } constexpr bool is_host() const noexcept { return _M_prefix_len == 128; } constexpr bool is_subnet_of(const network_v6& __other) const noexcept { if (__other.prefix_length() < prefix_length()) { network_v6 __net(address(), __other.prefix_length()); return __net.canonical() == __other.canonical(); } return false; } template<typename _Allocator = allocator<char>> __string_with<_Allocator> to_string(const _Allocator& __a = _Allocator()) const { return address().to_string(__a) + '/' + std::to_string(prefix_length()); } private: address_v6 _M_addr; int _M_prefix_len; }; /* ip::network_v4 comparisons * @{ / inline bool operator==(const network_v4& __a, const network_v4& __b) noexcept { return __a.address() == __b.address() && __a.prefix_length() == __b.prefix_length(); } inline bool operator!=(const network_v4& __a, const network_v4& __b) noexcept { return !(__a == __b); } /// @} /* ip::network_v6 comparisons * @{ / inline bool operator==(const network_v6& __a, const network_v6& __b) noexcept { return __a.address() == __b.address() && __a.prefix_length() == __b.prefix_length(); } inline bool operator!=(const network_v6& __a, const network_v6& __b) noexcept { return !(__a == __b); } /// @} /* ip::network_v4 creation * @{ / inline network_v4 make_network_v4(const address_v4& __a, int __prefix_len) { return network_v4{__a, __prefix_len}; } inline network_v4 make_network_v4(const address_v4& __a, const address_v4& __mask) { return network_v4{ __a, __mask }; } network_v4 make_network_v4(const char, error_code&) noexcept; // TODO inline network_v4 make_network_v4(const char* __str) { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); } network_v4 make_network_v4(const string&, error_code&) noexcept; // TODO inline network_v4 make_network_v4(const string& __str) { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); } network_v4 make_network_v4(string_view, error_code&) noexcept; // TODO inline network_v4 make_network_v4(string_view __str) { return make_network_v4(__str, __throw_on_error{"make_network_v4"}); } /// @} /** ip::network_v6 creation * @{ / inline network_v6 make_network_v6(const address_v6& __a, int __prefix_len) { return network_v6{__a, __prefix_len}; } network_v6 make_network_v6(const char, error_code&) noexcept; // TODO inline network_v6 make_network_v6(const char* __str) { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); } network_v6 make_network_v6(const string&, error_code&) noexcept; // TODO inline network_v6 make_network_v6(const string& __str) { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); } network_v6 make_network_v6(string_view, error_code&) noexcept; // TODO inline network_v6 make_network_v6(string_view __str) { return make_network_v6(__str, __throw_on_error{"make_network_v6"}); } /// @} /// ip::network_v4 I/O template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const network_v4& __net) { return __os << __net.to_string(); } /// ip::network_v6 I/O template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const network_v6& __net) { return __os << __net.to_string(); } /// An IP endpoint. template<typename _InternetProtocol> class basic_endpoint { public: // types: using protocol_type = _InternetProtocol; // constructors: constexpr basic_endpoint() noexcept : _M_data() { _M_data._M_v4.sin_family = protocol_type::v4().family(); } constexpr basic_endpoint(const protocol_type& __proto, port_type __port_num) noexcept : _M_data() { __glibcxx_assert(__proto == protocol_type::v4() \|\| __proto == protocol_type::v6()); _M_data._M_v4.sin_family = __proto.family(); _M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num); } constexpr basic_endpoint(const ip::address& __addr, port_type __port_num) noexcept : _M_data() { if (__addr.is_v4()) { _M_data._M_v4.sin_family = protocol_type::v4().family(); _M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num); _M_data._M_v4.sin_addr.s_addr = __addr._M_v4._M_addr; } else { _M_data._M_v6 = {}; _M_data._M_v6.sin6_family = protocol_type::v6().family(); _M_data._M_v6.sin6_port = address_v4::_S_hton_16(__port_num); __builtin_memcpy(_M_data._M_v6.sin6_addr.s6_addr, __addr._M_v6._M_bytes.data(), 16); _M_data._M_v6.sin6_scope_id = __addr._M_v6._M_scope_id; } } // members: constexpr protocol_type protocol() const noexcept { return _M_is_v6() ? protocol_type::v6() : protocol_type::v4(); } constexpr ip::address address() const noexcept { ip::address __addr; if (_M_is_v6()) { __builtin_memcpy(&__addr._M_v6._M_bytes, _M_data._M_v6.sin6_addr.s6_addr, 16); __addr._M_is_v4 = false; } else { __builtin_memcpy(&__addr._M_v4._M_addr, &_M_data._M_v4.sin_addr.s_addr, 4); } return __addr; } void address(const ip::address& __addr) noexcept { if (__addr.is_v6()) { _M_data._M_v6 = {}; _M_data._M_v6.sin6_family = protocol_type::v6().family(); __builtin_memcpy(_M_data._M_v6.sin6_addr.s6_addr, __addr._M_v6._M_bytes.data(), 16); _M_data._M_v6.sin6_scope_id = __addr._M_v6._M_scope_id; } else { _M_data._M_v4.sin_family = protocol_type::v4().family(); _M_data._M_v4.sin_addr.s_addr = __addr._M_v4._M_addr; } } constexpr port_type port() const noexcept { return address_v4::_S_ntoh_16(_M_data._M_v4.sin_port); } void port(port_type __port_num) noexcept { _M_data._M_v4.sin_port = address_v4::_S_hton_16(__port_num); } void* data() noexcept { return &_M_data; } const void* data() const noexcept { return &_M_data; } constexpr size_t size() const noexcept { return _M_is_v6() ? sizeof(sockaddr_in6) : sizeof(sockaddr_in); } void resize(size_t __s) { if (__s != size()) __throw_length_error("net::ip::basic_endpoint::resize"); } constexpr size_t capacity() const noexcept { return sizeof(_M_data); } private: union { sockaddr_in _M_v4; sockaddr_in6 _M_v6; } _M_data; constexpr bool _M_is_v6() const noexcept { return _M_data._M_v4.sin_family == AF_INET6; } }; /** basic_endpoint comparisons * @{ / template<typename _InternetProtocol> inline bool operator==(const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return __a.address() == __b.address() && __a.port() == __b.port(); } template<typename _InternetProtocol> inline bool operator!=(const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return !(__a == __b); } template<typename _InternetProtocol> inline bool operator< (const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return __a.address() < __b.address() \|\| (!(__b.address() < __a.address()) && __a.port() < __b.port()); } template<typename _InternetProtocol> inline bool operator> (const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return __b < __a; } template<typename _InternetProtocol> inline bool operator<=(const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return !(__b < __a); } template<typename _InternetProtocol> inline bool operator>=(const basic_endpoint<_InternetProtocol>& __a, const basic_endpoint<_InternetProtocol>& __b) { return !(__a < __b); } /// @} /// basic_endpoint I/O template<typename _CharT, typename _Traits, typename _InternetProtocol> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_endpoint<_InternetProtocol>& __ep) { basic_ostringstream<_CharT, _Traits> __ss; if (__ep.protocol() == basic_endpoint<_InternetProtocol>::protocol_type::v6()) __ss << '[' << __ep.address() << ']'; else __ss << __ep.address(); __ss << ':' << __ep.port(); __os << __ss.str(); return __os; } /* Type representing a single result of name/address resolution. * @{ / template<typename _InternetProtocol> class basic_resolver_entry { public: // types: using protocol_type = _InternetProtocol; using endpoint_type = typename _InternetProtocol::endpoint; // constructors: basic_resolver_entry() { } basic_resolver_entry(const endpoint_type& __ep, string_view __h, string_view __s) : _M_ep(__ep), _M_host(__h), _M_svc(__s) { } // members: endpoint_type endpoint() const { return _M_ep; } operator endpoint_type() const { return _M_ep; } template<typename _Allocator = allocator<char>> __string_with<_Allocator> host_name(const _Allocator& __a = _Allocator()) const { return { _M_host, __a }; } template<typename _Allocator = allocator<char>> __string_with<_Allocator> service_name(const _Allocator& __a = _Allocator()) const { return { _M_svc, __a }; } private: basic_endpoint<_InternetProtocol> _M_ep; string _M_host; string _M_svc; }; template<typename _InternetProtocol> inline bool operator==(const basic_resolver_entry<_InternetProtocol>& __a, const basic_resolver_entry<_InternetProtocol>& __b) { return __a.endpoint() == __b.endpoint() && __a.host_name() == __b.host_name() && __a.service_name() == __b.service_name(); } template<typename _InternetProtocol> inline bool operator!=(const basic_resolver_entry<_InternetProtocol>& __a, const basic_resolver_entry<_InternetProtocol>& __b) { return !(__a == __b); } /// @} /* Base class defining flags for name/address resolution. * @{ / class resolver_base { public: enum flags : int { }; static constexpr flags passive = (flags)AI_PASSIVE; static constexpr flags canonical_name = (flags)AI_CANONNAME; static constexpr flags numeric_host = (flags)AI_NUMERICHOST; #ifdef AI_NUMERICSERV static constexpr flags numeric_service = (flags)AI_NUMERICSERV; #endif #ifdef AI_V4MAPPED static constexpr flags v4_mapped = (flags)AI_V4MAPPED; #endif #ifdef AI_ALL static constexpr flags all_matching = (flags)AI_ALL; #endif #ifdef AI_ADDRCONFIG static constexpr flags address_configured = (flags)AI_ADDRCONFIG; #endif friend constexpr flags operator&(flags __f1, flags __f2) noexcept { return flags( int(__f1) & int(__f2) ); } friend constexpr flags operator\|(flags __f1, flags __f2) noexcept { return flags( int(__f1) \| int(__f2) ); } friend constexpr flags operator^(flags __f1, flags __f2) noexcept { return flags( int(__f1) ^ int(__f2) ); } friend constexpr flags operator~(flags __f) noexcept { return flags( ~int(__f) ); } friend constexpr flags& operator&=(flags& __f1, flags __f2) noexcept { return __f1 = (__f1 & __f2); } friend constexpr flags& operator\|=(flags& __f1, flags __f2) noexcept { return __f1 = (__f1 \| __f2); } friend constexpr flags& operator^=(flags& __f1, flags __f2) noexcept { return __f1 = (__f1 ^ __f2); } protected: resolver_base() = default; ~resolver_base() = default; }; // TODO define resolver_base::flags static constants in .so for C++14 mode /// @} /* Container for results of name/address resolution. * @{ / template<typename _InternetProtocol> class basic_resolver_results { public: // types: using protocol_type = _InternetProtocol; using endpoint_type = typename protocol_type::endpoint; using value_type = basic_resolver_entry<protocol_type>; using const_reference = const value_type&; using reference = value_type&; using const_iterator = typename forward_list<value_type>::const_iterator; using iterator = const_iterator; using difference_type = ptrdiff_t; using size_type = size_t; // construct / copy / destroy: basic_resolver_results() = default; basic_resolver_results(const basic_resolver_results&) = default; basic_resolver_results(basic_resolver_results&&) noexcept = default; basic_resolver_results& operator=(const basic_resolver_results&) = default; basic_resolver_results& operator=(basic_resolver_results&&) = default; ~basic_resolver_results() = default; // size: size_type size() const noexcept { return _M_size; } size_type max_size() const noexcept { return _M_results.max_size(); } _GLIBCXX_NODISCARD bool empty() const noexcept { return _M_results.empty(); } // element access: const_iterator begin() const { return _M_results.begin(); } const_iterator end() const { return _M_results.end(); } const_iterator cbegin() const { return _M_results.begin(); } const_iterator cend() const { return _M_results.end(); } // swap: void swap(basic_resolver_results& __that) noexcept { _M_results.swap(__that._M_results); } private: friend class basic_resolver<protocol_type>; basic_resolver_results(string_view, string_view, resolver_base::flags, error_code&, protocol_type = nullptr); basic_resolver_results(const endpoint_type&, error_code&); forward_list<value_type> _M_results; size_t _M_size = 0; }; template<typename _InternetProtocol> inline bool operator==(const basic_resolver_results<_InternetProtocol>& __a, const basic_resolver_results<_InternetProtocol>& __b) { return __a.size() == __b.size() && std::equal(__a.begin(), __a.end(), __b.begin()); } template<typename _InternetProtocol> inline bool operator!=(const basic_resolver_results<_InternetProtocol>& __a, const basic_resolver_results<_InternetProtocol>& __b) { return !(__a == __b); } /// @} /// Perform name/address resolution. template<typename _InternetProtocol> class basic_resolver : public resolver_base { public: // types: using executor_type = io_context::executor_type; using protocol_type = _InternetProtocol; using endpoint_type = typename _InternetProtocol::endpoint; using results_type = basic_resolver_results<_InternetProtocol>; // construct / copy / destroy: explicit basic_resolver(io_context& __ctx) : _M_ctx(&__ctx) { } basic_resolver(const basic_resolver&) = delete; basic_resolver(basic_resolver&& __rhs) noexcept : _M_ctx(__rhs._M_ctx) { } // TODO move state/tasks etc. ~basic_resolver() { cancel(); } basic_resolver& operator=(const basic_resolver&) = delete; basic_resolver& operator=(basic_resolver&& __rhs) { cancel(); _M_ctx = __rhs._M_ctx; // TODO move state/tasks etc. return this; } // basic_resolver operations: executor_type get_executor() noexcept { return _M_ctx->get_executor(); } void cancel() { } // TODO results_type resolve(string_view __host_name, string_view __service_name) { return resolve(__host_name, __service_name, resolver_base::flags(), __throw_on_error{"basic_resolver::resolve"}); } results_type resolve(string_view __host_name, string_view __service_name, error_code& __ec) { return resolve(__host_name, __service_name, resolver_base::flags(), __ec); } results_type resolve(string_view __host_name, string_view __service_name, flags __f) { return resolve(__host_name, __service_name, __f, __throw_on_error{"basic_resolver::resolve"}); } results_type resolve(string_view __host_name, string_view __service_name, flags __f, error_code& __ec) { return {__host_name, __service_name, __f, __ec}; } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, results_type)> async_resolve(string_view __host_name, string_view __service_name, _CompletionToken&& __token) { return async_resolve(__host_name, __service_name, resolver_base::flags(), forward<_CompletionToken>(__token)); } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, results_type)> async_resolve(string_view __host_name, string_view __service_name, flags __f, _CompletionToken&& __token); // TODO results_type resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name) { return resolve(__protocol, __host_name, __service_name, resolver_base::flags(), __throw_on_error{"basic_resolver::resolve"}); } results_type resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name, error_code& __ec) { return resolve(__protocol, __host_name, __service_name, resolver_base::flags(), __ec); } results_type resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name, flags __f) { return resolve(__protocol, __host_name, __service_name, __f, __throw_on_error{"basic_resolver::resolve"}); } results_type resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name, flags __f, error_code& __ec) { return {__host_name, __service_name, __f, __ec, &__protocol}; } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, results_type)> async_resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name, _CompletionToken&& __token) { return async_resolve(__protocol, __host_name, __service_name, resolver_base::flags(), forward<_CompletionToken>(__token)); } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, results_type)> async_resolve(const protocol_type& __protocol, string_view __host_name, string_view __service_name, flags __f, _CompletionToken&& __token); // TODO results_type resolve(const endpoint_type& __ep) { return resolve(__ep, __throw_on_error{"basic_resolver::resolve"}); } results_type resolve(const endpoint_type& __ep, error_code& __ec) { return { __ep, __ec }; } template<typename _CompletionToken> // TODO __deduced_t<_CompletionToken, void(error_code, results_type)> async_resolve(const endpoint_type& __ep, _CompletionToken&& __token); private: io_context _M_ctx; }; /// Private constructor to synchronously resolve host and service names. template<typename _InternetProtocol> basic_resolver_results<_InternetProtocol>:: basic_resolver_results(string_view __host_name, string_view __service_name, resolver_base::flags __f, error_code& __ec, protocol_type* __protocol) { #ifdef _GLIBCXX_HAVE_NETDB_H string __host; const char* __h = __host_name.data() ? (__host = __host_name.to_string()).c_str() : nullptr; string __svc; const char* __s = __service_name.data() ? (__svc = __service_name.to_string()).c_str() : nullptr; ::addrinfo __hints{ }; __hints.ai_flags = static_cast<int>(__f); if (__protocol) { __hints.ai_family = __protocol->family(); __hints.ai_socktype = __protocol->type(); __hints.ai_protocol = __protocol->protocol(); } else { auto __p = endpoint_type{}.protocol(); __hints.ai_family = AF_UNSPEC; __hints.ai_socktype = __p.type(); __hints.ai_protocol = __p.protocol(); } struct __scoped_addrinfo { ~__scoped_addrinfo() { if (_M_p) ::freeaddrinfo(_M_p); } ::addrinfo* _M_p = nullptr; } __sai; if (int __err = ::getaddrinfo(__h, __s, &__hints, &__sai._M_p)) { __ec.assign(__err, resolver_category()); return; } __ec.clear(); endpoint_type __ep; auto __tail = _M_results.before_begin(); for (auto __ai = __sai._M_p; __ai != nullptr; __ai = __ai->ai_next) { if (__ai->ai_family == AF_INET \|\| __ai->ai_family == AF_INET6) { if (__ai->ai_addrlen <= __ep.capacity()) __builtin_memcpy(__ep.data(), __ai->ai_addr, __ai->ai_addrlen); __ep.resize(__ai->ai_addrlen); __tail = _M_results.emplace_after(__tail, __ep, __host, __svc); _M_size++; } } #else __ec = std::make_error_code(errc::operation_not_supported); #endif } /// Private constructor to synchronously resolve an endpoint. template<typename _InternetProtocol> basic_resolver_results<_InternetProtocol>:: basic_resolver_results(const endpoint_type& __ep, error_code& __ec) { #ifdef _GLIBCXX_HAVE_NETDB_H char __host_name[256]; char __service_name[128]; int __flags = 0; if (__ep.protocol().type() == SOCK_DGRAM) __flags \|= NI_DGRAM; auto __sa = static_cast<const sockaddr>(__ep.data()); int __err = ::getnameinfo(__sa, __ep.size(), __host_name, sizeof(__host_name), __service_name, sizeof(__service_name), __flags); if (__err) { __flags \|= NI_NUMERICSERV; __err = ::getnameinfo(__sa, __ep.size(), __host_name, sizeof(__host_name), __service_name, sizeof(__service_name), __flags); } if (__err) __ec.assign(__err, resolver_category()); else { __ec.clear(); _M_results.emplace_front(__ep, __host_name, __service_name); _M_size = 1; } #else __ec = std::make_error_code(errc::operation_not_supported); #endif } /* The name of the local host. * @{ / template<typename _Allocator> __string_with<_Allocator> host_name(const _Allocator& __a, error_code& __ec) { #ifdef HOST_NAME_MAX constexpr size_t __maxlen = HOST_NAME_MAX; #else constexpr size_t __maxlen = 256; #endif char __buf[__maxlen + 1]; if (::gethostname(__buf, __maxlen) == -1) __ec.assign(errno, generic_category()); __buf[__maxlen] = '\0'; return { __buf, __a }; } template<typename _Allocator> inline __string_with<_Allocator> host_name(const _Allocator& __a) { return host_name(__a, __throw_on_error{"host_name"}); } inline string host_name(error_code& __ec) { return host_name(std::allocator<char>{}, __ec); } inline string host_name() { return host_name(std::allocator<char>{}, __throw_on_error{"host_name"}); } /// @} #ifdef IPPROTO_TCP /// The TCP byte-stream protocol. class tcp { public: // types: using endpoint = basic_endpoint<tcp>; ///< A TCP endpoint. using resolver = basic_resolver<tcp>; ///< A TCP resolver. using socket = basic_stream_socket<tcp>; ///< A TCP socket. using acceptor = basic_socket_acceptor<tcp>; ///< A TCP acceptor. using iostream = basic_socket_iostream<tcp>; /// A TCP iostream. #ifdef TCP_NODELAY /// Disable coalescing of small segments (i.e. the Nagle algorithm). struct no_delay : __sockopt_crtp<no_delay, bool> { using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; static const int _S_level = IPPROTO_TCP; static const int _S_name = TCP_NODELAY; }; #endif // static members: /// A protocol object representing IPv4 TCP. static constexpr tcp v4() noexcept { return tcp(AF_INET); } /// A protocol object representing IPv6 TCP. static constexpr tcp v6() noexcept { return tcp(AF_INET6); } tcp() = delete; constexpr int family() const noexcept { return _M_family; } constexpr int type() const noexcept { return SOCK_STREAM; } constexpr int protocol() const noexcept { return IPPROTO_TCP; } private: constexpr explicit tcp(int __family) : _M_family(__family) { } int _M_family; }; /* tcp comparisons * @{ / constexpr bool operator==(const tcp& __a, const tcp& __b) noexcept { return __a.family() == __b.family(); } constexpr bool operator!=(const tcp& __a, const tcp& __b) noexcept { return !(__a == __b); } /// @} #endif // IPPROTO_TCP #ifdef IPPROTO_UDP /// The UDP datagram protocol. class udp { public: // types: using endpoint = basic_endpoint<udp>; using resolver = basic_resolver<udp>; using socket = basic_datagram_socket<udp>; // static members: static constexpr udp v4() noexcept { return udp(AF_INET); } static constexpr udp v6() noexcept { return udp(AF_INET6); } udp() = delete; constexpr int family() const noexcept { return _M_family; } constexpr int type() const noexcept { return SOCK_DGRAM; } constexpr int protocol() const noexcept { return IPPROTO_UDP; } private: constexpr explicit udp(int __family) : _M_family(__family) { } int _M_family; }; /* udp comparisons * @{ / constexpr bool operator==(const udp& __a, const udp& __b) noexcept { return __a.family() == __b.family(); } constexpr bool operator!=(const udp& __a, const udp& __b) noexcept { return !(__a == __b); } /// @} #endif // IPPROTO_UDP #if defined IPPROTO_IP && defined IPPROTO_IPV6 /// Restrict a socket created for an IPv6 protocol to IPv6 only. class v6_only : public __sockopt_crtp<v6_only, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<v6_only, bool>; static const int _S_level = IPPROTO_IPV6; static const int _S_name = IPV6_V6ONLY; }; namespace unicast { /// Set the default number of hops (TTL) for outbound datagrams. class hops : public __sockopt_crtp<hops> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; template<typename _Protocol> int level(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; } template<typename _Protocol> int name(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPV6_UNICAST_HOPS : IP_TTL; } }; } // namespace unicast namespace multicast { class __mcastopt { public: explicit __mcastopt(const address& __grp) noexcept : __mcastopt(__grp.is_v4() ? __mcastopt(__grp.to_v4()) : __mcastopt(__grp.to_v6())) { } explicit __mcastopt(const address_v4& __grp, const address_v4& __iface = address_v4::any()) noexcept { #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ _M_v4.imr_multiaddr.s_addr = __grp.to_uint(); _M_v4.imr_interface.s_addr = __iface.to_uint(); #else _M_v4.imr_multiaddr.s_addr = __builtin_bswap32(__grp.to_uint()); _M_v4.imr_interface.s_addr = __builtin_bswap32(__iface.to_uint()); #endif } explicit __mcastopt(const address_v6& __grp, unsigned int __iface = 0) noexcept { const auto __addr = __grp.to_bytes(); __builtin_memcpy(_M_v6.ipv6mr_multiaddr.s6_addr, __addr.data(), 16); _M_v6.ipv6mr_interface = __iface; } template<typename _Protocol> int level(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; } template<typename _Protocol> const void data(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? &_M_v6 : &_M_v4; } template<typename _Protocol> size_t size(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? sizeof(_M_v6) : sizeof(_M_v4); } private: ipv6_mreq _M_v6 = {}; ip_mreq _M_v4 = {}; }; /// Request that a socket joins a multicast group. class join_group : private __mcastopt { public: using __mcastopt::__mcastopt; using __mcastopt::level; using __mcastopt::data; using __mcastopt::size; template<typename _Protocol> int name(const _Protocol& __p) const noexcept { if (__p.family() == AF_INET6) return IPV6_JOIN_GROUP; return IP_ADD_MEMBERSHIP; } }; /// Request that a socket leaves a multicast group. class leave_group : private __mcastopt { public: using __mcastopt::__mcastopt; using __mcastopt::level; using __mcastopt::data; using __mcastopt::size; template<typename _Protocol> int name(const _Protocol& __p) const noexcept { if (__p.family() == AF_INET6) return IPV6_LEAVE_GROUP; return IP_DROP_MEMBERSHIP; } }; /// Specify the network interface for outgoing multicast datagrams. class outbound_interface { public: explicit outbound_interface(const address_v4& __v4) noexcept { #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ _M_v4.s_addr = __v4.to_uint(); #else _M_v4.s_addr = __builtin_bswap32(__v4.to_uint()); #endif } explicit outbound_interface(unsigned int __v6) noexcept : _M_v4(), _M_v6(__v6) { } template<typename _Protocol> int level(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; } template<typename _Protocol> int name(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPV6_MULTICAST_IF : IP_MULTICAST_IF; } template<typename _Protocol> const void* data(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? &_M_v6 : &_M_v4; } template<typename _Protocol> size_t size(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? sizeof(_M_v6) : sizeof(_M_v4); } private: in_addr _M_v4; unsigned _M_v6 = 0; }; /// Set the default number of hops (TTL) for outbound datagrams. class hops : public __sockopt_crtp<hops> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; template<typename _Protocol> int level(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; } template<typename _Protocol> int name(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPV6_MULTICAST_HOPS : IP_MULTICAST_TTL; } }; /// Set whether datagrams are delivered back to the local application. class enable_loopback : public __sockopt_crtp<enable_loopback, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; template<typename _Protocol> int level(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IP; } template<typename _Protocol> int name(const _Protocol& __p) const noexcept { return __p.family() == AF_INET6 ? IPV6_MULTICAST_LOOP : IP_MULTICAST_LOOP; } }; } // namespace multicast #endif // IPPROTO_IP && IPPROTO_IPV6 /// @} } // namespace ip } // namespace v1 } // namespace net } // namespace experimental template<> struct is_error_condition_enum<experimental::net::v1::ip::resolver_errc> : public true_type {}; // hash support template<typename _Tp> struct hash; template<> struct hash<experimental::net::v1::ip::address> : __hash_base<size_t, experimental::net::v1::ip::address> { size_t operator()(const experimental::net::v1::ip::address& __a) const { if (__a.is_v4()) return _Hash_impl::hash(__a.to_v4()); else return _Hash_impl::hash(__a.to_v6()); } }; template<> struct hash<experimental::net::v1::ip::address_v4> : __hash_base<size_t, experimental::net::v1::ip::address_v4> { size_t operator()(const experimental::net::v1::ip::address_v4& __a) const { return _Hash_impl::hash(__a.to_bytes()); } }; template<> struct hash<experimental::net::v1::ip::address_v6> : __hash_base<size_t, experimental::net::v1::ip::address_v6> { size_t operator()(const experimental::net::v1::ip::address_v6& __a) const { return _Hash_impl::hash(__a.to_bytes()); } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_INTERNET	64.77 KB	2025-09-15 15:41
📄 io_context // <experimental/io_service> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/io_context * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_IO_SERVICE #define _GLIBCXX_EXPERIMENTAL_IO_SERVICE 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <atomic> #include <chrono> #include <forward_list> #include <functional> #include <system_error> #include <thread> #include <vector> #include <experimental/netfwd> #include <experimental/executor> #if _GLIBCXX_HAVE_UNISTD_H # include <unistd.h> #endif #ifdef _GLIBCXX_HAVE_POLL_H # include <poll.h> #endif #ifdef _GLIBCXX_HAVE_FCNTL_H # include <fcntl.h> #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @addtogroup networking-ts * @{ / class __socket_impl; /// An ExecutionContext for I/O operations. class io_context : public execution_context { public: // types: /// An executor for an io_context. class executor_type { public: // construct / copy / destroy: executor_type(const executor_type& __other) noexcept = default; executor_type(executor_type&& __other) noexcept = default; executor_type& operator=(const executor_type& __other) noexcept = default; executor_type& operator=(executor_type&& __other) noexcept = default; // executor operations: bool running_in_this_thread() const noexcept { #ifdef _GLIBCXX_HAS_GTHREADS lock_guard<execution_context::mutex_type> __lock(_M_ctx->_M_mtx); auto __end = _M_ctx->_M_call_stack.end(); return std::find(_M_ctx->_M_call_stack.begin(), __end, this_thread::get_id()) != __end; #else return _M_ctx->_M_run_count != 0; #endif } io_context& context() const noexcept { return _M_ctx; } void on_work_started() const noexcept { ++_M_ctx->_M_work_count; } void on_work_finished() const noexcept { --_M_ctx->_M_work_count; } template<typename _Func, typename _ProtoAllocator> void dispatch(_Func&& __f, const _ProtoAllocator& __a) const { if (running_in_this_thread()) decay_t<_Func>{std::forward<_Func>(__f)}(); else post(std::forward<_Func>(__f), __a); } template<typename _Func, typename _ProtoAllocator> void post(_Func&& __f, const _ProtoAllocator& __a) const { lock_guard<execution_context::mutex_type> __lock(_M_ctx->_M_mtx); // TODO (re-use functionality in system_context) _M_ctx->_M_reactor._M_notify(); } template<typename _Func, typename _ProtoAllocator> void defer(_Func&& __f, const _ProtoAllocator& __a) const { post(std::forward<_Func>(__f), __a); } private: friend io_context; explicit executor_type(io_context& __ctx) : _M_ctx(std::addressof(__ctx)) { } io_context* _M_ctx; }; using count_type = size_t; // construct / copy / destroy: io_context() : _M_work_count(0) { } explicit io_context(int __concurrency_hint) : _M_work_count(0) { } io_context(const io_context&) = delete; io_context& operator=(const io_context&) = delete; // io_context operations: executor_type get_executor() noexcept { return executor_type(this); } count_type run() { count_type __n = 0; while (run_one()) if (__n != numeric_limits<count_type>::max()) ++__n; return __n; } template<typename _Rep, typename _Period> count_type run_for(const chrono::duration<_Rep, _Period>& __rel_time) { return run_until(chrono::steady_clock::now() + __rel_time); } template<typename _Clock, typename _Duration> count_type run_until(const chrono::time_point<_Clock, _Duration>& __abs_time) { count_type __n = 0; while (run_one_until(__abs_time)) if (__n != numeric_limits<count_type>::max()) ++__n; return __n; } count_type run_one() { return _M_do_one(chrono::milliseconds{-1}); } template<typename _Rep, typename _Period> count_type run_one_for(const chrono::duration<_Rep, _Period>& __rel_time) { return run_one_until(chrono::steady_clock::now() + __rel_time); } template<typename _Clock, typename _Duration> count_type run_one_until(const chrono::time_point<_Clock, _Duration>& __abs_time) { auto __now = _Clock::now(); while (__now < __abs_time) { using namespace std::chrono; auto __ms = duration_cast<milliseconds>(__abs_time - __now); if (_M_do_one(__ms)) return 1; __now = _Clock::now(); } return 0; } count_type poll() { count_type __n = 0; while (poll_one()) if (__n != numeric_limits<count_type>::max()) ++__n; return __n; } count_type poll_one() { return _M_do_one(chrono::milliseconds{0}); } void stop() { lock_guard<execution_context::mutex_type> __lock(_M_mtx); _M_stopped = true; _M_reactor._M_notify(); } bool stopped() const noexcept { lock_guard<execution_context::mutex_type> __lock(_M_mtx); return _M_stopped; } void restart() { _M_stopped = false; } private: template<typename _Clock, typename _WaitTraits> friend class basic_waitable_timer; friend __socket_impl; template<typename _Protocol> friend class __basic_socket_impl; template<typename _Protocol> friend class basic_socket; template<typename _Protocol> friend class basic_datagram_socket; template<typename _Protocol> friend class basic_stream_socket; template<typename _Protocol> friend class basic_socket_acceptor; count_type _M_outstanding_work() const { return _M_work_count + !_M_ops.empty(); } struct __timer_queue_base : execution_context::service { // return milliseconds until next timer expires, or milliseconds::max() virtual chrono::milliseconds _M_next() const = 0; virtual bool run_one() = 0; protected: explicit __timer_queue_base(execution_context& __ctx) : service(__ctx) { auto& __ioc = static_cast<io_context&>(__ctx); lock_guard<execution_context::mutex_type> __lock(__ioc._M_mtx); __ioc._M_timers.push_back(this); } mutable execution_context::mutex_type _M_qmtx; }; template<typename _Timer, typename _Key = typename _Timer::_Key> struct __timer_queue : __timer_queue_base { using key_type = __timer_queue; explicit __timer_queue(execution_context& __ctx) : __timer_queue_base(__ctx) { } void shutdown() noexcept { } io_context& context() noexcept { return static_cast<io_context&>(service::context()); } // Start an asynchronous wait. void push(const _Timer& __t, function<void(error_code)> __h) { context().get_executor().on_work_started(); lock_guard<execution_context::mutex_type> __lock(_M_qmtx); _M_queue.emplace(__t, _M_next_id++, std::move(__h)); // no need to notify reactor unless this timer went to the front? } // Cancel all outstanding waits for __t size_t cancel(const _Timer& __t) { lock_guard<execution_context::mutex_type> __lock(_M_qmtx); size_t __count = 0; auto __last = _M_queue.end(); for (auto __it = _M_queue.begin(), __end = __last; __it != __end; ++__it) { if (__it->_M_key == __t._M_key.get()) { __it->cancel(); __last = __it; ++__count; } } if (__count) _M_queue._M_sort_to(__last); return __count; } // Cancel oldest outstanding wait for __t bool cancel_one(const _Timer& __t) { lock_guard<execution_context::mutex_type> __lock(_M_qmtx); const auto __end = _M_queue.end(); auto __oldest = __end; for (auto __it = _M_queue.begin(); __it != __end; ++__it) if (__it->_M_key == __t._M_key.get()) if (__oldest == __end \|\| __it->_M_id < __oldest->_M_id) __oldest = __it; if (__oldest == __end) return false; __oldest->cancel(); _M_queue._M_sort_to(__oldest); return true; } chrono::milliseconds _M_next() const override { typename _Timer::time_point __exp; { lock_guard<execution_context::mutex_type> __lock(_M_qmtx); if (_M_queue.empty()) return chrono::milliseconds::max(); // no pending timers if (_M_queue.top()._M_key == nullptr) return chrono::milliseconds::zero(); // cancelled, run now __exp = _M_queue.top()._M_expiry; } auto __dur = _Timer::traits_type::to_wait_duration(__exp); if (__dur < __dur.zero()) __dur = __dur.zero(); return chrono::duration_cast<chrono::milliseconds>(__dur); } private: bool run_one() override { auto __now = _Timer::clock_type::now(); function<void(error_code)> __h; error_code __ec; { lock_guard<execution_context::mutex_type> __lock(_M_qmtx); if (_M_queue.top()._M_key == nullptr) // cancelled { __h = std::move(_M_queue.top()._M_h); __ec = std::make_error_code(errc::operation_canceled); _M_queue.pop(); } else if (_M_queue.top()._M_expiry <= _Timer::clock_type::now()) { __h = std::move(_M_queue.top()._M_h); _M_queue.pop(); } } if (__h) { __h(__ec); context().get_executor().on_work_finished(); return true; } return false; } using __timer_id_type = uint64_t; struct __pending_timer { __pending_timer(const _Timer& __t, uint64_t __id, function<void(error_code)> __h) : _M_expiry(__t.expiry()), _M_key(__t._M_key.get()), _M_id(__id), _M_h(std::move(__h)) { } typename _Timer::time_point _M_expiry; _Key _M_key; __timer_id_type _M_id; function<void(error_code)> _M_h; void cancel() { _M_expiry = _M_expiry.min(); _M_key = nullptr; } bool operator<(const __pending_timer& __rhs) const { return _M_expiry < __rhs._M_expiry; } }; struct __queue : priority_queue<__pending_timer> { using iterator = typename priority_queue<__pending_timer>::container_type::iterator; // expose begin/end/erase for direct access to underlying container iterator begin() { return this->c.begin(); } iterator end() { return this->c.end(); } iterator erase(iterator __it) { return this->c.erase(__it); } void _M_sort_to(iterator __it) { std::stable_sort(this->c.begin(), ++__it); } }; __queue _M_queue; __timer_id_type _M_next_id = 0; }; template<typename _Timer, typename _CompletionHandler> void async_wait(const _Timer& __timer, _CompletionHandler&& __h) { auto& __queue = use_service<__timer_queue<_Timer>>(this); __queue.push(__timer, std::move(__h)); _M_reactor._M_notify(); } // Cancel all wait operations initiated by __timer. template<typename _Timer> size_t cancel(const _Timer& __timer) { if (!has_service<__timer_queue<_Timer>>(this)) return 0; auto __c = use_service<__timer_queue<_Timer>>(this).cancel(__timer); if (__c != 0) _M_reactor._M_notify(); return __c; } // Cancel the oldest wait operation initiated by __timer. template<typename _Timer> size_t cancel_one(const _Timer& __timer) { if (!has_service<__timer_queue<_Timer>>(this)) return 0; if (use_service<__timer_queue<_Timer>>(this).cancel_one(__timer)) { _M_reactor._M_notify(); return 1; } return 0; } // The caller must know what the wait-type __w will be interpreted. // In the current implementation the reactor is based on <poll.h> // so the parameter must be one of POLLIN, POLLOUT or POLLERR. template<typename _Op> void async_wait(int __fd, int __w, _Op&& __op) { lock_guard<execution_context::mutex_type> __lock(_M_mtx); // TODO need push_back, use std::list not std::forward_list auto __tail = _M_ops.before_begin(), __it = _M_ops.begin(); while (__it != _M_ops.end()) { ++__it; ++__tail; } using __type = __async_operation_impl<_Op>; _M_ops.emplace_after(__tail, make_unique<__type>(std::move(__op), __fd, __w)); _M_reactor._M_fd_interest(__fd, __w); } void _M_add_fd(int __fd) { _M_reactor._M_add_fd(__fd); } void _M_remove_fd(int __fd) { _M_reactor._M_remove_fd(__fd); } void cancel(int __fd, error_code&) { lock_guard<execution_context::mutex_type> __lock(_M_mtx); const auto __end = _M_ops.end(); auto __it = _M_ops.begin(); auto __prev = _M_ops.before_begin(); while (__it != __end && (__it)->_M_is_cancelled()) { ++__it; ++__prev; } auto __cancelled = __prev; while (__it != __end) { if ((__it)->_M_fd == __fd) { (__it)->cancel(); ++__it; _M_ops.splice_after(__cancelled, _M_ops, __prev); ++__cancelled; } else { ++__it; ++__prev; } } _M_reactor._M_not_interested(__fd); } struct __async_operation { __async_operation(int __fd, int __ev) : _M_fd(__fd), _M_ev(__ev) { } virtual ~__async_operation() = default; int _M_fd; short _M_ev; void cancel() { _M_fd = -1; } bool _M_is_cancelled() const { return _M_fd == -1; } virtual void run(io_context&) = 0; }; template<typename _Op> struct __async_operation_impl : __async_operation { __async_operation_impl(_Op&& __op, int __fd, int __ev) : __async_operation{__fd, __ev}, _M_op(std::move(__op)) { } _Op _M_op; void run(io_context& __ctx) { if (_M_is_cancelled()) _M_op(std::make_error_code(errc::operation_canceled)); else _M_op(error_code{}); } }; atomic<count_type> _M_work_count; mutable execution_context::mutex_type _M_mtx; queue<function<void()>> _M_op; bool _M_stopped = false; struct __monitor { __monitor(io_context& __c) : _M_ctx(__c) { #ifdef _GLIBCXX_HAS_GTHREADS lock_guard<execution_context::mutex_type> __lock(_M_ctx._M_mtx); _M_ctx._M_call_stack.push_back(this_thread::get_id()); #else _M_ctx._M_run_count++; #endif } ~__monitor() { #ifdef _GLIBCXX_HAS_GTHREADS lock_guard<execution_context::mutex_type> __lock(_M_ctx._M_mtx); _M_ctx._M_call_stack.pop_back(); #else _M_ctx._M_run_count--; #endif if (_M_ctx._M_outstanding_work() == 0) { _M_ctx._M_stopped = true; _M_ctx._M_reactor._M_notify(); } } __monitor(__monitor&&) = delete; io_context& _M_ctx; }; bool _M_do_one(chrono::milliseconds __timeout) { const bool __block = __timeout != chrono::milliseconds::zero(); __reactor::__fdvec __fds; __monitor __mon{this}; __timer_queue_base __timerq = nullptr; unique_ptr<__async_operation> __async_op; while (true) { if (__timerq) { if (__timerq->run_one()) return true; else __timerq = nullptr; } if (__async_op) { __async_op->run(this); // TODO need to unregister __async_op return true; } chrono::milliseconds __ms{0}; { lock_guard<execution_context::mutex_type> __lock(_M_mtx); if (_M_stopped) return false; // find first timer with something to do for (auto __q : _M_timers) { auto __next = __q->_M_next(); if (__next == __next.zero()) // ready to run immediately { __timerq = __q; __ms = __next; break; } else if (__next != __next.max() && __block && (__next < __ms \|\| __timerq == nullptr)) { __timerq = __q; __ms = __next; } } if (__timerq && __ms == __ms.zero()) continue; // restart loop to run a timer immediately if (!_M_ops.empty() && _M_ops.front()->_M_is_cancelled()) { _M_ops.front().swap(__async_op); _M_ops.pop_front(); continue; } // TODO run any posted items if (__block) { if (__timerq == nullptr) __ms = __timeout; else if (__ms.zero() <= __timeout && __timeout < __ms) __ms = __timeout; else if (__ms.count() > numeric_limits<int>::max()) __ms = chrono::milliseconds{numeric_limits<int>::max()}; } // else __ms == 0 and poll() will return immediately } auto __res = _M_reactor.wait(__fds, __ms); if (__res == __reactor::_S_retry) continue; if (__res == __reactor::_S_timeout) { if (__timerq == nullptr) return false; else continue; // timed out, so restart loop and process the timer } __timerq = nullptr; if (__fds.empty()) // nothing to do return false; lock_guard<execution_context::mutex_type> __lock(_M_mtx); for (auto __it = _M_ops.begin(), __end = _M_ops.end(), __prev = _M_ops.before_begin(); __it != __end; ++__it, ++__prev) { auto& __op = __it; auto __pos = std::lower_bound(__fds.begin(), __fds.end(), __op._M_fd, [](const auto& __p, int __fd) { return __p.fd < __fd; }); if (__pos != __fds.end() && __pos->fd == __op._M_fd && __pos->revents & __op._M_ev) { __it->swap(__async_op); _M_ops.erase_after(__prev); break; // restart loop and run op } } } } struct __reactor { #ifdef _GLIBCXX_HAVE_POLL_H __reactor() : _M_fds(1) { int __pipe[2]; if (::pipe(__pipe) == -1) __throw_system_error(errno); if (::fcntl(__pipe[0], F_SETFL, O_NONBLOCK) == -1 \|\| ::fcntl(__pipe[1], F_SETFL, O_NONBLOCK) == -1) { int __e = errno; ::close(__pipe[0]); ::close(__pipe[1]); __throw_system_error(__e); } _M_fds.back().events = POLLIN; _M_fds.back().fd = __pipe[0]; _M_notify_wr = __pipe[1]; } ~__reactor() { ::close(_M_fds.back().fd); ::close(_M_notify_wr); } #endif // write a notification byte to the pipe (ignoring errors) void _M_notify() { int __n; do { __n = ::write(_M_notify_wr, "", 1); } while (__n == -1 && errno == EINTR); } // read all notification bytes from the pipe void _M_on_notify() { // Drain the pipe. char __buf[64]; ssize_t __n; do { __n = ::read(_M_fds.back().fd, __buf, sizeof(__buf)); } while (__n != -1 \|\| errno == EINTR); } void _M_add_fd(int __fd) { auto __pos = _M_lower_bound(__fd); if (__pos->fd == __fd) __throw_system_error((int)errc::invalid_argument); _M_fds.insert(__pos, __fdvec::value_type{})->fd = __fd; _M_notify(); } void _M_remove_fd(int __fd) { auto __pos = _M_lower_bound(__fd); if (__pos->fd == __fd) _M_fds.erase(__pos); // else bug! _M_notify(); } void _M_fd_interest(int __fd, int __w) { auto __pos = _M_lower_bound(__fd); if (__pos->fd == __fd) __pos->events \|= __w; // else bug! _M_notify(); } void _M_not_interested(int __fd) { auto __pos = _M_lower_bound(__fd); if (__pos->fd == __fd) __pos->events = 0; _M_notify(); } #ifdef _GLIBCXX_HAVE_POLL_H using __fdvec = vector<::pollfd>; #else struct dummy_pollfd { int fd = -1; short events = 0, revents = 0; }; using __fdvec = vector<dummy_pollfd>; #endif // Find first element p such that !(p.fd < __fd) // N.B. always returns a dereferencable iterator. __fdvec::iterator _M_lower_bound(int __fd) { return std::lower_bound(_M_fds.begin(), _M_fds.end() - 1, __fd, [](const auto& __p, int __fd) { return __p.fd < __fd; }); } enum __status { _S_retry, _S_timeout, _S_ok, _S_error }; __status wait(__fdvec& __fds, chrono::milliseconds __timeout) { #ifdef _GLIBCXX_HAVE_POLL_H // XXX not thread-safe! __fds = _M_fds; // take snapshot to pass to poll() int __res = ::poll(__fds.data(), __fds.size(), __timeout.count()); if (__res == -1) { __fds.clear(); if (errno == EINTR) return _S_retry; return _S_error; // XXX ??? } else if (__res == 0) { __fds.clear(); return _S_timeout; } else if (__fds.back().revents != 0) // something changed, restart { __fds.clear(); _M_on_notify(); return _S_retry; } auto __part = std::stable_partition(__fds.begin(), __fds.end() - 1, [](const __fdvec::value_type& __p) { return __p.revents != 0; }); __fds.erase(__part, __fds.end()); return _S_ok; #else (void) __timeout; __fds.clear(); return _S_error; #endif } __fdvec _M_fds; // _M_fds.back() is the read end of the self-pipe int _M_notify_wr; // write end of the self-pipe }; __reactor _M_reactor; vector<__timer_queue_base> _M_timers; forward_list<unique_ptr<__async_operation>> _M_ops; #ifdef _GLIBCXX_HAS_GTHREADS vector<thread::id> _M_call_stack; #else int _M_run_count = 0; #endif }; inline bool operator==(const io_context::executor_type& __a, const io_context::executor_type& __b) noexcept { // https://github.com/chriskohlhoff/asio-tr2/issues/201 using executor_type = io_context::executor_type; return std::addressof(executor_type(__a).context()) == std::addressof(executor_type(__b).context()); } inline bool operator!=(const io_context::executor_type& __a, const io_context::executor_type& __b) noexcept { return !(__a == __b); } template<> struct is_executor<io_context::executor_type> : true_type {}; /// @} } // namespace v1 } // namespace net } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_IO_SERVICE	22 KB	2025-09-15 15:41
📄 iterator // <experimental/iterator> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/iterator * This is a TS C++ Library header. * @ingroup libfund-ts / // // N4336 Working Draft, C++ Extensions for Library Fundamentals, Version 2 // #ifndef _GLIBCXX_EXPERIMENTAL_ITERATOR #define _GLIBCXX_EXPERIMENTAL_ITERATOR 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <iterator> #include <iosfwd> #include <experimental/type_traits> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_ostream_joiner 201411 /// Output iterator that inserts a delimiter between elements. template<typename _DelimT, typename _CharT = char, typename _Traits = char_traits<_CharT>> class ostream_joiner { public: typedef _CharT char_type; typedef _Traits traits_type; typedef basic_ostream<_CharT, _Traits> ostream_type; typedef output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; ostream_joiner(ostream_type& __os, const _DelimT& __delimiter) noexcept(is_nothrow_copy_constructible_v<_DelimT>) : _M_out(std::__addressof(__os)), _M_delim(__delimiter) { } ostream_joiner(ostream_type& __os, _DelimT&& __delimiter) noexcept(is_nothrow_move_constructible_v<_DelimT>) : _M_out(std::__addressof(__os)), _M_delim(std::move(__delimiter)) { } template<typename _Tp> ostream_joiner& operator=(const _Tp& __value) { if (!_M_first) _M_out << _M_delim; _M_first = false; _M_out << __value; return this; } ostream_joiner& operator() noexcept { return this; } ostream_joiner& operator++() noexcept { return this; } ostream_joiner& operator++(int) noexcept { return this; } private: ostream_type* _M_out; _DelimT _M_delim; bool _M_first = true; }; /// Object generator for ostream_joiner. template<typename _CharT, typename _Traits, typename _DelimT> inline ostream_joiner<decay_t<_DelimT>, _CharT, _Traits> make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _DelimT&& __delimiter) { return { __os, std::forward<_DelimT>(__delimiter) }; } } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_ITERATOR	3.45 KB	2025-09-15 15:41
📄 list // <experimental/list> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/list * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_LIST #define _GLIBCXX_EXPERIMENTAL_LIST 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <list> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Tp, typename _Alloc, typename _Predicate> inline void erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred) { __cont.remove_if(__pred); } template<typename _Tp, typename _Alloc, typename _Up> inline void erase(list<_Tp, _Alloc>& __cont, const _Up& __value) { using __elem_type = typename list<_Tp, _Alloc>::value_type; experimental::erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; }); } namespace pmr { template<typename _Tp> using list = std::list<_Tp, polymorphic_allocator<_Tp>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_LIST	2.21 KB	2025-09-15 15:41
📄 map // <experimental/map> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/map * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_MAP #define _GLIBCXX_EXPERIMENTAL_MAP 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <map> #include <bits/erase_if.h> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Key, typename _Tp, typename _Compare, typename _Alloc, typename _Predicate> inline void erase_if(map<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } template<typename _Key, typename _Tp, typename _Compare, typename _Alloc, typename _Predicate> inline void erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } namespace pmr { template<typename _Key, typename _Tp, typename _Compare = less<_Key>> using map = std::map<_Key, _Tp, _Compare, polymorphic_allocator<pair<const _Key, _Tp>>>; template<typename _Key, typename _Tp, typename _Compare = less<_Key>> using multimap = std::multimap<_Key, _Tp, _Compare, polymorphic_allocator<pair<const _Key, _Tp>>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_MAP	2.53 KB	2025-09-15 15:41
📄 memory // <experimental/memory> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/memory * This is a TS C++ Library header. * @ingroup libfund-ts / // // N4336 Working Draft, C++ Extensions for Library Fundamentals, Version 2 // #ifndef _GLIBCXX_EXPERIMENTAL_MEMORY #define _GLIBCXX_EXPERIMENTAL_MEMORY 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <memory> #include <type_traits> #include <utility> #include <experimental/bits/shared_ptr.h> #include <bits/functional_hash.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_observer_ptr 201411 template <typename _Tp> class observer_ptr { public: // publish our template parameter and variations thereof using element_type = _Tp; using __pointer = add_pointer_t<_Tp>; // exposition-only using __reference = add_lvalue_reference_t<_Tp>; // exposition-only // 3.2.2, observer_ptr constructors // default c'tor constexpr observer_ptr() noexcept : __t() { } // pointer-accepting c'tors constexpr observer_ptr(nullptr_t) noexcept : __t() { } constexpr explicit observer_ptr(__pointer __p) noexcept : __t(__p) { } // copying c'tors (in addition to compiler-generated copy c'tor) template <typename _Up, typename = typename enable_if< is_convertible<typename add_pointer<_Up>::type, __pointer >::value >::type> constexpr observer_ptr(observer_ptr<_Up> __p) noexcept : __t(__p.get()) { } // 3.2.3, observer_ptr observers constexpr __pointer get() const noexcept { return __t; } constexpr __reference operator() const { return get(); } constexpr __pointer operator->() const noexcept { return get(); } constexpr explicit operator bool() const noexcept { return get() != nullptr; } // 3.2.4, observer_ptr conversions constexpr explicit operator __pointer() const noexcept { return get(); } // 3.2.5, observer_ptr modifiers constexpr __pointer release() noexcept { __pointer __tmp = get(); reset(); return __tmp; } constexpr void reset(__pointer __p = nullptr) noexcept { __t = __p; } constexpr void swap(observer_ptr& __p) noexcept { std::swap(__t, __p.__t); } private: __pointer __t; }; // observer_ptr<> template<typename _Tp> void swap(observer_ptr<_Tp>& __p1, observer_ptr<_Tp>& __p2) noexcept { __p1.swap(__p2); } template<typename _Tp> observer_ptr<_Tp> make_observer(_Tp __p) noexcept { return observer_ptr<_Tp>(__p); } template<typename _Tp, typename _Up> bool operator==(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return __p1.get() == __p2.get(); } template<typename _Tp, typename _Up> bool operator!=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return !(__p1 == __p2); } template<typename _Tp> bool operator==(observer_ptr<_Tp> __p, nullptr_t) noexcept { return !__p; } template<typename _Tp> bool operator==(nullptr_t, observer_ptr<_Tp> __p) noexcept { return !__p; } template<typename _Tp> bool operator!=(observer_ptr<_Tp> __p, nullptr_t) noexcept { return bool(__p); } template<typename _Tp> bool operator!=(nullptr_t, observer_ptr<_Tp> __p) noexcept { return bool(__p); } template<typename _Tp, typename _Up> bool operator<(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return std::less<typename common_type<typename add_pointer<_Tp>::type, typename add_pointer<_Up>::type >::type >{}(__p1.get(), __p2.get()); } template<typename _Tp, typename _Up> bool operator>(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return __p2 < __p1; } template<typename _Tp, typename _Up> bool operator<=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return !(__p2 < __p1); } template<typename _Tp, typename _Up> bool operator>=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2) { return !(__p1 < __p2); } } // namespace fundamentals_v2 } // namespace experimental template <typename _Tp> struct hash<experimental::observer_ptr<_Tp>> { using result_type = size_t; using argument_type = experimental::observer_ptr<_Tp>; size_t operator()(const experimental::observer_ptr<_Tp>& __t) const noexcept(noexcept(hash<typename add_pointer<_Tp>::type> {}(__t.get()))) { return hash<typename add_pointer<_Tp>::type> {}(__t.get()); } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_MEMORY	5.91 KB	2025-09-15 15:41
📄 memory_resource // <experimental/memory_resource> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/memory_resource * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE #define _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <memory> // align, uses_allocator, __uses_alloc #include <experimental/utility> // pair, experimental::erased_type #include <tuple> // tuple, forward_as_tuple #include <atomic> // atomic #include <new> // placement new #include <cstddef> // max_align_t #include <ext/new_allocator.h> #include <debug/assertions.h> /// @cond namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp> class malloc_allocator; _GLIBCXX_END_NAMESPACE_VERSION } // namespace __gnu_cxx /// @endcond namespace std { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { namespace pmr { #define __cpp_lib_experimental_memory_resources 201402L // Standard memory resources // 8.5 Class memory_resource class memory_resource; // 8.6 Class template polymorphic_allocator template<typename _Tp> class polymorphic_allocator; template<typename _Alloc, typename _Resource = memory_resource> class __resource_adaptor_imp; // 8.7 Alias template resource_adaptor template<typename _Alloc> using resource_adaptor = __resource_adaptor_imp< typename allocator_traits<_Alloc>::template rebind_alloc<char>>; // 8.8 Global memory resources memory_resource new_delete_resource() noexcept; memory_resource* null_memory_resource() noexcept; memory_resource* get_default_resource() noexcept; memory_resource* set_default_resource(memory_resource* __r) noexcept; // TODO 8.9 Pool resource classes class memory_resource { static constexpr size_t _S_max_align = alignof(max_align_t); public: memory_resource() = default; memory_resource(const memory_resource&) = default; virtual ~memory_resource() = default; memory_resource& operator=(const memory_resource&) = default; _GLIBCXX_NODISCARD void* allocate(size_t __bytes, size_t __alignment = _S_max_align) { return do_allocate(__bytes, __alignment); } void deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) { return do_deallocate(__p, __bytes, __alignment); } bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); } protected: virtual void* do_allocate(size_t __bytes, size_t __alignment) = 0; virtual void do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; virtual bool do_is_equal(const memory_resource& __other) const noexcept = 0; }; inline bool operator==(const memory_resource& __a, const memory_resource& __b) noexcept { return &__a == &__b \|\| __a.is_equal(__b); } inline bool operator!=(const memory_resource& __a, const memory_resource& __b) noexcept { return !(__a == __b); } template<typename _Tp> class polymorphic_allocator { public: using value_type = _Tp; polymorphic_allocator() noexcept : _M_resource(get_default_resource()) { } polymorphic_allocator(memory_resource* __r) : _M_resource(__r) { _GLIBCXX_DEBUG_ASSERT(__r); } polymorphic_allocator(const polymorphic_allocator& __other) = default; template <typename _Up> polymorphic_allocator(const polymorphic_allocator<_Up>& __other) noexcept : _M_resource(__other.resource()) { } polymorphic_allocator& operator=(const polymorphic_allocator& __rhs) = default; _GLIBCXX_NODISCARD _Tp* allocate(size_t __n) { return static_cast<_Tp>(_M_resource->allocate(__n sizeof(_Tp), alignof(_Tp))); } void deallocate(_Tp* __p, size_t __n) { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } template <typename _Tp1, typename... _Args> //used here void construct(_Tp1* __p, _Args&&... __args) { std::__uses_allocator_construct(this->resource(), __p, std::forward<_Args>(__args)...); } // Specializations for pair using piecewise construction template <typename _Tp1, typename _Tp2, typename... _Args1, typename... _Args2> void construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, tuple<_Args1...> __x, tuple<_Args2...> __y) { memory_resource* const __resource = this->resource(); auto __x_use_tag = std::__use_alloc<_Tp1, memory_resource, _Args1...>(__resource); auto __y_use_tag = std::__use_alloc<_Tp2, memory_resource, _Args2...>(__resource); ::new(__p) std::pair<_Tp1, _Tp2>(piecewise_construct, _M_construct_p(__x_use_tag, __x), _M_construct_p(__y_use_tag, __y)); } template <typename _Tp1, typename _Tp2> void construct(pair<_Tp1,_Tp2>* __p) { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp> void construct(pair<_Tp1,_Tp2>* __p, _Up&& __x, _Vp&& __y) { this->construct(__p, piecewise_construct, std::forward_as_tuple(std::forward<_Up>(__x)), std::forward_as_tuple(std::forward<_Vp>(__y))); } template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp> void construct(pair<_Tp1,_Tp2>* __p, const std::pair<_Up, _Vp>& __pr) { this->construct(__p, piecewise_construct, std::forward_as_tuple(__pr.first), std::forward_as_tuple(__pr.second)); } template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp> void construct(pair<_Tp1,_Tp2>* __p, pair<_Up, _Vp>&& __pr) { this->construct(__p, piecewise_construct, std::forward_as_tuple(std::forward<_Up>(__pr.first)), std::forward_as_tuple(std::forward<_Vp>(__pr.second))); } template <typename _Up> void destroy(_Up* __p) { __p->~_Up(); } // Return a default-constructed allocator (no allocator propagation) polymorphic_allocator select_on_container_copy_construction() const { return polymorphic_allocator(); } memory_resource* resource() const { return _M_resource; } private: using __uses_alloc1_ = __uses_alloc1<memory_resource>; using __uses_alloc2_ = __uses_alloc2<memory_resource>; template<typename _Tuple> _Tuple&& _M_construct_p(__uses_alloc0, _Tuple& __t) { return std::move(__t); } template<typename... _Args> decltype(auto) _M_construct_p(__uses_alloc1_ __ua, tuple<_Args...>& __t) { return tuple_cat(make_tuple(allocator_arg, (__ua._M_a)), std::move(__t)); } template<typename... _Args> decltype(auto) _M_construct_p(__uses_alloc2_ __ua, tuple<_Args...>& __t) { return tuple_cat(std::move(__t), make_tuple((__ua._M_a))); } memory_resource* _M_resource; }; template <class _Tp1, class _Tp2> bool operator==(const polymorphic_allocator<_Tp1>& __a, const polymorphic_allocator<_Tp2>& __b) noexcept { return __a.resource() == __b.resource(); } template <class _Tp1, class _Tp2> bool operator!=(const polymorphic_allocator<_Tp1>& __a, const polymorphic_allocator<_Tp2>& __b) noexcept { return !(__a == __b); } /// @cond undocumented class __resource_adaptor_common { template<typename, typename> friend class __resource_adaptor_imp; struct _AlignMgr { _AlignMgr(size_t __nbytes, size_t __align) : _M_nbytes(__nbytes), _M_align(__align) { } // Total size that needs to be allocated. size_t _M_alloc_size() const { return _M_buf_size() + _M_token_size(); } void* _M_adjust(void* __ptr) const { const auto __orig_ptr = static_cast<char>(__ptr); size_t __space = _M_buf_size(); // Align the pointer within the buffer: std::align(_M_align, _M_nbytes, __ptr, __space); const auto __aligned_ptr = static_cast<char>(__ptr); const auto __token_size = _M_token_size(); // Store token immediately after the aligned block: char* const __end = __aligned_ptr + _M_nbytes; if (__token_size == 1) _S_write<unsigned char>(__end, __aligned_ptr - __orig_ptr); else if (__token_size == sizeof(short)) _S_write<unsigned short>(__end, __aligned_ptr - __orig_ptr); else if (__token_size == sizeof(int) && sizeof(int) < sizeof(char)) _S_write<unsigned int>(__end, __aligned_ptr - __orig_ptr); else // (__token_size == sizeof(char)) // Just store the original pointer: _S_write<char>(__end, __orig_ptr); return __aligned_ptr; } char _M_unadjust(char* __ptr) const { const char* const __end = __ptr + _M_nbytes; char* __orig_ptr; const auto __token_size = _M_token_size(); // Read the token and restore the original pointer: if (__token_size == 1) __orig_ptr = __ptr - _S_read<unsigned char>(__end); else if (__token_size == sizeof(short)) __orig_ptr = __ptr - _S_read<unsigned short>(__end); else if (__token_size == sizeof(int) && sizeof(int) < sizeof(char)) __orig_ptr = __ptr - _S_read<unsigned int>(__end); else // (__token_size == sizeof(char)) __orig_ptr = _S_read<char>(__end); // The adjustment is always less than the requested alignment, // so if that isn't true now then either the wrong size was passed // to deallocate or the token was overwritten by a buffer overflow: __glibcxx_assert(static_cast<size_t>(__ptr - __orig_ptr) < _M_align); return __orig_ptr; } private: size_t _M_nbytes; size_t _M_align; // Number of bytes needed to fit block of given size and alignment. size_t _M_buf_size() const { return _M_nbytes + _M_align - 1; } // Number of additional bytes needed to write the token. int _M_token_size() const { if (_M_align <= (1ul << __CHAR_BIT__)) return 1; if (_M_align <= (1ul << (sizeof(short) __CHAR_BIT__))) return sizeof(short); if (_M_align <= (1ull << (sizeof(int) * __CHAR_BIT__))) return sizeof(int); return sizeof(char); } template<typename _Tp> static void _S_write(void __to, _Tp __val) { __builtin_memcpy(__to, &__val, sizeof(_Tp)); } template<typename _Tp> static _Tp _S_read(const void* __from) { _Tp __val; __builtin_memcpy(&__val, __from, sizeof(_Tp)); return __val; } }; }; /// @endcond // 8.7.1 __resource_adaptor_imp template<typename _Alloc, typename _Resource> class __resource_adaptor_imp : public _Resource, private __resource_adaptor_common { using memory_resource = _Resource; static_assert(is_same<char, typename allocator_traits<_Alloc>::value_type>::value, "Allocator's value_type is char"); static_assert(is_same<char, typename allocator_traits<_Alloc>::pointer>::value, "Allocator's pointer type is value_type"); static_assert(is_same<const char, typename allocator_traits<_Alloc>::const_pointer>::value, "Allocator's const_pointer type is value_type const"); static_assert(is_same<void, typename allocator_traits<_Alloc>::void_pointer>::value, "Allocator's void_pointer type is void"); static_assert(is_same<const void, typename allocator_traits<_Alloc>::const_void_pointer>::value, "Allocator's const_void_pointer type is void const"); public: using allocator_type = _Alloc; __resource_adaptor_imp() = default; __resource_adaptor_imp(const __resource_adaptor_imp&) = default; __resource_adaptor_imp(__resource_adaptor_imp&&) = default; explicit __resource_adaptor_imp(const _Alloc& __a2) : _M_alloc(__a2) { } explicit __resource_adaptor_imp(_Alloc&& __a2) : _M_alloc(std::move(__a2)) { } __resource_adaptor_imp& operator=(const __resource_adaptor_imp&) = default; allocator_type get_allocator() const noexcept { return _M_alloc; } protected: virtual void* do_allocate(size_t __bytes, size_t __alignment) override { // Cannot use max_align_t on 32-bit Solaris x86, see PR libstdc++/77691 #if ! ((defined __sun__ \|\| defined __VXWORKS__) && defined __i386__) if (__alignment == alignof(max_align_t)) return _M_allocate<alignof(max_align_t)>(__bytes); #endif switch (__alignment) { case 1: return _M_alloc.allocate(__bytes); case 2: return _M_allocate<2>(__bytes); case 4: return _M_allocate<4>(__bytes); case 8: return _M_allocate<8>(__bytes); } const _AlignMgr __mgr(__bytes, __alignment); // Assume _M_alloc returns 1-byte aligned memory, so allocate enough // space to fit a block of the right size and alignment, plus some // extra bytes to store a token for retrieving the original pointer. return __mgr._M_adjust(_M_alloc.allocate(__mgr._M_alloc_size())); } virtual void do_deallocate(void* __ptr, size_t __bytes, size_t __alignment) noexcept override { #if ! ((defined __sun__ \|\| defined __VXWORKS__) && defined __i386__) if (__alignment == alignof(max_align_t)) return (void) _M_deallocate<alignof(max_align_t)>(__ptr, __bytes); #endif switch (__alignment) { case 1: return (void) _M_alloc.deallocate((char)__ptr, __bytes); case 2: return (void) _M_deallocate<2>(__ptr, __bytes); case 4: return (void) _M_deallocate<4>(__ptr, __bytes); case 8: return (void) _M_deallocate<8>(__ptr, __bytes); } const _AlignMgr __mgr(__bytes, __alignment); // Use the stored token to retrieve the original pointer. _M_alloc.deallocate(__mgr._M_unadjust((char)__ptr), __mgr._M_alloc_size()); } virtual bool do_is_equal(const memory_resource& __other) const noexcept override { if (auto __p = dynamic_cast<const __resource_adaptor_imp>(&__other)) return _M_alloc == __p->_M_alloc; return false; } private: template<size_t _Num> struct _Aligned_type { alignas(_Num) char __c[_Num]; }; // Rebind the allocator to the specified type and use it to allocate. template<size_t _Num, typename _Tp = _Aligned_type<_Num>> void _M_allocate(size_t __bytes) { typename allocator_traits<_Alloc>::template rebind_alloc<_Tp> __a2(_M_alloc); const size_t __n = (__bytes + _Num - 1) / _Num; return __a2.allocate(__n); } // Rebind the allocator to the specified type and use it to deallocate. template<size_t _Num, typename _Tp = _Aligned_type<_Num>> void _M_deallocate(void* __ptr, size_t __bytes) noexcept { typename allocator_traits<_Alloc>::template rebind_alloc<_Tp> __a2(_M_alloc); const size_t __n = (__bytes + _Num - 1) / _Num; __a2.deallocate((_Tp)__ptr, __n); } _Alloc _M_alloc{}; }; // Global memory resources inline memory_resource new_delete_resource() noexcept { using type = resource_adaptor<__gnu_cxx::new_allocator<char>>; alignas(type) static unsigned char __buf[sizeof(type)]; static type* __r = new(__buf) type; return __r; } inline memory_resource* null_memory_resource() noexcept { class type final : public memory_resource { void* do_allocate(size_t, size_t) override { std::__throw_bad_alloc(); } void do_deallocate(void, size_t, size_t) noexcept override { } bool do_is_equal(const memory_resource& __other) const noexcept override { return this == &__other; } }; alignas(type) static unsigned char __buf[sizeof(type)]; static type __r = new(__buf) type; return __r; } // The default memory resource /// @cond undocumented inline std::atomic<memory_resource>& __get_default_resource() { using type = atomic<memory_resource>; alignas(type) static unsigned char __buf[sizeof(type)]; static type* __r = new(__buf) type(new_delete_resource()); return __r; } /// @endcond /// Get the current default resource. inline memory_resource get_default_resource() noexcept { return __get_default_resource().load(); } /// Change the default resource and return the previous one. inline memory_resource* set_default_resource(memory_resource* __r) noexcept { if (__r == nullptr) __r = new_delete_resource(); return __get_default_resource().exchange(__r); } } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE	17.12 KB	2025-09-15 15:41
📄 net // <experimental/net> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/net * This is a TS C++ Library header. * @ingroup networking-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_NET #define _GLIBCXX_EXPERIMENTAL_NET #pragma GCC system_header #if __cplusplus >= 201402L #include <experimental/executor> #include <experimental/io_context> #include <experimental/timer> #include <experimental/buffer> #include <experimental/socket> #include <experimental/internet> #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_NET	1.51 KB	2025-09-15 15:41
📄 netfwd // <experimental/netfwd> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/netfwd * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_NETFWD #define _GLIBCXX_EXPERIMENTAL_NETFWD 1 #pragma GCC system_header #if __cplusplus >= 201402L // #define __cpp_lib_experimental_net 201803 // #define __cpp_lib_experimental_net_extensible 201803 #include <chrono> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @defgroup networking-ts Networking TS * @ingroup experimental * * ISO/IEC TS 19216:2018 C++ Extensions for Networking * @{ / class execution_context; template<typename _Tp, typename _Executor> class executor_binder; template<typename _Executor> class executor_work_guard; class system_executor; class executor; template<typename _Executor> class strand; class io_service; template<typename _Clock> struct wait_traits; template<typename _Clock, typename _WaitTraits = wait_traits<_Clock>> class basic_waitable_timer; typedef basic_waitable_timer<chrono::system_clock> system_timer; typedef basic_waitable_timer<chrono::steady_clock> steady_timer; typedef basic_waitable_timer<chrono::high_resolution_clock> high_resolution_timer; template<typename _Protocol> class basic_socket; template<typename _Protocol> class basic_datagram_socket; template<typename _Protocol> class basic_stream_socket; template<typename _Protocol> class basic_socket_acceptor; template<typename _Protocol, typename _Clock = chrono::steady_clock, typename _WaitTraits = wait_traits<_Clock>> class basic_socket_streambuf; template<typename _Protocol, typename _Clock = chrono::steady_clock, typename _WaitTraits = wait_traits<_Clock>> class basic_socket_iostream; /// @} namespace ip { /* * @addtogroup networking-ts * @{ */ class address; class address_v4; class address_v6; class address_iterator_v4; class address_iterator_v6; class address_range_v4; class address_range_v6; class network_v4; class network_v6; template<typename _InternetProtocol> class basic_endpoint; template<typename _InternetProtocol> class basic_resolver_entry; template<typename _InternetProtocol> class basic_resolver_results; template<typename _InternetProtocol> class basic_resolver; class tcp; class udp; /// @} } // namespace ip } // namespace v1 } // namespace net } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_NETFWD	3.66 KB	2025-09-15 15:41
📄 numeric // <experimental/numeric> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/numeric * This is a TS C++ Library header. * @ingroup libfund-ts / // // N4336 Working Draft, C++ Extensions for Library Fundamentals, Version 2 // #ifndef _GLIBCXX_EXPERIMENTAL_NUMERIC #define _GLIBCXX_EXPERIMENTAL_NUMERIC 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <numeric> #include <experimental/type_traits> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_gcd_lcm 201411 /// Greatest common divisor template<typename _Mn, typename _Nn> constexpr common_type_t<_Mn, _Nn> gcd(_Mn __m, _Nn __n) noexcept { static_assert(is_integral_v<_Mn> && is_integral_v<_Nn>, "std::experimental::gcd arguments must be integers"); static_assert(_Mn(2) == 2 && _Nn(2) == 2, "std::experimental::gcd arguments must not be bool"); namespace __detail = std::__detail; using _Ct = common_type_t<_Mn, _Nn>; const _Ct __m2 = __detail::__abs_r<_Ct>(__m); const _Ct __n2 = __detail::__abs_r<_Ct>(__n); return __detail::__gcd<make_unsigned_t<_Ct>>(__m2, __n2); } /// Least common multiple template<typename _Mn, typename _Nn> constexpr common_type_t<_Mn, _Nn> lcm(_Mn __m, _Nn __n) { static_assert(is_integral_v<_Mn> && is_integral_v<_Nn>, "std::experimental::lcm arguments must be integers"); static_assert(_Mn(2) == 2 && _Nn(2) == 2, "std::experimental::lcm arguments must not be bool"); namespace __detail = std::__detail; using _Ct = common_type_t<_Mn, _Nn>; const _Ct __m2 = __detail::__abs_r<_Ct>(__m); const _Ct __n2 = __detail::__abs_r<_Ct>(__n); if (__m2 == 0 \|\| __n2 == 0) return 0; _Ct __r = __m2 / __detail::__gcd<make_unsigned_t<_Ct>>(__m2, __n2); #if defined _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED if _GLIBCXX17_CONSTEXPR (is_signed_v<_Ct>) if (__builtin_is_constant_evaluated()) return __r __n2; // constant evaluation can detect overflow here. #endif bool __overflow = __builtin_mul_overflow(__r, __n2, &__r); __glibcxx_assert(!__overflow); return __r; } } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_NUMERIC	3.4 KB	2025-09-15 15:41
📄 optional // <experimental/optional> -- C++ -- // Copyright (C) 2013-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/optional * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_OPTIONAL #define _GLIBCXX_EXPERIMENTAL_OPTIONAL 1 #if __cplusplus >= 201402L #include <utility> #include <type_traits> #include <stdexcept> #include <new> #include <initializer_list> #include <bits/functexcept.h> #include <bits/functional_hash.h> #include <bits/enable_special_members.h> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { /* * @defgroup optional Optional values * @ingroup libfund-ts * * Class template for optional values and surrounding facilities, as * described in n3793 "A proposal to add a utility class to represent * optional objects (Revision 5)". * * @{ / #define __cpp_lib_experimental_optional 201411 // All subsequent [X.Y.n] references are against n3793. // [X.Y.4] template<typename _Tp> class optional; // [X.Y.5] /// Tag type for in-place construction. struct in_place_t { }; /// Tag for in-place construction. constexpr in_place_t in_place { }; // [X.Y.6] /// Tag type to disengage optional objects. struct nullopt_t { // Do not user-declare default constructor at all for // optional_value = {} syntax to work. // nullopt_t() = delete; // Used for constructing nullopt. enum class _Construct { _Token }; // Must be constexpr for nullopt_t to be literal. explicit constexpr nullopt_t(_Construct) { } }; // [X.Y.6] /// Tag to disengage optional objects. constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; // [X.Y.7] /* * @brief Exception class thrown when a disengaged optional object is * dereferenced. * @ingroup exceptions / class bad_optional_access : public logic_error { public: bad_optional_access() : logic_error("bad optional access") { } // XXX This constructor is non-standard. Should not be inline explicit bad_optional_access(const char __arg) : logic_error(__arg) { } virtual ~bad_optional_access() noexcept = default; }; /// @cond undocumented // XXX Does not belong here. [[noreturn]] inline void __throw_bad_optional_access(const char* __s) { _GLIBCXX_THROW_OR_ABORT(bad_optional_access(__s)); } /** * @brief Class template that holds the necessary state for @ref optional * and that has the responsibility for construction and the special members. * * Such a separate base class template is necessary in order to * conditionally enable the special members (e.g. copy/move constructors). * Note that this means that @ref _Optional_base implements the * functionality for copy and move assignment, but not for converting * assignment. * * @see optional, _Enable_special_members / template<typename _Tp, bool _ShouldProvideDestructor = !is_trivially_destructible<_Tp>::value> class _Optional_base { private: // Remove const to avoid prohibition of reusing object storage for // const-qualified types in [3.8/9]. This is strictly internal // and even optional itself is oblivious to it. using _Stored_type = remove_const_t<_Tp>; public: // [X.Y.4.1] Constructors. // Constructors for disengaged optionals. constexpr _Optional_base() noexcept : _M_empty{} { } constexpr _Optional_base(nullopt_t) noexcept : _Optional_base{} { } // Constructors for engaged optionals. template<typename... _Args> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template<typename _Up, typename... _Args, enable_if_t<is_constructible<_Tp, initializer_list<_Up>&, _Args&&...>::value, int>...> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } // Copy and move constructors. _Optional_base(const _Optional_base& __other) { if (__other._M_engaged) this->_M_construct(__other._M_get()); } _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible<_Tp>()) { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); } // [X.Y.4.3] (partly) Assignment. _Optional_base& operator=(const _Optional_base& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } return this; } _Optional_base& operator=(_Optional_base&& __other) noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>()) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } return this; } // [X.Y.4.2] Destructor. ~_Optional_base() { if (this->_M_engaged) this->_M_payload.~_Stored_type(); } // The following functionality is also needed by optional, hence the // protected accessibility. protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_engaged; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return _M_payload; } constexpr const _Tp& _M_get() const noexcept { return _M_payload; } // The _M_construct operation has !_M_engaged as a precondition // while _M_destruct has _M_engaged as a precondition. template<typename... _Args> void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new (std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } void _M_destruct() { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } // _M_reset is a 'safe' operation with no precondition. void _M_reset() { if (this->_M_engaged) this->_M_destruct(); } private: struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged = false; }; /// Partial specialization that is exactly identical to the primary template /// save for not providing a destructor, to fulfill triviality requirements. template<typename _Tp> class _Optional_base<_Tp, false> { private: using _Stored_type = remove_const_t<_Tp>; public: constexpr _Optional_base() noexcept : _M_empty{} { } constexpr _Optional_base(nullopt_t) noexcept : _Optional_base{} { } template<typename... _Args> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template<typename _Up, typename... _Args, enable_if_t<is_constructible<_Tp, initializer_list<_Up>&, _Args&&...>::value, int>...> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } _Optional_base(const _Optional_base& __other) { if (__other._M_engaged) this->_M_construct(__other._M_get()); } _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible<_Tp>()) { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); } _Optional_base& operator=(const _Optional_base& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } return this; } _Optional_base& operator=(_Optional_base&& __other) noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>()) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } return this; } // Sole difference // ~_Optional_base() noexcept = default; protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_engaged; } _Tp& _M_get() noexcept { return _M_payload; } constexpr const _Tp& _M_get() const noexcept { return _M_payload; } template<typename... _Args> void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new (std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } void _M_destruct() { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } void _M_reset() { if (this->_M_engaged) this->_M_destruct(); } private: struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged = false; }; template<typename _Tp, typename _Up> using __converts_from_optional = __or_<is_constructible<_Tp, const optional<_Up>&>, is_constructible<_Tp, optional<_Up>&>, is_constructible<_Tp, const optional<_Up>&&>, is_constructible<_Tp, optional<_Up>&&>, is_convertible<const optional<_Up>&, _Tp>, is_convertible<optional<_Up>&, _Tp>, is_convertible<const optional<_Up>&&, _Tp>, is_convertible<optional<_Up>&&, _Tp>>; template<typename _Tp, typename _Up> using __assigns_from_optional = __or_<is_assignable<_Tp&, const optional<_Up>&>, is_assignable<_Tp&, optional<_Up>&>, is_assignable<_Tp&, const optional<_Up>&&>, is_assignable<_Tp&, optional<_Up>&&>>; /// @endcond /* * @brief Class template for optional values. / template<typename _Tp> class optional : private _Optional_base<_Tp>, private _Enable_copy_move< // Copy constructor. is_copy_constructible<_Tp>::value, // Copy assignment. __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value, // Move constructor. is_move_constructible<_Tp>::value, // Move assignment. __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value, // Unique tag type. optional<_Tp>> { static_assert(__and_<__not_<is_same<remove_cv_t<_Tp>, nullopt_t>>, __not_<is_same<remove_cv_t<_Tp>, in_place_t>>, __not_<is_reference<_Tp>>>(), "Invalid instantiation of optional<T>"); private: using _Base = _Optional_base<_Tp>; public: using value_type = _Tp; // _Optional_base has the responsibility for construction. using _Base::_Base; constexpr optional() = default; // Converting constructors for engaged optionals. template <typename _Up = _Tp, enable_if_t<__and_< __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp> >::value, bool> = true> constexpr optional(_Up&& __t) : _Base(in_place, std::forward<_Up>(__t)) { } template <typename _Up = _Tp, enable_if_t<__and_< __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up&&>, __not_<is_convertible<_Up&&, _Tp>> >::value, bool> = false> explicit constexpr optional(_Up&& __t) : _Base(in_place, std::forward<_Up>(__t)) { } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, const _Up&>, is_convertible<const _Up&, _Tp>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(const optional<_Up>& __t) { if (__t) emplace(__t); } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, const _Up&>, __not_<is_convertible<const _Up&, _Tp>>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(const optional<_Up>& __t) { if (__t) emplace(__t); } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(__t)); } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up&&>, __not_<is_convertible<_Up&&, _Tp>>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(__t)); } // [X.Y.4.3] (partly) Assignment. optional& operator=(nullopt_t) noexcept { this->_M_reset(); return this; } template<typename _Up = _Tp> enable_if_t<__and_< __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up>, __not_<__and_<is_scalar<_Tp>, is_same<_Tp, decay_t<_Up>>>>, is_assignable<_Tp&, _Up>>::value, optional&> operator=(_Up&& __u) { if (this->_M_is_engaged()) this->_M_get() = std::forward<_Up>(__u); else this->_M_construct(std::forward<_Up>(__u)); return this; } template<typename _Up> enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, const _Up&>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>> >::value, optional&> operator=(const optional<_Up>& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = __u; else this->_M_construct(__u); } else { this->_M_reset(); } return this; } template<typename _Up> enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>> >::value, optional&> operator=(optional<_Up>&& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = std::move(__u); else this->_M_construct(std::move(__u)); } else { this->_M_reset(); } return this; } template<typename... _Args> enable_if_t<is_constructible<_Tp, _Args&&...>::value> emplace(_Args&&... __args) { this->_M_reset(); this->_M_construct(std::forward<_Args>(__args)...); } template<typename _Up, typename... _Args> enable_if_t<is_constructible<_Tp, initializer_list<_Up>&, _Args&&...>::value> emplace(initializer_list<_Up> __il, _Args&&... __args) { this->_M_reset(); this->_M_construct(__il, std::forward<_Args>(__args)...); } // [X.Y.4.2] Destructor is implicit, implemented in _Optional_base. // [X.Y.4.4] Swap. void swap(optional& __other) noexcept(is_nothrow_move_constructible<_Tp>() && __is_nothrow_swappable<_Tp>::value) { using std::swap; if (this->_M_is_engaged() && __other._M_is_engaged()) swap(this->_M_get(), __other._M_get()); else if (this->_M_is_engaged()) { __other._M_construct(std::move(this->_M_get())); this->_M_destruct(); } else if (__other._M_is_engaged()) { this->_M_construct(std::move(__other._M_get())); __other._M_destruct(); } } // [X.Y.4.5] Observers. constexpr const _Tp operator->() const { return std::__addressof(this->_M_get()); } _Tp* operator->() { return std::__addressof(this->_M_get()); } constexpr const _Tp& operator() const& { return this->_M_get(); } constexpr _Tp& operator()& { return this->_M_get(); } constexpr _Tp&& operator()&& { return std::move(this->_M_get()); } constexpr const _Tp&& operator() const&& { return std::move(this->_M_get()); } constexpr explicit operator bool() const noexcept { return this->_M_is_engaged(); } constexpr const _Tp& value() const& { if (this->_M_is_engaged()) return this->_M_get(); __throw_bad_optional_access("Attempt to access value of a " "disengaged optional object"); } constexpr _Tp& value()& { if (this->_M_is_engaged()) return this->_M_get(); __throw_bad_optional_access("Attempt to access value of a " "disengaged optional object"); } constexpr _Tp&& value()&& { if (this->_M_is_engaged()) return std::move(this->_M_get()); __throw_bad_optional_access("Attempt to access value of a " "disengaged optional object"); } constexpr const _Tp&& value() const&& { if (this->_M_is_engaged()) return std::move(this->_M_get()); __throw_bad_optional_access("Attempt to access value of a " "disengaged optional object"); } template<typename _Up> constexpr _Tp value_or(_Up&& __u) const& { static_assert(__and_<is_copy_constructible<_Tp>, is_convertible<_Up&&, _Tp>>(), "Cannot return value"); if (this->_M_is_engaged()) return this->_M_get(); else return static_cast<_Tp>(std::forward<_Up>(__u)); } template<typename _Up> _Tp value_or(_Up&& __u) && { static_assert(__and_<is_move_constructible<_Tp>, is_convertible<_Up&&, _Tp>>(), "Cannot return value" ); if (this->_M_is_engaged()) return std::move(this->_M_get()); else return static_cast<_Tp>(std::forward<_Up>(__u)); } }; /// @relates experimental::optional @{ // [X.Y.8] Comparisons between optional values. template<typename _Tp> constexpr bool operator==(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return static_cast<bool>(__lhs) == static_cast<bool>(__rhs) && (!__lhs \|\| __lhs == __rhs); } template<typename _Tp> constexpr bool operator!=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return !(__lhs == __rhs); } template<typename _Tp> constexpr bool operator<(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return static_cast<bool>(__rhs) && (!__lhs \|\| __lhs < __rhs); } template<typename _Tp> constexpr bool operator>(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return __rhs < __lhs; } template<typename _Tp> constexpr bool operator<=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return !(__rhs < __lhs); } template<typename _Tp> constexpr bool operator>=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) { return !(__lhs < __rhs); } // [X.Y.9] Comparisons with nullopt. template<typename _Tp> constexpr bool operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template<typename _Tp> constexpr bool operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } template<typename _Tp> constexpr bool operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast<bool>(__lhs); } template<typename _Tp> constexpr bool operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast<bool>(__rhs); } template<typename _Tp> constexpr bool operator<(const optional<_Tp>& /* __lhs /, nullopt_t) noexcept { return false; } template<typename _Tp> constexpr bool operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast<bool>(__rhs); } template<typename _Tp> constexpr bool operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast<bool>(__lhs); } template<typename _Tp> constexpr bool operator>(nullopt_t, const optional<_Tp>& / __rhs /) noexcept { return false; } template<typename _Tp> constexpr bool operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template<typename _Tp> constexpr bool operator<=(nullopt_t, const optional<_Tp>& / __rhs /) noexcept { return true; } template<typename _Tp> constexpr bool operator>=(const optional<_Tp>& / __lhs /, nullopt_t) noexcept { return true; } template<typename _Tp> constexpr bool operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } // [X.Y.10] Comparisons with value type. template<typename _Tp> constexpr bool operator==(const optional<_Tp>& __lhs, const _Tp& __rhs) { return __lhs && __lhs == __rhs; } template<typename _Tp> constexpr bool operator==(const _Tp& __lhs, const optional<_Tp>& __rhs) { return __rhs && __lhs == __rhs; } template<typename _Tp> constexpr bool operator!=(const optional<_Tp>& __lhs, _Tp const& __rhs) { return !__lhs \|\| !(__lhs == __rhs); } template<typename _Tp> constexpr bool operator!=(const _Tp& __lhs, const optional<_Tp>& __rhs) { return !__rhs \|\| !(__lhs == __rhs); } template<typename _Tp> constexpr bool operator<(const optional<_Tp>& __lhs, const _Tp& __rhs) { return !__lhs \|\| __lhs < __rhs; } template<typename _Tp> constexpr bool operator<(const _Tp& __lhs, const optional<_Tp>& __rhs) { return __rhs && __lhs < __rhs; } template<typename _Tp> constexpr bool operator>(const optional<_Tp>& __lhs, const _Tp& __rhs) { return __lhs && __rhs < __lhs; } template<typename _Tp> constexpr bool operator>(const _Tp& __lhs, const optional<_Tp>& __rhs) { return !__rhs \|\| __rhs < __lhs; } template<typename _Tp> constexpr bool operator<=(const optional<_Tp>& __lhs, const _Tp& __rhs) { return !__lhs \|\| !(__rhs < __lhs); } template<typename _Tp> constexpr bool operator<=(const _Tp& __lhs, const optional<_Tp>& __rhs) { return __rhs && !(__rhs < __lhs); } template<typename _Tp> constexpr bool operator>=(const optional<_Tp>& __lhs, const _Tp& __rhs) { return __lhs && !(__lhs < __rhs); } template<typename _Tp> constexpr bool operator>=(const _Tp& __lhs, const optional<_Tp>& __rhs) { return !__rhs \|\| !(__lhs < __rhs); } // [X.Y.11] template<typename _Tp> inline void swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } template<typename _Tp> constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __t) { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; } /// @} relates experimental::optional /// @} group optional } // namespace fundamentals_v1 } // namespace experimental // [X.Y.12] /// std::hash partial specialization for experimental::optional /// @relates experimental::optional template<typename _Tp> struct hash<experimental::optional<_Tp>> { using result_type = size_t; using argument_type = experimental::optional<_Tp>; size_t operator()(const experimental::optional<_Tp>& __t) const noexcept(noexcept(hash<_Tp> {}(__t))) { // We pick an arbitrary hash for disengaged optionals which hopefully // usual values of _Tp won't typically hash to. constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333); return __t ? hash<_Tp> {}(*__t) : __magic_disengaged_hash; } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_OPTIONAL	25.99 KB	2025-09-15 15:41
📄 propagate_const // <experimental/propagate_const> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/propagate_const * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST #define _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <type_traits> #include <bits/functional_hash.h> #include <bits/move.h> #include <bits/stl_function.h> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { /* * @defgroup propagate_const Const-propagating wrapper * @ingroup libfund-ts * * A const-propagating wrapper that propagates const to pointer-like members, * as described in n4388 "A Proposal to Add a Const-Propagating Wrapper * to the Standard Library". * * @{ / /// Const-propagating wrapper. template <typename _Tp> class propagate_const { public: typedef remove_reference_t<decltype(std::declval<_Tp&>())> element_type; private: template <typename _Up> struct __is_propagate_const : false_type { }; template <typename _Up> struct __is_propagate_const<propagate_const<_Up>> : true_type { }; template <typename _Up> friend constexpr const _Up& get_underlying(const propagate_const<_Up>& __pt) noexcept; template <typename _Up> friend constexpr _Up& get_underlying(propagate_const<_Up>& __pt) noexcept; template <typename _Up> static constexpr element_type* __to_raw_pointer(_Up* __u) { return __u; } template <typename _Up> static constexpr element_type* __to_raw_pointer(_Up& __u) { return __u.get(); } template <typename _Up> static constexpr const element_type* __to_raw_pointer(const _Up* __u) { return __u; } template <typename _Up> static constexpr const element_type* __to_raw_pointer(const _Up& __u) { return __u.get(); } public: static_assert(__and_<is_object<typename remove_pointer<_Tp>::type>, __not_<is_array<_Tp>>, __or_<is_class<_Tp>, is_pointer<_Tp>>>::value, "propagate_const requires a class or a pointer to an" " object type"); // [propagate_const.ctor], constructors constexpr propagate_const() = default; propagate_const(const propagate_const& __p) = delete; constexpr propagate_const(propagate_const&& __p) = default; template <typename _Up, typename enable_if<__and_<is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>>::value, bool >::type=true> constexpr propagate_const(propagate_const<_Up>&& __pu) : _M_t(std::move(get_underlying(__pu))) {} template <typename _Up, typename enable_if<__and_<is_constructible<_Tp, _Up&&>, __not_<is_convertible<_Up&&, _Tp>>>::value, bool>::type=false> constexpr explicit propagate_const(propagate_const<_Up>&& __pu) : _M_t(std::move(get_underlying(__pu))) {} template <typename _Up, typename enable_if<__and_<is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>, __not_<__is_propagate_const< typename decay<_Up>::type>> >::value, bool>::type=true> constexpr propagate_const(_Up&& __u) : _M_t(std::forward<_Up>(__u)) {} template <typename _Up, typename enable_if<__and_<is_constructible<_Tp, _Up&&>, __not_<is_convertible<_Up&&, _Tp>>, __not_<__is_propagate_const< typename decay<_Up>::type>> >::value, bool>::type=false> constexpr explicit propagate_const(_Up&& __u) : _M_t(std::forward<_Up>(__u)) {} // [propagate_const.assignment], assignment propagate_const& operator=(const propagate_const& __p) = delete; constexpr propagate_const& operator=(propagate_const&& __p) = default; template <typename _Up, typename = typename enable_if<is_convertible<_Up&&, _Tp>::value>::type> constexpr propagate_const& operator=(propagate_const<_Up>&& __pu) { _M_t = std::move(get_underlying(__pu)); return this; } template <typename _Up, typename = typename enable_if<__and_<is_convertible<_Up&&, _Tp>, __not_<__is_propagate_const< typename decay<_Up>::type>> >::value>::type> constexpr propagate_const& operator=(_Up&& __u) { _M_t = std::forward<_Up>(__u); return this; } // [propagate_const.const_observers], const observers explicit constexpr operator bool() const { return bool(_M_t); } constexpr const element_type* operator->() const { return get(); } template <typename _Up = _Tp, typename enable_if<__or_<is_pointer<_Up>, is_convertible<_Up, const element_type> >::value, bool>::type = true> constexpr operator const element_type() const { return get(); } constexpr const element_type& operator() const { return get(); } constexpr const element_type* get() const { return __to_raw_pointer(_M_t); } // [propagate_const.non_const_observers], non-const observers constexpr element_type* operator->() { return get(); } template <typename _Up = _Tp, typename enable_if<__or_<is_pointer<_Up>, is_convertible<_Up, const element_type> >::value, bool>::type = true> constexpr operator element_type() { return get(); } constexpr element_type& operator() { return get(); } constexpr element_type* get() { return __to_raw_pointer(_M_t); } // [propagate_const.modifiers], modifiers constexpr void swap(propagate_const& __pt) noexcept(__is_nothrow_swappable<_Tp>::value) { using std::swap; swap(_M_t, get_underlying(__pt)); } private: _Tp _M_t; }; // [propagate_const.relational], relational operators template <typename _Tp> constexpr bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) { return get_underlying(__pt) == nullptr; } template <typename _Tp> constexpr bool operator==(nullptr_t, const propagate_const<_Tp>& __pu) { return nullptr == get_underlying(__pu); } template <typename _Tp> constexpr bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) { return get_underlying(__pt) != nullptr; } template <typename _Tp> constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pu) { return nullptr != get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator==(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) == get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator!=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) != get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator<(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) < get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator>(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) > get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator<=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) <= get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator>=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) { return get_underlying(__pt) >= get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) == __u; } template <typename _Tp, typename _Up> constexpr bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) != __u; } template <typename _Tp, typename _Up> constexpr bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) < __u; } template <typename _Tp, typename _Up> constexpr bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) > __u; } template <typename _Tp, typename _Up> constexpr bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) <= __u; } template <typename _Tp, typename _Up> constexpr bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) { return get_underlying(__pt) >= __u; } template <typename _Tp, typename _Up> constexpr bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t == get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t != get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t < get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t > get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t <= get_underlying(__pu); } template <typename _Tp, typename _Up> constexpr bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) { return __t >= get_underlying(__pu); } // [propagate_const.algorithms], specialized algorithms // _GLIBCXX_RESOLVE_LIB_DEFECTS // 3413. propagate_const's swap [...] needs to be constrained and use a trait template <typename _Tp> constexpr enable_if_t<__is_swappable<_Tp>::value, void> swap(propagate_const<_Tp>& __pt, propagate_const<_Tp>& __pt2) noexcept(__is_nothrow_swappable<_Tp>::value) { __pt.swap(__pt2); } // [propagate_const.underlying], underlying pointer access template <typename _Tp> constexpr const _Tp& get_underlying(const propagate_const<_Tp>& __pt) noexcept { return __pt._M_t; } template <typename _Tp> constexpr _Tp& get_underlying(propagate_const<_Tp>& __pt) noexcept { return __pt._M_t; } /// @} group propagate_const } // namespace fundamentals_v2 } // namespace experimental // [propagate_const.hash], hash support template <typename _Tp> struct hash<experimental::propagate_const<_Tp>> { using result_type = size_t; using argument_type = experimental::propagate_const<_Tp>; size_t operator()(const experimental::propagate_const<_Tp>& __t) const noexcept(noexcept(hash<_Tp>{}(get_underlying(__t)))) { return hash<_Tp>{}(get_underlying(__t)); } }; // [propagate_const.comparison_function_objects], comparison function objects template <typename _Tp> struct equal_to<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; template <typename _Tp> struct not_equal_to<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return not_equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; template <typename _Tp> struct less<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return less<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; template <typename _Tp> struct greater<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return greater<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; template <typename _Tp> struct less_equal<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return less_equal<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; template <typename _Tp> struct greater_equal<experimental::propagate_const<_Tp>> { constexpr bool operator()(const experimental::propagate_const<_Tp>& __x, const experimental::propagate_const<_Tp>& __y) const { return greater_equal<_Tp>{}(get_underlying(__x), get_underlying(__y)); } typedef experimental::propagate_const<_Tp> first_argument_type; typedef experimental::propagate_const<_Tp> second_argument_type; typedef bool result_type; }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST	15.13 KB	2025-09-15 15:41
📄 random // <experimental/random> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/random * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_RANDOM #define _GLIBCXX_EXPERIMENTAL_RANDOM 1 #if __cplusplus >= 201402L #include <random> #include <experimental/bits/lfts_config.h> namespace std { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_randint 201511 inline std::default_random_engine& _S_randint_engine() { static thread_local default_random_engine __eng{random_device{}()}; return __eng; } // 13.2.2.1, Function template randint template<typename _IntType> inline _IntType randint(_IntType __a, _IntType __b) { static_assert(is_integral<_IntType>::value && sizeof(_IntType) > 1, "argument must be an integer type"); using _Dist = std::uniform_int_distribution<_IntType>; // This relies on the fact our uniform_int_distribution is stateless, // otherwise we'd need a static thread_local _Dist and pass it // _Dist::param_type{__a, __b}. return _Dist(__a, __b)(_S_randint_engine()); } inline void reseed() { _S_randint_engine().seed(random_device{}()); } inline void reseed(default_random_engine::result_type __value) { _S_randint_engine().seed(__value); } } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_RANDOM	2.51 KB	2025-09-15 15:41
📄 ratio // Variable Templates For ratio -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/ratio * This is a TS C++ Library header. * @ingroup libfund-ts */ // // N3932 Variable Templates For Type Traits (Revision 1) // #ifndef _GLIBCXX_EXPERIMENTAL_RATIO #define _GLIBCXX_EXPERIMENTAL_RATIO 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <ratio> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { // See C++14 20.11.5, ratio comparison template <typename _R1, typename _R2> constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value; template <typename _R1, typename _R2> constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value; template <typename _R1, typename _R2> constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value; template <typename _R1, typename _R2> constexpr bool ratio_less_equal_v = ratio_less_equal<_R1, _R2>::value; template <typename _R1, typename _R2> constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value; template <typename _R1, typename _R2> constexpr bool ratio_greater_equal_v = ratio_greater_equal<_R1, _R2>::value; } // namespace fundamentals_v1 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_RATIO	2.38 KB	2025-09-15 15:41
📄 regex // <experimental/regex> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/regex * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_REGEX #define _GLIBCXX_EXPERIMENTAL_REGEX 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <regex> #include <experimental/string> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #if _GLIBCXX_USE_CXX11_ABI namespace pmr { template<typename _BidirectionalIterator> using match_results = std::match_results<_BidirectionalIterator, polymorphic_allocator< sub_match<_BidirectionalIterator>>>; typedef match_results<const char> cmatch; typedef match_results<const wchar_t*> wcmatch; typedef match_results<string::const_iterator> smatch; typedef match_results<wstring::const_iterator> wsmatch; } // namespace pmr #endif } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_REGEX	2.07 KB	2025-09-15 15:41
📄 set // <experimental/set> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/set * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_SET #define _GLIBCXX_EXPERIMENTAL_SET 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <set> #include <bits/erase_if.h> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Key, typename _Compare, typename _Alloc, typename _Predicate> inline void erase_if(set<_Key, _Compare, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } template<typename _Key, typename _Compare, typename _Alloc, typename _Predicate> inline void erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } namespace pmr { template<typename _Key, typename _Compare = less<_Key>> using set = std::set<_Key, _Compare, polymorphic_allocator<_Key>>; template<typename _Key, typename _Compare = less<_Key>> using multiset = std::multiset<_Key, _Compare, polymorphic_allocator<_Key>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_SET	2.41 KB	2025-09-15 15:41
📄 simd // Components for element-wise operations on data-parallel objects -- C++ -- // Copyright (C) 2020-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/simd * This is a TS C++ Library header. / // // N4773 §9 data-parallel types library // #ifndef _GLIBCXX_EXPERIMENTAL_SIMD #define _GLIBCXX_EXPERIMENTAL_SIMD #if __cplusplus >= 201703L /* @defgroup par-ts Parallelism TS * @ingroup experimental * * Components defined by the _C++ Extensions for Parallelism_ * Technical Specification. * * - ISO/IEC TS 19570:2015 C++ Extensions for Parallelism * - ISO/IEC TS 19570:2018 C++ Extensions for Parallelism, Version 2 / /* @defgroup ts_simd Data parallel extensions * @ingroup par-ts * * Data-parallel types library. * @since C++17 */ /// @ingroup ts_simd #define __cpp_lib_experimental_parallel_simd 201803 #pragma GCC diagnostic push // Many [[gnu::vector_size(N)]] types might lead to a -Wpsabi warning which is // irrelevant as those functions never appear on ABI borders #ifndef __clang__ #pragma GCC diagnostic ignored "-Wpsabi" #endif // If __OPTIMIZE__ is not defined some intrinsics are defined as macros, making // use of C casts internally. This requires us to disable the warning as it // would otherwise yield many false positives. #ifndef __OPTIMIZE__ #pragma GCC diagnostic ignored "-Wold-style-cast" #endif #include "bits/simd_detail.h" #include "bits/simd.h" #include "bits/simd_fixed_size.h" #include "bits/simd_scalar.h" #include "bits/simd_builtin.h" #include "bits/simd_converter.h" #if _GLIBCXX_SIMD_X86INTRIN #include "bits/simd_x86.h" #elif _GLIBCXX_SIMD_HAVE_NEON #include "bits/simd_neon.h" #elif __ALTIVEC__ #include "bits/simd_ppc.h" #endif #include "bits/simd_math.h" #pragma GCC diagnostic pop #endif // C++17 #endif // _GLIBCXX_EXPERIMENTAL_SIMD // vim: ft=cpp	2.75 KB	2025-09-15 15:41
📄 socket // <experimental/socket> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/socket * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_SOCKET #define _GLIBCXX_EXPERIMENTAL_SOCKET #pragma GCC system_header #if __cplusplus >= 201402L #include <experimental/netfwd> #include <experimental/buffer> #include <experimental/io_context> #include <experimental/bits/net.h> #include <streambuf> #include <istream> #include <bits/unique_ptr.h> #if _GLIBCXX_HAVE_UNISTD_H # include <unistd.h> # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H # include <sys/socket.h> // socket etc # endif # ifdef _GLIBCXX_HAVE_SYS_IOCTL_H # include <sys/ioctl.h> // ioctl # endif # ifdef _GLIBCXX_HAVE_SYS_UIO_H # include <sys/uio.h> // iovec # endif # ifdef _GLIBCXX_HAVE_POLL_H # include <poll.h> // poll, pollfd, POLLIN, POLLOUT, POLLERR # endif # ifdef _GLIBCXX_HAVE_FCNTL_H # include <fcntl.h> // fcntl, F_GETFL, F_SETFL # endif #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @addtogroup networking-ts * @{ / enum class socket_errc { // TODO decide values already_open = 3, not_found = 4 }; } // namespace v1 } // namespace net } // namespace experimental template<> struct is_error_code_enum<experimental::net::v1::socket_errc> : public true_type {}; namespace experimental { namespace net { inline namespace v1 { const error_category& socket_category() noexcept { struct __cat : error_category { const char name() const noexcept { return "socket"; } std::string message(int __e) const { if (__e == (int)socket_errc::already_open) return "already open"; else if (__e == (int)socket_errc::not_found) return "endpoint not found"; return "socket error"; } virtual void __message(int) { } // TODO dual ABI XXX }; static __cat __c; return __c; } inline error_code make_error_code(socket_errc __e) noexcept { return error_code(static_cast<int>(__e), socket_category()); } inline error_condition make_error_condition(socket_errc __e) noexcept { return error_condition(static_cast<int>(__e), socket_category()); } // TODO GettableSocket reqs // TODO SettableSocket reqs // TODO BooleanSocketOption reqs // TODO IntegerSocketOption reqs // TODO IoControlCommand reqs // TODO ConnectCondition reqs /** @brief Sockets * @{ / class socket_base { public: #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H class broadcast : public __sockopt_crtp<broadcast, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<broadcast, bool>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_BROADCAST; }; class debug : public __sockopt_crtp<debug, bool> { public: friend __sockopt_crtp<debug, bool>; using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: static const int _S_level = SOL_SOCKET; static const int _S_name = SO_DEBUG; }; class do_not_route : public __sockopt_crtp<do_not_route, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<do_not_route, bool>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_DONTROUTE; }; class keep_alive : public __sockopt_crtp<keep_alive, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<keep_alive, bool>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_KEEPALIVE; }; class linger : public __sockopt_crtp<linger, ::linger> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; linger() noexcept = default; linger(bool __e, chrono::seconds __t) noexcept { enabled(__e); timeout(__t); } bool enabled() const noexcept { return _M_value.l_onoff != 0; } void enabled(bool __e) noexcept { _M_value.l_onoff = int(__e); } chrono::seconds timeout() const noexcept { return chrono::seconds(_M_value.l_linger); } void timeout(chrono::seconds __t) noexcept { _M_value.l_linger = __t.count(); } private: friend __sockopt_crtp<linger, ::linger>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_LINGER; }; class out_of_band_inline : public __sockopt_crtp<out_of_band_inline, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<out_of_band_inline, bool>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_OOBINLINE; }; class receive_buffer_size : public __sockopt_crtp<receive_buffer_size> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<receive_buffer_size>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_RCVBUF; }; class receive_low_watermark : public __sockopt_crtp<receive_low_watermark> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<receive_low_watermark>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_RCVLOWAT; }; class reuse_address : public __sockopt_crtp<reuse_address, bool> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<reuse_address, bool>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_REUSEADDR; }; class send_buffer_size : public __sockopt_crtp<send_buffer_size> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<send_buffer_size>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_SNDBUF; }; class send_low_watermark : public __sockopt_crtp<send_low_watermark> { public: using __sockopt_crtp::__sockopt_crtp; using __sockopt_crtp::operator=; private: friend __sockopt_crtp<send_low_watermark>; static const int _S_level = SOL_SOCKET; static const int _S_name = SO_SNDLOWAT; }; #endif // HAVE_SYS_SOCKET_H enum shutdown_type : int { }; #if defined SHUT_RD && defined SHUT_WR && defined SHUT_RDWR static constexpr shutdown_type shutdown_receive = (shutdown_type)SHUT_RD; static constexpr shutdown_type shutdown_send = (shutdown_type)SHUT_WR; static constexpr shutdown_type shutdown_both = (shutdown_type)SHUT_RDWR; #endif enum wait_type : int { }; #ifdef _GLIBCXX_HAVE_POLL_H static constexpr wait_type wait_read = (wait_type)POLLIN; static constexpr wait_type wait_write = (wait_type)POLLOUT; static constexpr wait_type wait_error = (wait_type)POLLERR; #else static constexpr wait_type wait_read = (wait_type)1; static constexpr wait_type wait_write = (wait_type)2; static constexpr wait_type wait_error = (wait_type)4; #endif enum message_flags : int { }; #if defined MSG_PEEK && defined MSG_OOB && defined MSG_DONTROUTE static constexpr message_flags message_peek = (message_flags)MSG_PEEK; static constexpr message_flags message_out_of_band = (message_flags)MSG_OOB; static constexpr message_flags message_do_not_route = (message_flags)MSG_DONTROUTE; #endif #ifdef SOMAXCONN static constexpr int max_listen_connections = SOMAXCONN; #else static constexpr int max_listen_connections = 4; #endif // message_flags bitmask operations are defined as hidden friends. friend constexpr message_flags operator&(message_flags __f1, message_flags __f2) noexcept { return message_flags( int(__f1) & int(__f2) ); } friend constexpr message_flags operator\|(message_flags __f1, message_flags __f2) noexcept { return message_flags( int(__f1) \| int(__f2) ); } friend constexpr message_flags operator^(message_flags __f1, message_flags __f2) noexcept { return message_flags( int(__f1) ^ int(__f2) ); } friend constexpr message_flags operator~(message_flags __f) noexcept { return message_flags( ~int(__f) ); } friend constexpr message_flags& operator&=(message_flags& __f1, message_flags __f2) noexcept { return __f1 = (__f1 & __f2); } friend constexpr message_flags& operator\|=(message_flags& __f1, message_flags __f2) noexcept { return __f1 = (__f1 \| __f2); } friend constexpr message_flags& operator^=(message_flags& __f1, message_flags __f2) noexcept { return __f1 = (__f1 ^ __f2); } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H protected: struct __msg_hdr : ::msghdr { #ifdef IOV_MAX using __iovec_array = array<::iovec, IOV_MAX>; #elif _GLIBCXX_HAVE_UNISTD_H struct __iovec_array { __iovec_array() : _M_ptr(new ::iovec[size()]) { } ::iovec& operator[](size_t __n) noexcept { return _M_ptr[__n]; } ::iovec data() noexcept { return _M_ptr.get(); } static size_t size() { static const size_t __iov_max = ::sysconf(_SC_IOV_MAX); return __iov_max; } private: unique_ptr<::iovec[]> _M_ptr; }; #else using __iovec_array = array<::iovec, 16>; #endif __iovec_array _M_iov; template<typename _BufferSequence> explicit __msg_hdr(const _BufferSequence& __buffers) : msghdr() { auto __buf = net::buffer_sequence_begin(__buffers); const auto __bufend = net::buffer_sequence_end(__buffers); size_t __len = 0; while (__buf != __bufend && __len != _M_iov.size()) { _M_iov[__len].iov_base = (void)__buf->data(); _M_iov[__len].iov_len = __buf->size(); ++__buf; ++__len; } this->msg_iovlen = __len; this->msg_iov = _M_iov.data(); } template<typename _BufferSequence, typename _Endpoint> __msg_hdr(const _BufferSequence& __buffers, const _Endpoint& __ep) : __msg_hdr(__buffers) { this->msg_name = __ep.data(); this->msg_namelen = __ep.size(); } }; #endif protected: socket_base() = default; ~socket_base() = default; }; // TODO define socket_base static constants in .so for C++14 mode #if _GLIBCXX_HAVE_UNISTD_H class __socket_impl { protected: using executor_type = io_context::executor_type; using native_handle_type = int; explicit __socket_impl(io_context& __ctx) : _M_ctx(std::addressof(__ctx)) { } __socket_impl(__socket_impl&& __rhs) : _M_ctx(__rhs._M_ctx), _M_sockfd(std::exchange(__rhs._M_sockfd, -1)), _M_bits(std::exchange(__rhs._M_bits, {})) { } __socket_impl& operator=(__socket_impl&& __rhs) { _M_ctx = __rhs._M_ctx; _M_sockfd = std::exchange(__rhs._M_sockfd, -1); _M_bits = std::exchange(__rhs._M_bits, {}); return this; } ~__socket_impl() = default; __socket_impl(const __socket_impl&) = delete; __socket_impl& operator=(const __socket_impl&) = delete; executor_type get_executor() noexcept { return _M_ctx->get_executor(); } native_handle_type native_handle() noexcept { return _M_sockfd; } bool is_open() const noexcept { return _M_sockfd != -1; } void close(error_code& __ec) { if (is_open()) { cancel(__ec); if (!__ec) { if (::close(_M_sockfd) == -1) __ec.assign(errno, generic_category()); else { get_executor().context()._M_remove_fd(_M_sockfd); _M_sockfd = -1; } } } } void cancel(error_code& __ec) { _M_ctx->cancel(_M_sockfd, __ec); } void non_blocking(bool __mode, error_code&) { _M_bits.non_blocking = __mode; } bool non_blocking() const { return _M_bits.non_blocking; } void native_non_blocking(bool __mode, error_code& __ec) { #if defined _GLIBCXX_HAVE_FCNTL_H && defined _GLIBCXX_HAVE_DECL_O_NONBLOCK int __flags = ::fcntl(_M_sockfd, F_GETFL, 0); if (__flags >= 0) { if (__mode) __flags \|= O_NONBLOCK; else __flags &= ~O_NONBLOCK; __flags = ::fcntl(_M_sockfd, F_SETFL, __flags); } if (__flags == -1) __ec.assign(errno, generic_category()); else { __ec.clear(); _M_bits.native_non_blocking = __mode; } #else __ec = std::make_error_code(std::errc::not_supported); #endif } bool native_non_blocking() const { #if defined _GLIBCXX_HAVE_FCNTL_H && defined _GLIBCXX_HAVE_DECL_O_NONBLOCK if (_M_bits.native_non_blocking == -1) { const int __flags = ::fcntl(_M_sockfd, F_GETFL, 0); if (__flags == -1) return 0; _M_bits.native_non_blocking = __flags & O_NONBLOCK; } return _M_bits.native_non_blocking; #else return false; #endif } io_context* _M_ctx; int _M_sockfd{-1}; struct { unsigned non_blocking : 1; mutable signed native_non_blocking : 2; unsigned enable_connection_aborted : 1; } _M_bits{}; }; template<typename _Protocol> class __basic_socket_impl : public __socket_impl { using __base = __socket_impl; protected: using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; explicit __basic_socket_impl(io_context& __ctx) : __base(__ctx) { } __basic_socket_impl(__basic_socket_impl&&) = default; template<typename _OtherProtocol> __basic_socket_impl(__basic_socket_impl<_OtherProtocol>&& __rhs) : __base(std::move(__rhs)), _M_protocol(std::move(__rhs._M_protocol)) { } __basic_socket_impl& operator=(__basic_socket_impl&& __rhs) { if (this == std::addressof(__rhs)) return this; _M_close(); __base::operator=(std::move(__rhs)); return this; } ~__basic_socket_impl() { _M_close(); } __basic_socket_impl(const __basic_socket_impl&) = delete; __basic_socket_impl& operator=(const __basic_socket_impl&) = delete; void open(const protocol_type& __protocol, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (is_open()) __ec = socket_errc::already_open; else { _M_protocol = __protocol; _M_sockfd = ::socket(__protocol.family(), __protocol.type(), __protocol.protocol()); if (is_open()) { get_executor().context()._M_add_fd(_M_sockfd); __ec.clear(); } else __ec.assign(errno, std::generic_category()); } #else __ec = std::make_error_code(errc::operation_not_supported); #endif } void assign(const protocol_type& __protocol, const native_handle_type& __native_socket, error_code& __ec) { if (is_open()) __ec = socket_errc::already_open; else { _M_protocol = __protocol; _M_bits.native_non_blocking = -1; _M_sockfd = __native_socket; if (is_open()) { get_executor().context()._M_add_fd(_M_sockfd); __ec.clear(); } else __ec.assign(errno, std::generic_category()); } } native_handle_type release(error_code& __ec) { __glibcxx_assert(is_open()); cancel(__ec); return std::exchange(_M_sockfd, -1); } template<typename _SettableSocketOption> void set_option(const _SettableSocketOption& __option, error_code& __ec) { # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H int __result = ::setsockopt(_M_sockfd, __option.level(_M_protocol), __option.name(_M_protocol), __option.data(_M_protocol), __option.size(_M_protocol)); if (__result == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(std::errc::not_supported); #endif } template<typename _GettableSocketOption> void get_option(_GettableSocketOption& __option, error_code& __ec) const { # ifdef _GLIBCXX_HAVE_SYS_SOCKET_H int __result = ::getsockopt(_M_sockfd, __option.level(_M_protocol), __option.name(_M_protocol), __option.data(_M_protocol), __option.size(_M_protocol)); if (__result == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(std::errc::not_supported); #endif } template<typename _IoControlCommand> void io_control(_IoControlCommand& __command, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_IOCTL_H int __result = ::ioctl(_M_sockfd, __command.name(), __command.data()); if (__result == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(std::errc::not_supported); #endif } endpoint_type local_endpoint(error_code& __ec) const { endpoint_type __endpoint; #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socklen_t __endpoint_len = __endpoint.capacity(); if (::getsockname(_M_sockfd, (sockaddr)__endpoint.data(), &__endpoint_len) == -1) { __ec.assign(errno, generic_category()); return endpoint_type{}; } __ec.clear(); __endpoint.resize(__endpoint_len); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return __endpoint; } void bind(const endpoint_type& __endpoint, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (::bind(_M_sockfd, (sockaddr)__endpoint.data(), __endpoint.size()) == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } _Protocol _M_protocol{ endpoint_type{}.protocol() }; private: void _M_close() { if (is_open()) { error_code __ec; cancel(__ec); #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H set_option(socket_base::linger{false, chrono::seconds{}}, __ec); #endif ::close(_M_sockfd); } } }; template<typename _Protocol> class basic_socket : public socket_base, private __basic_socket_impl<_Protocol> { using __base = __basic_socket_impl<_Protocol>; public: // types: using executor_type = io_context::executor_type; using native_handle_type = int; using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; static_assert(__detail::__protocol<protocol_type>, "protocol_type meets the Protocol requirements"); // basic_socket operations: executor_type get_executor() noexcept { return __base::get_executor(); } native_handle_type native_handle() noexcept { return __base::native_handle(); } void open(const protocol_type& __protocol = protocol_type()) { open(__protocol, __throw_on_error{"basic_socket::open"}); } void open(const protocol_type& __protocol, error_code& __ec) { __base::open(__protocol, __ec); } void assign(const protocol_type& __protocol, const native_handle_type& __native_socket) { assign(__protocol, __native_socket, __throw_on_error{"basic_socket::assign"}); } void assign(const protocol_type& __protocol, const native_handle_type& __native_socket, error_code& __ec) { __base::assign(__protocol, __native_socket, __ec); } native_handle_type release() { return release(__throw_on_error{"basic_socket::release"}); } native_handle_type release(error_code& __ec) { return __base::release(__ec); } _GLIBCXX_NODISCARD bool is_open() const noexcept { return __base::is_open(); } void close() { close(__throw_on_error{"basic_socket::close"}); } void close(error_code& __ec) { __base::close(__ec); } void cancel() { cancel(__throw_on_error{"basic_socket::cancel"}); } void cancel(error_code& __ec) { __base::cancel(__ec); } template<typename _SettableSocketOption> void set_option(const _SettableSocketOption& __option) { set_option(__option, __throw_on_error{"basic_socket::set_option"}); } template<typename _SettableSocketOption> void set_option(const _SettableSocketOption& __option, error_code& __ec) { __base::set_option(__option, __ec); } template<typename _GettableSocketOption> void get_option(_GettableSocketOption& __option) const { get_option(__option, __throw_on_error{"basic_socket::get_option"}); } template<typename _GettableSocketOption> void get_option(_GettableSocketOption& __option, error_code& __ec) const { __base::get_option(__option, __ec); } template<typename _IoControlCommand> void io_control(_IoControlCommand& __command) { io_control(__command, __throw_on_error{"basic_socket::io_control"}); } template<typename _IoControlCommand> void io_control(_IoControlCommand& __command, error_code& __ec) { __base::io_control(__command, __ec); } void non_blocking(bool __mode) { non_blocking(__mode, __throw_on_error{"basic_socket::non_blocking"}); } void non_blocking(bool __mode, error_code& __ec) { __base::non_blocking(__mode, __ec); } bool non_blocking() const { return __base::non_blocking(); } void native_non_blocking(bool __mode) { native_non_blocking(__mode, __throw_on_error{ "basic_socket::native_non_blocking"}); } void native_non_blocking(bool __mode, error_code& __ec) { __base::native_non_blocking(__mode, __ec); } bool native_non_blocking() const { return __base::native_non_blocking(); } bool at_mark() const { return at_mark(__throw_on_error{"basic_socket::at_mark"}); } bool at_mark(error_code& __ec) const { #ifdef _GLIBCXX_HAVE_SOCKATMARK const int __result = ::sockatmark(native_handle()); if (__result == -1) { __ec.assign(errno, generic_category()); return false; } __ec.clear(); return (bool)__result; #else __ec = std::make_error_code(errc::operation_not_supported); return false; #endif } size_t available() const { return available(__throw_on_error{"basic_socket::available"}); } size_t available(error_code& __ec) const { if (!is_open()) { __ec = std::make_error_code(errc::bad_file_descriptor); return 0; } #if defined _GLIBCXX_HAVE_SYS_IOCTL_H && defined FIONREAD int __avail = 0; if (::ioctl(this->_M_sockfd, FIONREAD, &__avail) == -1) { __ec.assign(errno, generic_category()); return 0; } __ec.clear(); return __avail; #else return 0; #endif } void bind(const endpoint_type& __endpoint) { return bind(__endpoint, __throw_on_error{"basic_socket::bind"}); } void bind(const endpoint_type& __endpoint, error_code& __ec) { __base::bind(__endpoint, __ec); } void shutdown(shutdown_type __what) { return shutdown(__what, __throw_on_error{"basic_socket::shutdown"}); } void shutdown(shutdown_type __what, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (::shutdown(native_handle(), static_cast<int>(__what)) == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } endpoint_type local_endpoint() const { return local_endpoint( __throw_on_error{"basic_socket::local_endpoint"}); } endpoint_type local_endpoint(error_code& __ec) const { return __base::local_endpoint(__ec); } endpoint_type remote_endpoint() const { return remote_endpoint( __throw_on_error{"basic_socket::remote_endpoint"}); } endpoint_type remote_endpoint(error_code& __ec) const { endpoint_type __endpoint; #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socklen_t __endpoint_len = __endpoint.capacity(); if (::getpeername(this->_M_sockfd, (sockaddr)__endpoint.data(), &__endpoint_len) == -1) { __ec.assign(errno, generic_category()); return endpoint_type{}; } __ec.clear(); __endpoint.resize(__endpoint_len); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return __endpoint; } void connect(const endpoint_type& __endpoint) { return connect(__endpoint, __throw_on_error{"basic_socket::connect"}); } void connect(const endpoint_type& __endpoint, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (!is_open()) { open(__endpoint.protocol(), __ec); if (__ec) return; } if (::connect(native_handle(), (const sockaddr)__endpoint.data(), __endpoint.size()) == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code)> async_connect(const endpoint_type& __endpoint, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code)> __init{__token}; if (!is_open()) { error_code __ec; open(__endpoint.protocol(), __ec); if (__ec) { auto __ex = net::get_associated_executor( __init.completion_handler, get_executor()); auto __a = get_associated_allocator( __init.completion_handler, std::allocator<void>()); __ex.post( [__h = std::move(__init.completion_handler), __ec] () mutable { __h(__ec); }, __a); return __init.result.get(); } } get_executor().context().async_wait( native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), __ep = std::move(__endpoint), __fd = native_handle()] (error_code __ec) mutable { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (!__ec && ::connect(__fd, (const sockaddr)__ep.data(), __ep.size()) == -1) __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif __h(__ec); }); return __init.result.get(); } void wait(wait_type __w) { return wait(__w, __throw_on_error{"basic_socket::wait"}); } void wait(wait_type __w, error_code& __ec) { #ifdef _GLIBCXX_HAVE_POLL_H ::pollfd __fd; __fd.fd = native_handle(); __fd.events = static_cast<int>(__w); int __res = ::poll(&__fd, 1, -1); if (__res == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code)> async_wait(wait_type __w, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code)> __init{__token}; get_executor().context().async_wait( native_handle(), static_cast<int>(__w), [__h = std::move(__init.completion_handler)] (error_code __ec) mutable { __h(__ec); }); return __init.result.get(); } protected: // construct / copy / destroy: using __base::__base; explicit basic_socket(io_context& __ctx) : __base(__ctx) { } basic_socket(io_context& __ctx, const protocol_type& __protocol) : __base(__ctx) { open(__protocol); } basic_socket(io_context& __ctx, const endpoint_type& __endpoint) : basic_socket(__ctx, __endpoint.protocol()) { bind(__endpoint); } basic_socket(io_context& __ctx, const protocol_type& __protocol, const native_handle_type& __native_socket) : __base(__ctx) { assign(__protocol, __native_socket); } basic_socket(const basic_socket&) = delete; basic_socket(basic_socket&& __rhs) = default; template<typename _OtherProtocol, typename _Requires = _Require<is_convertible<_OtherProtocol, _Protocol>>> basic_socket(basic_socket<_OtherProtocol>&& __rhs) : __base(std::move(__rhs)) { } ~basic_socket() = default; basic_socket& operator=(const basic_socket&) = delete; basic_socket& operator=(basic_socket&& __rhs) = default; template<typename _OtherProtocol> enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value, basic_socket&> operator=(basic_socket<_OtherProtocol>&& __rhs) { return this = basic_socket{std::move(__rhs)}; } }; template<typename _Protocol> class basic_datagram_socket : public basic_socket<_Protocol> { using __base = basic_socket<_Protocol>; public: // types: using native_handle_type = int; using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; // construct / copy / destroy: explicit basic_datagram_socket(io_context& __ctx) : __base(__ctx) { } basic_datagram_socket(io_context& __ctx, const protocol_type& __protocol) : __base(__ctx, __protocol) { } basic_datagram_socket(io_context& __ctx, const endpoint_type& __endpoint) : __base(__ctx, __endpoint) { } basic_datagram_socket(io_context& __ctx, const protocol_type& __protocol, const native_handle_type& __native_socket) : __base(__ctx, __protocol, __native_socket) { } basic_datagram_socket(const basic_datagram_socket&) = delete; basic_datagram_socket(basic_datagram_socket&& __rhs) = default; template<typename _OtherProtocol, typename _Requires = _Require<is_convertible<_OtherProtocol, _Protocol>>> basic_datagram_socket(basic_datagram_socket<_OtherProtocol>&& __rhs) : __base(std::move(__rhs)) { } ~basic_datagram_socket() = default; basic_datagram_socket& operator=(const basic_datagram_socket&) = delete; basic_datagram_socket& operator=(basic_datagram_socket&& __rhs) = default; template<typename _OtherProtocol> enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value, basic_datagram_socket&> operator=(basic_datagram_socket<_OtherProtocol>&& __rhs) { __base::operator=(std::move(__rhs)); return this; } // basic_datagram_socket operations: template<typename _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers) { return receive(__buffers, socket_base::message_flags(), __throw_on_error{"basic_datagram_socket::receive"}); } template<typename _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, error_code& __ec) { return receive(__buffers, socket_base::message_flags(), __ec); } template<typename _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags) { return receive(__buffers, __flags, __throw_on_error{"basic_datagram_socket::receive"}); } template<typename _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::recvmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result == -1) { __ec.assign(errno, generic_category()); return 0; } __ec.clear(); return __result; #else __ec = std::make_error_code(errc::operation_not_supported); return 0; #endif } template<typename _MutableBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive(const _MutableBufferSequence& __buffers, _CompletionToken&& __token) { return async_receive(__buffers, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<typename _MutableBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; this->get_executor().context().async_wait(this->native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::recvmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else __ec.clear(); __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } template<typename _MutableBufferSequence> size_t receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender) { return receive_from(__buffers, __sender, socket_base::message_flags(), __throw_on_error{ "basic_datagram_socket::receive_from"}); } template<typename _MutableBufferSequence> size_t receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender, error_code& __ec) { return receive_from(__buffers, __sender, socket_base::message_flags(), __ec); } template<typename _MutableBufferSequence> size_t receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender, socket_base::message_flags __flags) { return receive_from(__buffers, __sender, __flags, __throw_on_error{ "basic_datagram_socket::receive_from"}); } template<typename _MutableBufferSequence> size_t receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender, socket_base::message_flags __flags, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers, __sender); ssize_t __result = ::recvmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result == -1) { __ec.assign(errno, generic_category()); return 0; } __ec.clear(); __sender.resize(__msg.msg_namelen); return __result; #else __ec = std::make_error_code(errc::operation_not_supported); return 0; #endif } template<typename _MutableBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender, _CompletionToken&& __token) { return async_receive_from(__buffers, __sender, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<typename _MutableBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive_from(const _MutableBufferSequence& __buffers, endpoint_type& __sender, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; this->get_executor().context().async_wait( this->native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __sender = std::move(__sender), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers, __sender); ssize_t __result = ::recvmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else { __ec.clear(); __sender.resize(__msg.msg_namelen); } __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } template<typename _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers) { return send(__buffers, socket_base::message_flags(), __throw_on_error{"basic_datagram_socket::send"}); } template<typename _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, error_code& __ec) { return send(__buffers, socket_base::message_flags(), __ec); } template<typename _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags) { return send(__buffers, __flags, __throw_on_error{"basic_datagram_socket::send"}); } template<typename _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::sendmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result == -1) { __ec.assign(errno, generic_category()); return 0; } __ec.clear(); return __result; #else __ec = std::make_error_code(errc::operation_not_supported); return 0; #endif } template<typename _ConstBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send(const _ConstBufferSequence& __buffers, _CompletionToken&& __token) { return async_send(__buffers, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<typename _ConstBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; this->get_executor().context().async_wait( this->native_handle(), (int) socket_base::wait_write, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::sendmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else __ec.clear(); __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } template<typename _ConstBufferSequence> size_t send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient) { return send_to(__buffers, __recipient, socket_base::message_flags(), __throw_on_error{"basic_datagram_socket::send_to"}); } template<typename _ConstBufferSequence> size_t send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient, error_code& __ec) { return send_to(__buffers, __recipient, socket_base::message_flags(), __ec); } template<typename _ConstBufferSequence> size_t send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient, socket_base::message_flags __flags) { return send_to(__buffers, __recipient, __flags, __throw_on_error{"basic_datagram_socket::send_to"}); } template<typename _ConstBufferSequence> size_t send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient, socket_base::message_flags __flags, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers, __recipient); ssize_t __result = ::sendmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result == -1) { __ec.assign(errno, generic_category()); return 0; } __ec.clear(); __recipient.resize(__msg.msg_namelen); return __result; #else __ec = std::make_error_code(errc::operation_not_supported); return 0; #endif } template<typename _ConstBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient, _CompletionToken&& __token) { return async_send_to(__buffers, __recipient, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<typename _ConstBufferSequence, typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send_to(const _ConstBufferSequence& __buffers, const endpoint_type& __recipient, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; this->get_executor().context().async_wait( this->native_handle(), (int) socket_base::wait_write, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __recipient = std::move(__recipient), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers, __recipient); ssize_t __result = ::sendmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else { __ec.clear(); __recipient.resize(__msg.msg_namelen); } __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } }; template<typename _Protocol> class basic_stream_socket : public basic_socket<_Protocol> { using __base = basic_socket<_Protocol>; public: // types: using native_handle_type = int; using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; // construct / copy / destroy: explicit basic_stream_socket(io_context& __ctx) : __base(__ctx) { } basic_stream_socket(io_context& __ctx, const protocol_type& __protocol) : __base(__ctx, __protocol) { } basic_stream_socket(io_context& __ctx, const endpoint_type& __endpoint) : __base(__ctx, __endpoint) { } basic_stream_socket(io_context& __ctx, const protocol_type& __protocol, const native_handle_type& __native_socket) : __base(__ctx, __protocol, __native_socket) { } basic_stream_socket(const basic_stream_socket&) = delete; basic_stream_socket(basic_stream_socket&& __rhs) = default; template<typename _OtherProtocol, typename _Requires = _Require<is_convertible<_OtherProtocol, _Protocol>>> basic_stream_socket(basic_stream_socket<_OtherProtocol>&& __rhs) : __base(std::move(__rhs)) { } ~basic_stream_socket() = default; basic_stream_socket& operator=(const basic_stream_socket&) = delete; basic_stream_socket& operator=(basic_stream_socket&& __rhs) = default; template<class _OtherProtocol> enable_if_t<is_convertible<_OtherProtocol, _Protocol>::value, basic_stream_socket&> operator=(basic_stream_socket<_OtherProtocol>&& __rhs) { __base::operator=(std::move(__rhs)); return this; } // basic_stream_socket operations: template<class _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers) { return receive(__buffers, socket_base::message_flags(), __throw_on_error{"basic_stream_socket::receive"}); } template<class _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, error_code& __ec) { return receive(__buffers, socket_base::message_flags(), __ec); } template<class _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags) { return receive(__buffers, __flags, __throw_on_error{"basic_stream_socket::receive"}); } template<class _MutableBufferSequence> size_t receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags, error_code& __ec) { if (__buffer_empty(__buffers)) { __ec.clear(); return 0; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::recvmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result >= 0) { __ec.clear(); return __result; } __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return 0; } template<class _MutableBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive(const _MutableBufferSequence& __buffers, _CompletionToken&& __token) { return async_receive(__buffers, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<class _MutableBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_receive(const _MutableBufferSequence& __buffers, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; if (__buffer_empty(__buffers)) { auto __ex = net::get_associated_executor( __init.completion_handler, this->get_executor()); auto __a = get_associated_allocator( __init.completion_handler, std::allocator<void>()); __ex.post( [__h=std::move(__init.completion_handler)] () mutable { __h(error_code{}, 0); }, __a); return __init.result.get(); } this->get_executor().context().async_wait(this->native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::recvmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else __ec.clear(); __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } template<class _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers) { return send(__buffers, socket_base::message_flags(), __throw_on_error{"basic_stream_socket::send"}); } template<class _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, error_code& __ec) { return send(__buffers, socket_base::message_flags(), __ec); } template<class _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags) { return send(__buffers, socket_base::message_flags(), __throw_on_error{"basic_stream_socket::send"}); } template<class _ConstBufferSequence> size_t send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags, error_code& __ec) { if (__buffer_empty(__buffers)) { __ec.clear(); return 0; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::sendmsg(this->native_handle(), &__msg, static_cast<int>(__flags)); if (__result >= 0) { __ec.clear(); return __result; } __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return 0; } template<class _ConstBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send(const _ConstBufferSequence& __buffers, _CompletionToken&& __token) { return async_send(__buffers, socket_base::message_flags(), std::forward<_CompletionToken>(__token)); } template<class _ConstBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_send(const _ConstBufferSequence& __buffers, socket_base::message_flags __flags, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, size_t)> __init{__token}; if (__buffer_empty(__buffers)) { auto __ex = net::get_associated_executor( __init.completion_handler, this->get_executor()); auto __a = get_associated_allocator( __init.completion_handler, std::allocator<void>()); __ex.post( [__h=std::move(__init.completion_handler)] () mutable { __h(error_code{}, 0); }, __a); return __init.result.get(); } this->get_executor().context().async_wait(this->native_handle(), (int) socket_base::wait_write, [__h = std::move(__init.completion_handler), &__buffers, __flags = static_cast<int>(__flags), __fd = this->native_handle()] (error_code __ec) mutable { if (__ec) { __h(__ec); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H socket_base::__msg_hdr __msg(__buffers); ssize_t __result = ::sendmsg(__fd, &__msg, __flags); if (__result == -1) { __ec.assign(errno, generic_category()); __result = 0; } else __ec.clear(); __h(__ec, __result); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } template<class _MutableBufferSequence> size_t read_some(const _MutableBufferSequence& __buffers) { return receive(__buffers, __throw_on_error{"basic_stream_socket::read_some"}); } template<class _MutableBufferSequence> size_t read_some(const _MutableBufferSequence& __buffers, error_code& __ec) { return receive(__buffers, __ec); } template<class _MutableBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_read_some(const _MutableBufferSequence& __buffers, _CompletionToken&& __token) { return async_receive(__buffers, std::forward<_CompletionToken>(__token)); } template<class _ConstBufferSequence> size_t write_some(const _ConstBufferSequence& __buffers) { return send(__buffers, __throw_on_error{"basic_stream_socket:write_some"}); } template<class _ConstBufferSequence> size_t write_some(const _ConstBufferSequence& __buffers, error_code& __ec) { return send(__buffers, __ec); } template<class _ConstBufferSequence, class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, size_t)> async_write_some(const _ConstBufferSequence& __buffers, _CompletionToken&& __token) { return async_send(__buffers, std::forward<_CompletionToken>(__token)); } }; template<typename _AcceptableProtocol> class basic_socket_acceptor : public socket_base, private __basic_socket_impl<_AcceptableProtocol> { using __base = __basic_socket_impl<_AcceptableProtocol>; public: // types: using executor_type = io_context::executor_type; using native_handle_type = int; using protocol_type = _AcceptableProtocol; using endpoint_type = typename protocol_type::endpoint; using socket_type = typename protocol_type::socket; static_assert(__detail::__acceptable_protocol<protocol_type>, "protocol_type meets the AcceptableProtocol requirements"); // construct / copy / destroy: explicit basic_socket_acceptor(io_context& __ctx) : __base(__ctx), _M_protocol(endpoint_type{}.protocol()) { } basic_socket_acceptor(io_context& __ctx, const protocol_type& __protocol) : __base(__ctx), _M_protocol(__protocol) { open(__protocol); } basic_socket_acceptor(io_context& __ctx, const endpoint_type& __endpoint, [[__maybe_unused__]] bool __reuse_addr = true) : basic_socket_acceptor(__ctx, __endpoint.protocol()) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (__reuse_addr) set_option(reuse_address(true)); #endif bind(__endpoint); listen(); } basic_socket_acceptor(io_context& __ctx, const protocol_type& __protocol, const native_handle_type& __native_acceptor) : basic_socket_acceptor(__ctx, __protocol) { assign(__protocol, __native_acceptor); } basic_socket_acceptor(const basic_socket_acceptor&) = delete; basic_socket_acceptor(basic_socket_acceptor&&) = default; template<typename _OtherProtocol, typename _Requires = _Require<is_convertible<_OtherProtocol, protocol_type>>> basic_socket_acceptor(basic_socket_acceptor<_OtherProtocol>&& __rhs) : __base(std::move(__rhs)) { } ~basic_socket_acceptor() = default; basic_socket_acceptor& operator=(const basic_socket_acceptor&) = delete; basic_socket_acceptor& operator=(basic_socket_acceptor&&) = default; template<class _OtherProtocol> enable_if_t<is_convertible<_OtherProtocol, protocol_type>::value, basic_socket_acceptor&> operator=(basic_socket_acceptor<_OtherProtocol>&& __rhs) { __base::operator=(std::move(__rhs)); return this; } // basic_socket_acceptor operations: executor_type get_executor() noexcept { return __base::get_executor(); } native_handle_type native_handle() noexcept { return __base::native_handle(); } void open(const protocol_type& __protocol = protocol_type()) { open(__protocol, __throw_on_error{"basic_socket_acceptor::open"}); } void open(const protocol_type& __protocol, error_code& __ec) { __base::open(__protocol, __ec); } void assign(const protocol_type& __protocol, const native_handle_type& __native_acceptor) { assign(__protocol, __native_acceptor, __throw_on_error{"basic_socket_acceptor::assign"}); } void assign(const protocol_type& __protocol, const native_handle_type& __native_acceptor, error_code& __ec) { __base::assign(__protocol, __native_acceptor, __ec); } native_handle_type release() { return release(__throw_on_error{"basic_socket_acceptor::release"}); } native_handle_type release(error_code& __ec) { return __base::release(__ec); } _GLIBCXX_NODISCARD bool is_open() const noexcept { return __base::is_open(); } void close() { close(__throw_on_error{"basic_socket_acceptor::close"}); } void close(error_code& __ec) { __base::_close(__ec); } void cancel() { cancel(__throw_on_error{"basic_socket_acceptor::cancel"}); } void cancel(error_code& __ec) { __base::cancel(__ec); } template<typename _SettableSocketOption> void set_option(const _SettableSocketOption& __option) { set_option(__option, __throw_on_error{"basic_socket_acceptor::set_option"}); } template<typename _SettableSocketOption> void set_option(const _SettableSocketOption& __option, error_code& __ec) { __base::set_option(__option, __ec); } template<typename _GettableSocketOption> void get_option(_GettableSocketOption& __option) const { get_option(__option, __throw_on_error{"basic_socket_acceptor::get_option"}); } template<typename _GettableSocketOption> void get_option(_GettableSocketOption& __option, error_code& __ec) const { __base::get_option(__option, __ec); } template<typename _IoControlCommand> void io_control(_IoControlCommand& __command) { io_control(__command, __throw_on_error{"basic_socket_acceptor::io_control"}); } template<typename _IoControlCommand> void io_control(_IoControlCommand& __command, error_code& __ec) { __base::io_control(__command, __ec); } void non_blocking(bool __mode) { non_blocking(__mode, __throw_on_error{"basic_socket_acceptor::non_blocking"}); } void non_blocking(bool __mode, error_code& __ec) { __base::non_blocking(__mode, __ec); } bool non_blocking() const { return __base::non_blocking(); } void native_non_blocking(bool __mode) { native_non_blocking(__mode, __throw_on_error{ "basic_socket_acceptor::native_non_blocking"}); } void native_non_blocking(bool __mode, error_code& __ec) { __base::native_non_blocking(__mode, __ec); } bool native_non_blocking() const { return __base::native_non_blocking(); } void bind(const endpoint_type& __endpoint) { return bind(__endpoint, __throw_on_error{"basic_socket_acceptor::bind"}); } void bind(const endpoint_type& __endpoint, error_code& __ec) { __base::bind(__endpoint, __ec); } void listen(int __backlog = max_listen_connections) { return listen(__backlog, __throw_on_error{"basic_socket_acceptor::listen"}); } void listen(int __backlog, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H if (::listen(native_handle(), __backlog) == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } endpoint_type local_endpoint() const { return local_endpoint( __throw_on_error{"basic_socket_acceptor::local_endpoint"}); } endpoint_type local_endpoint(error_code& __ec) const { return __base::local_endpoint(__ec); } void enable_connection_aborted(bool __mode) { __base::_M_bits.enable_connection_aborted = __mode; } bool enable_connection_aborted() const { return __base::_M_bits.enable_connection_aborted; } socket_type accept() { return accept(__throw_on_error{"basic_socket_acceptor::accept"}); } socket_type accept(error_code& __ec) { return accept(get_executor().context(), __ec); } socket_type accept(io_context& __ctx) { return accept(__ctx, __throw_on_error{"basic_socket_acceptor::accept"}); } socket_type accept(io_context& __ctx, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H do { int __h = ::accept(native_handle(), nullptr, 0); if (__h != -1) { __ec.clear(); return socket_type{__ctx, _M_protocol, __h}; } } while (errno == ECONNABORTED && enable_connection_aborted()); __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return socket_type{__ctx}; } template<class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, socket_type)> async_accept(_CompletionToken&& __token) { return async_accept(get_executor().context(), std::forward<_CompletionToken>(__token)); } template<class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, socket_type)> async_accept(io_context& __ctx, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, socket_type)> __init{__token}; __ctx.async_wait(native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), __connabort = enable_connection_aborted(), __fd = native_handle(), __protocol = _M_protocol, &__ctx ] (error_code __ec) mutable { if (__ec) { __h(__ec, socket_type(__ctx)); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H do { int __newfd = ::accept(__fd, nullptr, 0); if (__newfd != -1) { __ec.clear(); __h(__ec, socket_type{__ctx, __protocol, __newfd}); return; } } while (errno == ECONNABORTED && __connabort); __ec.assign(errno, generic_category()); __h(__ec, socket_type(__ctx)); #else __h(std::make_error_code(errc::operation_not_supported), 0); #endif }); return __init.result.get(); } socket_type accept(endpoint_type& __endpoint) { return accept(get_executor().context(), __endpoint, __throw_on_error{"basic_socket_acceptor::accept"}); } socket_type accept(endpoint_type& __endpoint, error_code& __ec) { return accept(get_executor().context(), __endpoint, __ec); } socket_type accept(io_context& __ctx, endpoint_type& __endpoint) { return accept(__ctx, __endpoint, __throw_on_error{"basic_socket_acceptor::accept"}); } socket_type accept(io_context& __ctx, endpoint_type& __endpoint, error_code& __ec) { #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H do { socklen_t __len = __endpoint.capacity(); int __h = ::accept(native_handle(), (sockaddr)__endpoint.data(), &__len); if (__h != -1) { __endpoint.resize(__len); return socket_type{__ctx, _M_protocol, __h}; } } while (errno == ECONNABORTED && enable_connection_aborted()); __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif return socket_type{__ctx}; } template<class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, socket_type)> async_accept(endpoint_type& __endpoint, _CompletionToken&& __token) { return async_accept(get_executor().context(), __endpoint, std::forward<_CompletionToken>(__token)); } template<class _CompletionToken> __deduced_t<_CompletionToken, void(error_code, socket_type)> async_accept(io_context& __ctx, endpoint_type& __endpoint, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code, socket_type)> __init{__token}; __ctx.async_wait(native_handle(), (int) socket_base::wait_read, [__h = std::move(__init.completion_handler), __ep = std::move(__endpoint), __connabort = enable_connection_aborted(), __fd = native_handle(), &__ctx ] (error_code __ec) mutable { if (__ec) { __h(__ec, socket_type(__ctx)); return; } #ifdef _GLIBCXX_HAVE_SYS_SOCKET_H do { socklen_t __len = __ep.capacity(); int __newfd = ::accept(__fd, __ep.data, &__len); if (__newfd != -1) { __ep.resize(__len); auto __protocol = __ep.protocol(); __ec.clear(); __h(__ec, socket_type{__ctx, __protocol, __newfd}); return; } } while (errno == ECONNABORTED && __connabort); __ec.assign(errno, generic_category()); #else __ec = std::make_error_code(errc::operation_not_supported); #endif __h(__ec, socket_type(__ctx)); }); return __init.result.get(); } void wait(wait_type __w) { wait(__w, __throw_on_error{"basic_socket_acceptor::wait"}); } void wait(wait_type __w, error_code& __ec) { #ifdef _GLIBCXX_HAVE_POLL_H ::pollfd __fds; __fds.fd = native_handle(); __fds.events = __w; // __w \| POLLIN; if (::poll(&__fds, 1, -1) == -1) __ec.assign(errno, generic_category()); else __ec.clear(); #else __ec = std::make_error_code(errc::operation_not_supported); #endif } template<class _CompletionToken> __deduced_t<_CompletionToken, void(error_code)> async_wait(wait_type __w, _CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code)> __init{__token}; get_executor().context().async_wait( native_handle(), static_cast<int>(__w), [__h = std::move(__init.completion_handler)] (error_code __ec) mutable { __h(__ec); }); return __init.result.get(); } private: protocol_type _M_protocol; }; /// @} /** @brief Socket streams * @{ / template<typename _Protocol, typename _Clock, typename _WaitTraits> class basic_socket_streambuf : public basic_streambuf<char> { public: // types: using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; using clock_type = _Clock; using time_point = typename clock_type::time_point; using duration = typename clock_type::duration; using wait_traits_type = _WaitTraits; // construct / copy / destroy: basic_socket_streambuf() : _M_socket(_S_ctx()) { } explicit basic_socket_streambuf(basic_stream_socket<protocol_type> __s) : _M_socket(std::move(__s)) { } basic_socket_streambuf(const basic_socket_streambuf&) = delete; basic_socket_streambuf(basic_socket_streambuf&& __rhs); // TODO virtual ~basic_socket_streambuf(); // TODO basic_socket_streambuf& operator=(const basic_socket_streambuf&) = delete; basic_socket_streambuf& operator=(basic_socket_streambuf&& __rhs); // TODO // members: basic_socket_streambuf connect(const endpoint_type& __e); // TODO template<typename... _Args> basic_socket_streambuf* connect(_Args&&... ); // TODO basic_socket_streambuf* close(); // TODO basic_socket<protocol_type>& socket() { return _M_socket; } error_code error() const noexcept { return _M_ec; } time_point expiry() const { return _M_expiry; } void expires_at(const time_point& __t) { _M_expiry = __t; } void expires_after(const duration& __d) { expires_at(clock_type::now() + __d); } protected: // overridden virtual functions: // TODO virtual int_type underflow() override; virtual int_type pbackfail(int_type __c = traits_type::eof()) override; virtual int_type overflow(int_type __c = traits_type::eof()) override; virtual int sync() override; virtual streambuf* setbuf(char_type* __s, streamsize __n) override; private: static io_context& _S_ctx() { static io_context __ctx; return __ctx; } basic_stream_socket<protocol_type> _M_socket; error_code _M_ec; time_point _M_expiry{ time_point::max() }; }; template<typename _Protocol, class _Clock, typename _WaitTraits> class basic_socket_iostream : public basic_iostream<char> { using __streambuf_type = basic_socket_streambuf<_Protocol, _Clock, _WaitTraits>; public: // types: using protocol_type = _Protocol; using endpoint_type = typename protocol_type::endpoint; using clock_type = _Clock; using time_point = typename clock_type::time_point; using duration = typename clock_type::duration; using wait_traits_type = _WaitTraits; // construct / copy / destroy: // TODO base-from-member ? basic_socket_iostream() : basic_iostream(nullptr), _M_sb() { this->init(std::addressof(_M_sb)); this->setf(std::ios::unitbuf); } explicit basic_socket_iostream(basic_stream_socket<protocol_type> __s) : basic_iostream(nullptr), _M_sb(std::move(__s)) { this->init(std::addressof(_M_sb)); this->setf(std::ios::unitbuf); } basic_socket_iostream(const basic_socket_iostream&) = delete; basic_socket_iostream(basic_socket_iostream&& __rhs) : basic_iostream(nullptr), _M_sb(std::move(__rhs._M_sb)) // XXX ??? ^^^^^^^ { // XXX ??? this->init(std::addressof(_M_sb)); this->set_rbduf(std::addressof(_M_sb)); } template<typename... _Args> explicit basic_socket_iostream(_Args&&... __args) : basic_iostream(nullptr), _M_sb() { this->init(std::addressof(_M_sb)); this->setf(std::ios::unitbuf); connect(forward<_Args>(__args)...); } basic_socket_iostream& operator=(const basic_socket_iostream&) = delete; basic_socket_iostream& operator=(basic_socket_iostream&& __rhs); // TODO // members: template<typename... _Args> void connect(_Args&&... __args) { if (rdbuf()->connect(forward<_Args>(__args)...) == nullptr) this->setstate(failbit); } void close() { if (rdbuf()->close() == nullptr) this->setstate(failbit); } basic_socket_streambuf<protocol_type, clock_type, wait_traits_type>* rdbuf() const { return const_cast<__streambuf_type>(std::addressof(_M_sb)); } basic_socket<protocol_type>& socket() { return rdbuf()->socket(); } error_code error() const noexcept { return rdbuf()->error(); } time_point expiry() const { return rdbuf()->expiry(); } void expires_at(const time_point& __t) { rdbuf()->expires_at(__t); } void expires_after(const duration& __d) { rdbuf()->expires_after(__d); } private: __streambuf_type _M_sb; }; /// @} /* @brief synchronous connect operations * @{ / template<typename _Protocol, typename _EndpointSequence, typename _ConnectCondition> inline typename _Protocol::endpoint connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints, _ConnectCondition __c, error_code& __ec) { __ec.clear(); bool __found = false; for (auto& __ep : __endpoints) { if (__c(__ec, __ep)) { __found = true; __s.close(__ec); if (!__ec) __s.open(__ep.protocol(), __ec); if (!__ec) __s.connect(__ep, __ec); if (!__ec) return __ep; } } if (!__found) __ec = socket_errc::not_found; return typename _Protocol::endpoint{}; } template<typename _Protocol, typename _InputIterator, typename _ConnectCondition> inline _InputIterator connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last, _ConnectCondition __c, error_code& __ec) { __ec.clear(); bool __found = false; for (auto __i = __first; __i != __last; ++__i) { if (__c(__ec, __i)) { __found = true; __s.close(__ec); if (!__ec) __s.open(typename _Protocol::endpoint(__i).protocol(), __ec); if (!__ec) __s.connect(__i, __ec); if (!__ec) return __i; } } if (!__found) __ec = socket_errc::not_found; return __last; } template<typename _Protocol, typename _EndpointSequence, typename _ConnectCondition> inline typename _Protocol::endpoint connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints, _ConnectCondition __c) { return net::connect(__s, __endpoints, __c, __throw_on_error{"connect"}); } template<typename _Protocol, typename _InputIterator, typename _ConnectCondition> inline _InputIterator connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last, _ConnectCondition __c) { return net::connect(__s, __first, __last, __c, __throw_on_error{"connect"}); } template<typename _Protocol, typename _EndpointSequence> inline typename _Protocol::endpoint connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints) { return net::connect(__s, __endpoints, [](auto, auto){ return true; }, __throw_on_error{"connect"}); } template<typename _Protocol, typename _EndpointSequence> inline typename _Protocol::endpoint connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints, error_code& __ec) { return net::connect(__s, __endpoints, [](auto, auto){ return true; }, __ec); } template<typename _Protocol, typename _InputIterator> inline _InputIterator connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last) { return net::connect(__s, __first, __last, [](auto, auto){ return true; }, __throw_on_error{"connect"}); } template<typename _Protocol, typename _InputIterator> inline _InputIterator connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last, error_code& __ec) { return net::connect(__s, __first, __last, [](auto, auto){ return true; }, __ec); } /// @} /** @brief asynchronous connect operations * @{ */ template<typename _Protocol, typename _EndpointSequence, typename _ConnectCondition, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, typename _Protocol::endpoint)> async_connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints, _ConnectCondition __c, _CompletionToken&& __token); // TODO template<typename _Protocol, typename _EndpointSequence, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, typename _Protocol::endpoint)> async_connect(basic_socket<_Protocol>& __s, const _EndpointSequence& __endpoints, _CompletionToken&& __token) { return net::async_connect(__s, __endpoints, [](auto, auto){ return true; }, forward<_CompletionToken>(__token)); } template<typename _Protocol, typename _InputIterator, typename _ConnectCondition, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, _InputIterator)> async_connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last, _ConnectCondition __c, _CompletionToken&& __token); // TODO template<typename _Protocol, typename _InputIterator, typename _CompletionToken> inline __deduced_t<_CompletionToken, void(error_code, _InputIterator)> async_connect(basic_socket<_Protocol>& __s, _InputIterator __first, _InputIterator __last, _CompletionToken&& __token) { return net::async_connect(__s, __first, __last, [](auto, auto){ return true; }, forward<_CompletionToken>(__token)); } /// @} #endif // _GLIBCXX_HAVE_UNISTD_H /// @} } // namespace v1 } // namespace net } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_SOCKET	76.34 KB	2025-09-15 15:41
📄 source_location // <experimental/source_location> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/source_location * This is a TS C++ Library header. * @ingroup libfund-ts / #ifndef _GLIBCXX_EXPERIMENTAL_SRCLOC #define _GLIBCXX_EXPERIMENTAL_SRCLOC 1 #if __cplusplus >= 201402L #include <cstdint> namespace std { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_source_location 201505 struct source_location { #ifndef _GLIBCXX_USE_C99_STDINT_TR1 private: using uint_least32_t = unsigned; public: #endif // 14.1.2, source_location creation static constexpr source_location current(const char __file = __builtin_FILE(), const char* __func = __builtin_FUNCTION(), int __line = __builtin_LINE(), int __col = 0) noexcept { source_location __loc; __loc._M_file = __file; __loc._M_func = __func; __loc._M_line = __line; __loc._M_col = __col; return __loc; } constexpr source_location() noexcept : _M_file("unknown"), _M_func(_M_file), _M_line(0), _M_col(0) { } // 14.1.3, source_location field access constexpr uint_least32_t line() const noexcept { return _M_line; } constexpr uint_least32_t column() const noexcept { return _M_col; } constexpr const char* file_name() const noexcept { return _M_file; } constexpr const char* function_name() const noexcept { return _M_func; } private: const char* _M_file; const char* _M_func; uint_least32_t _M_line; uint_least32_t _M_col; }; } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_SRCLOC	2.71 KB	2025-09-15 15:41
📄 string // <experimental/string> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/string * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_STRING #define _GLIBCXX_EXPERIMENTAL_STRING 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <string> #include <algorithm> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _CharT, typename _Traits, typename _Alloc, typename _Predicate> inline void erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred) { __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); } template<typename _CharT, typename _Traits, typename _Alloc, typename _Up> inline void erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value) { __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); } #if _GLIBCXX_USE_CXX11_ABI namespace pmr { // basic_string using polymorphic allocator in namespace pmr template<typename _CharT, typename _Traits = char_traits<_CharT>> using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; // basic_string typedef names using polymorphic allocator in namespace // std::experimental::pmr typedef basic_string<char> string; #ifdef _GLIBCXX_USE_CHAR8_T typedef basic_string<char8_t> u8string; #endif typedef basic_string<char16_t> u16string; typedef basic_string<char32_t> u32string; typedef basic_string<wchar_t> wstring; } // namespace pmr #endif } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_STRING	2.85 KB	2025-09-15 15:41
📄 string_view // Components for manipulating non-owning sequences of characters -- C++ -- // Copyright (C) 2013-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/string_view * This is a TS C++ Library header. * @ingroup libfund-ts / // // N3762 basic_string_view library // #ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW #define _GLIBCXX_EXPERIMENTAL_STRING_VIEW 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <string> #include <limits> #include <bits/ranges_base.h> // enable_borrowed_range, enable_view #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { #define __cpp_lib_experimental_string_view 201411 /* * @class basic_string_view <experimental/string_view> * @brief A non-owning reference to a string. * * @ingroup strings * @ingroup sequences * @ingroup libfund-ts * * @tparam _CharT Type of character * @tparam _Traits Traits for character type, defaults to * char_traits<_CharT>. * * A basic_string_view looks like this: * * @code * _CharT* _M_str * size_t _M_len * @endcode / template<typename _CharT, typename _Traits = std::char_traits<_CharT>> class basic_string_view { public: // types using traits_type = _Traits; using value_type = _CharT; using pointer = _CharT; using const_pointer = const _CharT; using reference = _CharT&; using const_reference = const _CharT&; using const_iterator = const _CharT; using iterator = const_iterator; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using reverse_iterator = const_reverse_iterator; using size_type = size_t; using difference_type = ptrdiff_t; static constexpr size_type npos = size_type(-1); // [string.view.cons], construct/copy constexpr basic_string_view() noexcept : _M_len{0}, _M_str{nullptr} { } constexpr basic_string_view(const basic_string_view&) noexcept = default; template<typename _Allocator> basic_string_view(const basic_string<_CharT, _Traits, _Allocator>& __str) noexcept : _M_len{__str.length()}, _M_str{__str.data()} { } constexpr basic_string_view(const _CharT* __str) : _M_len{__str == nullptr ? 0 : traits_type::length(__str)}, _M_str{__str} { } constexpr basic_string_view(const _CharT* __str, size_type __len) : _M_len{__len}, _M_str{__str} { } basic_string_view& operator=(const basic_string_view&) noexcept = default; // [string.view.iterators], iterators constexpr const_iterator begin() const noexcept { return this->_M_str; } constexpr const_iterator end() const noexcept { return this->_M_str + this->_M_len; } constexpr const_iterator cbegin() const noexcept { return this->_M_str; } constexpr const_iterator cend() const noexcept { return this->_M_str + this->_M_len; } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->end()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->begin()); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } // [string.view.capacity], capacity constexpr size_type size() const noexcept { return this->_M_len; } constexpr size_type length() const noexcept { return _M_len; } constexpr size_type max_size() const noexcept { return (npos - sizeof(size_type) - sizeof(void)) / sizeof(value_type) / 4; } _GLIBCXX_NODISCARD constexpr bool empty() const noexcept { return this->_M_len == 0; } // [string.view.access], element access constexpr const _CharT& operator[](size_type __pos) const { __glibcxx_assert(__pos < this->_M_len); return (this->_M_str + __pos); } constexpr const _CharT& at(size_type __pos) const { return __pos < this->_M_len ? (this->_M_str + __pos) : (__throw_out_of_range_fmt(__N("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size()), this->_M_str); } constexpr const _CharT& front() const { __glibcxx_assert(this->_M_len > 0); return this->_M_str; } constexpr const _CharT& back() const { __glibcxx_assert(this->_M_len > 0); return (this->_M_str + this->_M_len - 1); } constexpr const _CharT* data() const noexcept { return this->_M_str; } // [string.view.modifiers], modifiers: constexpr void remove_prefix(size_type __n) { __glibcxx_assert(this->_M_len >= __n); this->_M_str += __n; this->_M_len -= __n; } constexpr void remove_suffix(size_type __n) { this->_M_len -= __n; } constexpr void swap(basic_string_view& __sv) noexcept { auto __tmp = this; this = __sv; __sv = __tmp; } // [string.view.ops], string operations: template<typename _Allocator> explicit operator basic_string<_CharT, _Traits, _Allocator>() const { return { this->_M_str, this->_M_len }; } template<typename _Allocator = std::allocator<_CharT>> basic_string<_CharT, _Traits, _Allocator> to_string(const _Allocator& __alloc = _Allocator()) const { return { this->_M_str, this->_M_len, __alloc }; } size_type copy(_CharT* __str, size_type __n, size_type __pos = 0) const { __glibcxx_requires_string_len(__str, __n); if (__pos > this->_M_len) __throw_out_of_range_fmt(__N("basic_string_view::copy: __pos " "(which is %zu) > this->size() " "(which is %zu)"), __pos, this->size()); size_type __rlen{std::min(__n, size_type{this->_M_len - __pos})}; for (auto __begin = this->_M_str + __pos, __end = __begin + __rlen; __begin != __end;) __str++ = __begin++; return __rlen; } // [string.view.ops], string operations: constexpr basic_string_view substr(size_type __pos = 0, size_type __n = npos) const { return __pos <= this->_M_len ? basic_string_view{this->_M_str + __pos, std::min(__n, size_type{this->_M_len - __pos})} : (__throw_out_of_range_fmt(__N("basic_string_view::substr: __pos " "(which is %zu) > this->size() " "(which is %zu)"), __pos, this->size()), basic_string_view{}); } constexpr int compare(basic_string_view __str) const noexcept { int __ret = traits_type::compare(this->_M_str, __str._M_str, std::min(this->_M_len, __str._M_len)); if (__ret == 0) __ret = _S_compare(this->_M_len, __str._M_len); return __ret; } constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str) const { return this->substr(__pos1, __n1).compare(__str); } constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str, size_type __pos2, size_type __n2) const { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); } constexpr int compare(const _CharT* __str) const noexcept { return this->compare(basic_string_view{__str}); } constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str) const { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str, size_type __n2) const { return this->substr(__pos1, __n1) .compare(basic_string_view(__str, __n2)); } constexpr size_type find(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find(__str._M_str, __pos, __str._M_len); } constexpr size_type find(_CharT __c, size_type __pos=0) const noexcept; constexpr size_type find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; constexpr size_type find(const _CharT* __str, size_type __pos=0) const noexcept { return this->find(__str, __pos, traits_type::length(__str)); } constexpr size_type rfind(basic_string_view __str, size_type __pos = npos) const noexcept { return this->rfind(__str._M_str, __pos, __str._M_len); } constexpr size_type rfind(_CharT __c, size_type __pos = npos) const noexcept; constexpr size_type rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; constexpr size_type rfind(const _CharT* __str, size_type __pos = npos) const noexcept { return this->rfind(__str, __pos, traits_type::length(__str)); } constexpr size_type find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept { return this->find(__c, __pos); } constexpr size_type find_first_of(const _CharT* __str, size_type __pos, size_type __n) const; constexpr size_type find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_last_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_last_of(_CharT __c, size_type __pos=npos) const noexcept { return this->rfind(__c, __pos); } constexpr size_type find_last_of(const _CharT* __str, size_type __pos, size_type __n) const; constexpr size_type find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_first_not_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const; constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_last_not_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const; constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str, __pos, traits_type::length(__str)); } private: static constexpr int _S_compare(size_type __n1, size_type __n2) noexcept { return difference_type(__n1 - __n2) > std::numeric_limits<int>::max() ? std::numeric_limits<int>::max() : difference_type(__n1 - __n2) < std::numeric_limits<int>::min() ? std::numeric_limits<int>::min() : static_cast<int>(difference_type(__n1 - __n2)); } size_t _M_len; const _CharT* _M_str; }; // [string.view.comparison], non-member basic_string_view comparison functions // Several of these functions use type_identity_t to create a non-deduced // context, so that only one argument participates in template argument // deduction and the other argument gets implicitly converted to the deduced // type (see N3766). template<typename _CharT, typename _Traits> constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template<typename _CharT, typename _Traits> constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template<typename _CharT, typename _Traits> constexpr bool operator==(__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template<typename _CharT, typename _Traits> constexpr bool operator!=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return !(__x == __y); } template<typename _CharT, typename _Traits> constexpr bool operator!=(basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return !(__x == __y); } template<typename _CharT, typename _Traits> constexpr bool operator!=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return !(__x == __y); } template<typename _CharT, typename _Traits> constexpr bool operator< (basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) < 0; } template<typename _CharT, typename _Traits> constexpr bool operator< (basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return __x.compare(__y) < 0; } template<typename _CharT, typename _Traits> constexpr bool operator< (__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) < 0; } template<typename _CharT, typename _Traits> constexpr bool operator> (basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) > 0; } template<typename _CharT, typename _Traits> constexpr bool operator> (basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return __x.compare(__y) > 0; } template<typename _CharT, typename _Traits> constexpr bool operator> (__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) > 0; } template<typename _CharT, typename _Traits> constexpr bool operator<=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) <= 0; } template<typename _CharT, typename _Traits> constexpr bool operator<=(basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return __x.compare(__y) <= 0; } template<typename _CharT, typename _Traits> constexpr bool operator<=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) <= 0; } template<typename _CharT, typename _Traits> constexpr bool operator>=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) >= 0; } template<typename _CharT, typename _Traits> constexpr bool operator>=(basic_string_view<_CharT, _Traits> __x, __type_identity_t<basic_string_view<_CharT, _Traits>> __y) noexcept { return __x.compare(__y) >= 0; } template<typename _CharT, typename _Traits> constexpr bool operator>=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) >= 0; } // [string.view.io], Inserters and extractors template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT,_Traits> __str) { return __ostream_insert(__os, __str.data(), __str.size()); } // basic_string_view typedef names using string_view = basic_string_view<char>; #ifdef _GLIBCXX_USE_WCHAR_T using wstring_view = basic_string_view<wchar_t>; #endif #ifdef _GLIBCXX_USE_CHAR8_T using u8string_view = basic_string_view<char8_t>; #endif using u16string_view = basic_string_view<char16_t>; using u32string_view = basic_string_view<char32_t>; } // namespace fundamentals_v1 } // namespace experimental // [string.view.hash], hash support: template<typename _Tp> struct hash; template<> struct hash<experimental::string_view> : public __hash_base<size_t, experimental::string_view> { size_t operator()(const experimental::string_view& __str) const noexcept { return std::_Hash_impl::hash(__str.data(), __str.length()); } }; template<> struct __is_fast_hash<hash<experimental::string_view>> : std::false_type { }; #ifdef _GLIBCXX_USE_WCHAR_T template<> struct hash<experimental::wstring_view> : public __hash_base<size_t, wstring> { size_t operator()(const experimental::wstring_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } }; template<> struct __is_fast_hash<hash<experimental::wstring_view>> : std::false_type { }; #endif #ifdef _GLIBCXX_USE_CHAR8_T template<> struct hash<experimental::u8string_view> : public __hash_base<size_t, experimental::u8string_view> { size_t operator()(const experimental::u8string_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length()); } }; template<> struct __is_fast_hash<hash<experimental::u8string_view>> : std::false_type { }; #endif template<> struct hash<experimental::u16string_view> : public __hash_base<size_t, experimental::u16string_view> { size_t operator()(const experimental::u16string_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char16_t)); } }; template<> struct __is_fast_hash<hash<experimental::u16string_view>> : std::false_type { }; template<> struct hash<experimental::u32string_view> : public __hash_base<size_t, experimental::u32string_view> { size_t operator()(const experimental::u32string_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char32_t)); } }; template<> struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type { }; namespace experimental { // I added these EMSR. inline namespace literals { inline namespace string_view_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" inline constexpr basic_string_view<char> operator""sv(const char* __str, size_t __len) noexcept { return basic_string_view<char>{__str, __len}; } #ifdef _GLIBCXX_USE_WCHAR_T inline constexpr basic_string_view<wchar_t> operator""sv(const wchar_t* __str, size_t __len) noexcept { return basic_string_view<wchar_t>{__str, __len}; } #endif #ifdef _GLIBCXX_USE_CHAR8_T inline constexpr basic_string_view<char8_t> operator""sv(const char8_t* __str, size_t __len) noexcept { return basic_string_view<char8_t>{__str, __len}; } #endif inline constexpr basic_string_view<char16_t> operator""sv(const char16_t* __str, size_t __len) noexcept { return basic_string_view<char16_t>{__str, __len}; } inline constexpr basic_string_view<char32_t> operator""sv(const char32_t* __str, size_t __len) noexcept { return basic_string_view<char32_t>{__str, __len}; } #pragma GCC diagnostic pop } // namespace string_literals } // namespace literals } // namespace experimental #if __cpp_lib_concepts namespace ranges { // Opt-in to borrowed_range concept template<typename _CharT, typename _Traits> inline constexpr bool enable_borrowed_range<experimental::basic_string_view<_CharT, _Traits>> = true; // Opt-in to view concept template<typename _CharT, typename _Traits> inline constexpr bool enable_view<experimental::basic_string_view<_CharT, _Traits>> = true; } #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #include <experimental/bits/string_view.tcc> #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW	21.99 KB	2025-09-15 15:41
📄 system_error // Variable Templates For system_error -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/system_error * This is a TS C++ Library header. * @ingroup libfund-ts */ // // N3932 Variable Templates For Type Traits (Revision 1) // #ifndef _GLIBCXX_EXPERIMENTAL_SYSTEM_ERROR #define _GLIBCXX_EXPERIMENTAL_SYSTEM_ERROR 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <system_error> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { // See C++14 19.5, System error support template <typename _Tp> constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; template <typename _Tp> constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; } // namespace fundamentals_v1 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_SYSTEM_ERROR	2 KB	2025-09-15 15:41
📄 timer // <experimental/timer> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/timer * This is a TS C++ Library header. * @ingroup networking-ts / #ifndef _GLIBCXX_EXPERIMENTAL_TIMER #define _GLIBCXX_EXPERIMENTAL_TIMER 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <chrono> #include <system_error> #include <thread> #include <experimental/netfwd> #include <experimental/io_context> #include <experimental/bits/net.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { namespace net { inline namespace v1 { /* @addtogroup networking-ts * @{ / template<typename _Clock> struct wait_traits { static typename _Clock::duration to_wait_duration(const typename _Clock::duration& __d) { return __d; } static typename _Clock::duration to_wait_duration(const typename _Clock::time_point& __t) { auto __now = _Clock::now(); auto __diff = __t - __now; if (__diff > _Clock::duration::max()) return _Clock::duration::max(); if (__diff < _Clock::duration::min()) return _Clock::duration::min(); return __diff; } }; template<typename _Clock, typename _WaitTraits> class basic_waitable_timer { public: // types: using executor_type = io_context::executor_type; using clock_type = _Clock; using duration = typename clock_type::duration; using time_point = typename clock_type::time_point; using traits_type = _WaitTraits; // construct / copy / destroy: explicit basic_waitable_timer(io_context& __ctx) : _M_ex(__ctx.get_executor()), _M_expiry() { } basic_waitable_timer(io_context& __ctx, const time_point& __t) : _M_ex(__ctx.get_executor()), _M_expiry(__t) { } basic_waitable_timer(io_context& __ctx, const duration& __d) : _M_ex(__ctx.get_executor()), _M_expiry(_Clock::now() + __d) { } basic_waitable_timer(const basic_waitable_timer&) = delete; basic_waitable_timer(basic_waitable_timer&& __rhs) : _M_ex(std::move(__rhs._M_ex)), _M_expiry(__rhs._M_expiry) { _M_key.swap(__rhs._M_key); __rhs._M_expiry = time_point{}; } ~basic_waitable_timer() { cancel(); } basic_waitable_timer& operator=(const basic_waitable_timer&) = delete; basic_waitable_timer& operator=(basic_waitable_timer&& __rhs) { if (this == std::addressof(__rhs)) return this; cancel(); _M_ex = std::move(__rhs._M_ex); _M_expiry = __rhs._M_expiry; __rhs._M_expiry = time_point{}; _M_key.swap(__rhs._M_key); return this; } // basic_waitable_timer operations: executor_type get_executor() noexcept { return _M_ex; } size_t cancel() { return _M_ex.context().cancel(this); } size_t cancel_one() { return _M_ex.context().cancel_one(this); } time_point expiry() const { return _M_expiry; } size_t expires_at(const time_point& __t) { size_t __cancelled = cancel(); _M_expiry = __t; return __cancelled; } size_t expires_after(const duration& __d) { return expires_at(_Clock::now() + __d); } void wait(); void wait(error_code& __ec); template<typename _CompletionToken> __deduced_t<_CompletionToken, void(error_code)> async_wait(_CompletionToken&& __token) { async_completion<_CompletionToken, void(error_code)> __init(__token); _M_ex.context().async_wait(this, std::move(__init.completion_handler)); return __init.result.get(); } private: executor_type _M_ex; time_point _M_expiry; struct _Key { }; // TODO move _M_expiry into here? unique_ptr<_Key> _M_key{new _Key}; friend class io_context; }; using system_timer = basic_waitable_timer<chrono::system_clock>; using steady_timer = basic_waitable_timer<chrono::steady_clock>; using high_resolution_timer = basic_waitable_timer<chrono::high_resolution_clock>; template<typename _Clock, typename _WaitTraits> void basic_waitable_timer<_Clock, _WaitTraits>::wait() { _M_ex.dispatch([this] { while (clock_type::now() < _M_expiry) this_thread::sleep_for(traits_type::to_wait_duration(_M_expiry)); }, allocator<void>{}); } template<typename _Clock, typename _WaitTraits> void basic_waitable_timer<_Clock, _WaitTraits>::wait(error_code&) { _M_ex.dispatch([this] { while (clock_type::now() < _M_expiry) this_thread::sleep_for(traits_type::to_wait_duration(_M_expiry)); }, allocator<void>{}); } /// @} } // namespace v1 } // namespace net } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_TIMER	5.66 KB	2025-09-15 15:41
📄 tuple // <experimental/tuple> -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/tuple * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_TUPLE #define _GLIBCXX_EXPERIMENTAL_TUPLE 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <tuple> #include <bits/invoke.h> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { // See C++14 20.4.2.5, tuple helper classes template <typename _Tp> constexpr size_t tuple_size_v = tuple_size<_Tp>::value; #define __cpp_lib_experimental_tuple 201402 template <typename _Fn, typename _Tuple, std::size_t... _Idx> constexpr decltype(auto) __apply_impl(_Fn&& __f, _Tuple&& __t, std::index_sequence<_Idx...>) { return std::__invoke(std::forward<_Fn>(__f), std::get<_Idx>(std::forward<_Tuple>(__t))...); } template <typename _Fn, typename _Tuple> constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t) { using _Indices = std::make_index_sequence<tuple_size_v<std::decay_t<_Tuple>>>; return experimental::__apply_impl(std::forward<_Fn>(__f), std::forward<_Tuple>(__t), _Indices{}); } } // namespace fundamentals_v1 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_TUPLE	2.41 KB	2025-09-15 15:41
📄 type_traits // Variable Templates For Type Traits -- C++ -- // Copyright (C) 2014-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/type_traits * This is a TS C++ Library header. * * This header defines variable templates for the C++14 type traits. * * Equivalent variable templates are defined in namespace `std` since C++17. * @see variable_templates * * @ingroup libfund-ts * @since C++14 / // // N3932 Variable Templates For Type Traits (Revision 1) // #ifndef _GLIBCXX_EXPERIMENTAL_TYPE_TRAITS #define _GLIBCXX_EXPERIMENTAL_TYPE_TRAITS 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <type_traits> #include <experimental/bits/lfts_config.h> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v1 { /* @defgroup lfts_variable_templates Variable template for type traits * @ingroup libfund-ts * @since Library Fundamentals TS v1. C++14. * @see variable_templates / /* @ingroup lfts_variable_templates * @{ / #define __cpp_lib_experimental_type_trait_variable_templates 201402 // See C++14 20.10.4.1, primary type categories template <typename _Tp> constexpr bool is_void_v = is_void<_Tp>::value; template <typename _Tp> constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; template <typename _Tp> constexpr bool is_integral_v = is_integral<_Tp>::value; template <typename _Tp> constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; template <typename _Tp> constexpr bool is_array_v = is_array<_Tp>::value; template <typename _Tp> constexpr bool is_pointer_v = is_pointer<_Tp>::value; template <typename _Tp> constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; template <typename _Tp> constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value; template <typename _Tp> constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; template <typename _Tp> constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; template <typename _Tp> constexpr bool is_enum_v = is_enum<_Tp>::value; template <typename _Tp> constexpr bool is_union_v = is_union<_Tp>::value; template <typename _Tp> constexpr bool is_class_v = is_class<_Tp>::value; template <typename _Tp> constexpr bool is_function_v = is_function<_Tp>::value; // See C++14 20.10.4.2, composite type categories template <typename _Tp> constexpr bool is_reference_v = is_reference<_Tp>::value; template <typename _Tp> constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; template <typename _Tp> constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; template <typename _Tp> constexpr bool is_object_v = is_object<_Tp>::value; template <typename _Tp> constexpr bool is_scalar_v = is_scalar<_Tp>::value; template <typename _Tp> constexpr bool is_compound_v = is_compound<_Tp>::value; template <typename _Tp> constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; // See C++14 20.10.4.3, type properties template <typename _Tp> constexpr bool is_const_v = is_const<_Tp>::value; template <typename _Tp> constexpr bool is_volatile_v = is_volatile<_Tp>::value; template <typename _Tp> constexpr bool is_trivial_v = is_trivial<_Tp>::value; template <typename _Tp> constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value; template <typename _Tp> constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template <typename _Tp> constexpr bool is_pod_v = is_pod<_Tp>::value; template <typename _Tp> constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; #pragma GCC diagnostic pop template <typename _Tp> constexpr bool is_empty_v = is_empty<_Tp>::value; template <typename _Tp> constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; template <typename _Tp> constexpr bool is_abstract_v = is_abstract<_Tp>::value; template <typename _Tp> constexpr bool is_final_v = is_final<_Tp>::value; template <typename _Tp> constexpr bool is_signed_v = is_signed<_Tp>::value; template <typename _Tp> constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; template <typename _Tp, typename... _Args> constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value; template <typename _Tp> constexpr bool is_default_constructible_v = is_default_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value; template <typename _Tp, typename _Up> constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; template <typename _Tp> constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_destructible_v = is_destructible<_Tp>::value; template <typename _Tp, typename... _Args> constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Tp, _Args...>::value; template <typename _Tp> constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value; template <typename _Tp, typename _Up> constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Tp, _Up>::value; template <typename _Tp> constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; template <typename _Tp, typename... _Args> constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value; template <typename _Tp> constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value; template <typename _Tp> constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value; template <typename _Tp, typename _Up> constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Tp, _Up>::value; template <typename _Tp> constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; template <typename _Tp> constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; template <typename _Tp> constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value; // See C++14 20.10.5, type property queries template <typename _Tp> constexpr size_t alignment_of_v = alignment_of<_Tp>::value; template <typename _Tp> constexpr size_t rank_v = rank<_Tp>::value; template <typename _Tp, unsigned _Idx = 0> constexpr size_t extent_v = extent<_Tp, _Idx>::value; // See C++14 20.10.6, type relations template <typename _Tp, typename _Up> constexpr bool is_same_v = is_same<_Tp, _Up>::value; template <typename _Base, typename _Derived> constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; template <typename _From, typename _To> constexpr bool is_convertible_v = is_convertible<_From, _To>::value; /// @} // 3.3.2, Other type transformations // invocation_type (still unimplemented) // raw_invocation_type (still unimplemented) // invocation_type_t (still unimplemented) // raw_invocation_type_t (still unimplemented) } // namespace fundamentals_v1 inline namespace fundamentals_v2 { /* * @defgroup lfts_detect Detection idiom * @ingroup libfund-ts * @since Library Fundamentals TS v2. C++14. / /* @ingroup lfts_detect * @{ / #define __cpp_lib_experimental_detect 201505 // [meta.detect] /// A metafunction that always yields void, used for detecting valid types. template<typename...> using void_t = void; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" /// @internal struct __nonesuchbase {}; struct nonesuch : private __nonesuchbase { ~nonesuch() = delete; nonesuch(nonesuch const&) = delete; void operator=(nonesuch const&) = delete; }; #pragma GCC diagnostic pop template<template<typename...> class _Op, typename... _Args> using is_detected = typename std::__detector<nonesuch, void, _Op, _Args...>::value_t; template<template<typename...> class _Op, typename... _Args> constexpr bool is_detected_v = is_detected<_Op, _Args...>::value; template<template<typename...> class _Op, typename... _Args> using detected_t = typename std::__detector<nonesuch, void, _Op, _Args...>::type; template<typename _Default, template<typename...> class _Op, typename... _Args> using detected_or = std::__detected_or<_Default, _Op, _Args...>; template<typename _Default, template<typename...> class _Op, typename... _Args> using detected_or_t = typename detected_or<_Default, _Op, _Args...>::type; template<typename _Expected, template<typename...> class _Op, typename... _Args> using is_detected_exact = is_same<_Expected, detected_t<_Op, _Args...>>; template<typename _Expected, template<typename...> class _Op, typename... _Args> constexpr bool is_detected_exact_v = is_detected_exact<_Expected, _Op, _Args...>::value; template<typename _To, template<typename...> class _Op, typename... _Args> using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, _To>; template<typename _To, template<typename...> class _Op, typename... _Args> constexpr bool is_detected_convertible_v = is_detected_convertible<_To, _Op, _Args...>::value; /// @} /* * @defgroup lfts_logical Logical operator traits * @ingroup libfund-ts * @since Library Fundamentals TS v2. C++14. / /* @ingroup lfts_logical * @{ */ #define __cpp_lib_experimental_logical_traits 201511 template<typename... _Bn> struct conjunction : __and_<_Bn...> { }; template<typename... _Bn> struct disjunction : __or_<_Bn...> { }; template<typename _Pp> struct negation : __not_<_Pp> { }; template<typename... _Bn> constexpr bool conjunction_v = conjunction<_Bn...>::value; template<typename... _Bn> constexpr bool disjunction_v = disjunction<_Bn...>::value; template<typename _Pp> constexpr bool negation_v = negation<_Pp>::value; /// @} } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cplusplus <= 201103L #endif // _GLIBCXX_EXPERIMENTAL_TYPE_TRAITS	11.78 KB	2025-09-15 15:41
📄 unordered_map // <experimental/unordered_map> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/unordered_map * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_UNORDERED_MAP #define _GLIBCXX_EXPERIMENTAL_UNORDERED_MAP 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <unordered_map> #include <bits/erase_if.h> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Key, typename _Tp, typename _Hash, typename _CPred, typename _Alloc, typename _Predicate> inline void erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } template<typename _Key, typename _Tp, typename _Hash, typename _CPred, typename _Alloc, typename _Predicate> inline void erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } namespace pmr { template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>> using unordered_map = std::unordered_map<_Key, _Tp, _Hash, _Pred, polymorphic_allocator<pair<const _Key, _Tp>>>; template<typename _Key, typename _Tp, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>> using unordered_multimap = std::unordered_multimap<_Key, _Tp, _Hash, _Pred, polymorphic_allocator<pair<const _Key, _Tp>>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_UNORDERED_MAP	2.78 KB	2025-09-15 15:41
📄 unordered_set // <experimental/unordered_set> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/unordered_set * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_UNORDERED_SET #define _GLIBCXX_EXPERIMENTAL_UNORDERED_SET 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <unordered_set> #include <bits/erase_if.h> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { template<typename _Key, typename _Hash, typename _CPred, typename _Alloc, typename _Predicate> inline void erase_if(unordered_set<_Key, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } template<typename _Key, typename _Hash, typename _CPred, typename _Alloc, typename _Predicate> inline void erase_if(unordered_multiset<_Key, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { std::__detail::__erase_nodes_if(__cont, __pred); } namespace pmr { template<typename _Key, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>> using unordered_set = std::unordered_set<_Key, _Hash, _Pred, polymorphic_allocator<_Key>>; template<typename _Key, typename _Hash = hash<_Key>, typename _Pred = equal_to<_Key>> using unordered_multiset = std::unordered_multiset<_Key, _Hash, _Pred, polymorphic_allocator<_Key>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_UNORDERED_SET	2.66 KB	2025-09-15 15:41
📄 utility // <experimental/utility> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/utility * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_UTILITY #define _GLIBCXX_EXPERIMENTAL_UTILITY 1 #if __cplusplus >= 201402L #include <utility> #include <bits/uses_allocator.h> #include <experimental/bits/lfts_config.h> namespace std { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { // 3.1.2, erased-type placeholder using erased_type = std::__erased_type; } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_UTILITY	1.69 KB	2025-09-15 15:41
📄 vector // <experimental/vector> -- C++ -- // Copyright (C) 2015-2021 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. /** @file experimental/vector * This is a TS C++ Library header. * @ingroup libfund-ts */ #ifndef _GLIBCXX_EXPERIMENTAL_VECTOR #define _GLIBCXX_EXPERIMENTAL_VECTOR 1 #pragma GCC system_header #if __cplusplus >= 201402L #include <vector> #include <algorithm> #include <experimental/memory_resource> namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace experimental { inline namespace fundamentals_v2 { #define __cpp_lib_experimental_erase_if 201411 template<typename _Tp, typename _Alloc, typename _Predicate> inline void erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred) { __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); } template<typename _Tp, typename _Alloc, typename _Up> inline void erase(vector<_Tp, _Alloc>& __cont, const _Up& __value) { __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); } namespace pmr { template<typename _Tp> using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>; } // namespace pmr } // namespace fundamentals_v2 } // namespace experimental _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_EXPERIMENTAL_VECTOR	2.3 KB	2025-09-15 15:41

Edit File:

Terminal