// <experimental/buffer> -*- C++ -*- // Copyright (C) 2015-2020 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: typedef const_buffer const_buffers_type; typedef mutable_buffer mutable_buffers_type; // 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