libstdc++-v3/include/experimental/buffer

   1 // <experimental/buffer> -*- C++ -*-
   2
   3 // Copyright (C) 2015-2021 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file experimental/buffer
  26  *  This is a TS C++ Library header.
  27  *  @ingroup networking-ts
  28  */
  29
  30 #ifndef _GLIBCXX_EXPERIMENTAL_BUFFER
  31 #define _GLIBCXX_EXPERIMENTAL_BUFFER 1
  32
  33 #pragma GCC system_header
  34
  35 #if __cplusplus >= 201402L
  36
  37 #include <array>
  38 #include <string>
  39 #include <system_error>
  40 #include <vector>
  41 #include <cstring>
  42 #include <experimental/string_view>
  43 #include <experimental/bits/net.h>
  44
  45 namespace std _GLIBCXX_VISIBILITY(default)
  46 {
  47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  48 namespace experimental
  49 {
  50 namespace net
  51 {
  52 inline namespace v1
  53 {
  54
  55   /** @addtogroup networking-ts
  56    *  @{
  57    */
  58
  59   enum class stream_errc {    // TODO decide values
  60     eof = 1,
  61     not_found = 2
  62   };
  63
  64   const error_category& stream_category() noexcept // TODO not inline
  65   {
  66     struct __cat : error_category
  67     {
  68       const char* name() const noexcept { return "stream"; }
  69
  70       std::string message(int __e) const
  71       {
  72         if (__e == (int)stream_errc::eof)
  73           return "EOF";
  74         else if (__e == (int)stream_errc::not_found)
  75           return "not found";
  76         return "stream";
  77       }
  78
  79       virtual void __message(int) { } // TODO dual ABI XXX
  80     };
  81     static __cat __c;
  82     return __c;
  83   }
  84
  85   inline error_code
  86   make_error_code(stream_errc __e) noexcept
  87   { return error_code(static_cast<int>(__e), stream_category()); }
  88
  89   inline error_condition
  90   make_error_condition(stream_errc __e) noexcept
  91   { return error_condition(static_cast<int>(__e), stream_category()); }
  92
  93   class mutable_buffer
  94   {
  95   public:
  96     // constructors:
  97     mutable_buffer() noexcept : _M_data(), _M_size() { }
  98
  99     mutable_buffer(void* __p, size_t __n) noexcept
 100     : _M_data(__p), _M_size(__n) { }
 101
 102     // members:
 103     void* data() const noexcept { return _M_data; }
 104     size_t size() const noexcept { return _M_size; }
 105
 106   private:
 107     void*       _M_data;
 108     size_t      _M_size;
 109   };
 110
 111   class const_buffer
 112   {
 113   public:
 114     // constructors:
 115     const_buffer() noexcept : _M_data(), _M_size() { }
 116
 117     const_buffer(const void* __p, size_t __n) noexcept
 118     : _M_data(__p), _M_size(__n) { }
 119
 120     const_buffer(const mutable_buffer& __b) noexcept
 121     : _M_data(__b.data()), _M_size(__b.size()) { }
 122
 123     // members:
 124     const void* data() const noexcept { return _M_data; }
 125     size_t size() const noexcept { return _M_size; }
 126
 127   private:
 128     const void* _M_data;
 129     size_t      _M_size;
 130   };
 131
 132
 133   /** @brief buffer sequence access
 134    *
 135    * Uniform access to types that meet the BufferSequence requirements.
 136    * @{
 137    */
 138
 139   inline const mutable_buffer*
 140   buffer_sequence_begin(const mutable_buffer& __b)
 141   { return std::addressof(__b); }
 142
 143   inline const const_buffer*
 144   buffer_sequence_begin(const const_buffer& __b)
 145   { return std::addressof(__b); }
 146
 147   inline const mutable_buffer*
 148   buffer_sequence_end(const mutable_buffer& __b)
 149   { return std::addressof(__b) + 1; }
 150
 151   inline const const_buffer*
 152   buffer_sequence_end(const const_buffer& __b)
 153   { return std::addressof(__b) + 1; }
 154
 155   template<typename _Cont>
 156     auto
 157     buffer_sequence_begin(_Cont& __c) -> decltype(__c.begin())
 158     { return __c.begin(); }
 159
 160   template<typename _Cont>
 161     auto
 162     buffer_sequence_begin(const _Cont& __c) -> decltype(__c.begin())
 163     { return __c.begin(); }
 164
 165   template<typename _Cont>
 166     auto
 167     buffer_sequence_end(_Cont& __c) -> decltype(__c.end())
 168     { return __c.end(); }
 169
 170   template<typename _Cont>
 171     auto
 172     buffer_sequence_end(const _Cont& __c) -> decltype(__c.end())
 173     { return __c.end(); }
 174
 175   /// @}
 176
 177
 178   /** @brief buffer type traits
 179    *
 180    * @{
 181    */
 182
 183   template<typename _Tp, typename _Buffer,
 184            typename _Begin
 185             = decltype(net::buffer_sequence_begin(std::declval<_Tp&>())),
 186            typename _End
 187             = decltype(net::buffer_sequence_end(std::declval<_Tp&>()))>
 188     using __buffer_sequence = enable_if_t<__and_<
 189       __is_value_constructible<_Tp>, is_same<_Begin, _End>,
 190       is_convertible<typename iterator_traits<_Begin>::value_type, _Buffer>
 191       >::value>;
 192
 193   template<typename _Tp, typename _Buffer, typename = void>
 194     struct __is_buffer_sequence : false_type
 195     { };
 196
 197   template<typename _Tp, typename _Buffer>
 198     struct __is_buffer_sequence<_Tp, _Buffer, __buffer_sequence<_Tp, _Buffer>>
 199     : true_type
 200     { };
 201
 202   template<typename _Tp>
 203     struct is_mutable_buffer_sequence
 204     : __is_buffer_sequence<_Tp, mutable_buffer>::type
 205     { };
 206
 207   template<typename _Tp>
 208     struct is_const_buffer_sequence
 209     : __is_buffer_sequence<_Tp, const_buffer>::type
 210     { };
 211
 212   template<typename _Tp>
 213     constexpr bool is_mutable_buffer_sequence_v
 214       = is_mutable_buffer_sequence<_Tp>::value;
 215
 216   template<typename _Tp>
 217     constexpr bool is_const_buffer_sequence_v
 218       = is_const_buffer_sequence<_Tp>::value;
 219
 220   template<typename _Tp, typename = void>
 221     struct __is_dynamic_buffer_impl : false_type
 222     { };
 223
 224   // Check DynamicBuffer requirements.
 225   template<typename _Tp, typename _Up = remove_const_t<_Tp>>
 226     auto
 227     __dynamic_buffer_reqs(_Up* __x = 0, const _Up* __x1 = 0, size_t __n = 0)
 228     -> enable_if_t<__and_<
 229       is_move_constructible<_Up>,
 230       is_const_buffer_sequence<typename _Tp::const_buffers_type>,
 231       is_mutable_buffer_sequence<typename _Tp::mutable_buffers_type>,
 232       is_same<decltype(__x1->size()), size_t>,
 233       is_same<decltype(__x1->max_size()), size_t>,
 234       is_same<decltype(__x1->capacity()), size_t>,
 235       is_same<decltype(__x1->data()), typename _Tp::const_buffers_type>,
 236       is_same<decltype(__x->prepare(__n)), typename _Tp::mutable_buffers_type>,
 237       is_void<decltype(__x->commit(__n), __x->consume(__n), void())>
 238     >::value>;
 239
 240   template<typename _Tp>
 241     struct __is_dynamic_buffer_impl<_Tp,
 242                                     decltype(__dynamic_buffer_reqs<_Tp>())>
 243     : true_type
 244     { };
 245
 246   template<typename _Tp>
 247     struct is_dynamic_buffer : __is_dynamic_buffer_impl<_Tp>::type
 248     { };
 249
 250   template<typename _Tp>
 251     constexpr bool is_dynamic_buffer_v = is_dynamic_buffer<_Tp>::value;
 252
 253   /// @}
 254
 255   /// buffer size
 256   template<typename _ConstBufferSequence>
 257     size_t
 258     buffer_size(const _ConstBufferSequence& __buffers) noexcept
 259     {
 260       size_t __total_size = 0;
 261       auto __i = net::buffer_sequence_begin(__buffers);
 262       const auto __end = net::buffer_sequence_end(__buffers);
 263       for (; __i != __end; ++__i)
 264         __total_size += const_buffer(*__i).size();
 265       return __total_size;
 266     }
 267
 268   template<typename _ConstBufferSequence>
 269     bool
 270     __buffer_empty(const _ConstBufferSequence& __buffers) noexcept
 271     {
 272       auto __i = net::buffer_sequence_begin(__buffers);
 273       const auto __end = net::buffer_sequence_end(__buffers);
 274       for (; __i != __end; ++__i)
 275         if (const_buffer(*__i).size() != 0)
 276           return false;
 277       return true;
 278     }
 279
 280   // buffer copy:
 281
 282   template<typename _MutableBufferSequence, typename _ConstBufferSequence>
 283     size_t
 284     buffer_copy(const _MutableBufferSequence& __dest,
 285                 const _ConstBufferSequence& __source,
 286                 size_t __max_size) noexcept
 287     {
 288       size_t __total_size = 0;
 289       auto __to_i = net::buffer_sequence_begin(__dest);
 290       const auto __to_end = net::buffer_sequence_end(__dest);
 291       auto __from_i = net::buffer_sequence_begin(__source);
 292       const auto __from_end = net::buffer_sequence_end(__source);
 293       mutable_buffer __to;
 294       const_buffer __from;
 295       while (((__from_i != __from_end && __to_i != __to_end)
 296             || (__from.size() && __to.size()))
 297           && __total_size < __max_size)
 298         {
 299           if (__from.size() == 0)
 300             __from = const_buffer{*__from_i++};
 301           if (__to.size() == 0)
 302             __to = mutable_buffer{*__to_i++};
 303
 304           size_t __n = std::min(__from.size(), __to.size());
 305           __n = std::min(__n, __max_size - __total_size);
 306           std::memcpy(__to.data(), __from.data(), __n);
 307           __from = { (const char*)__from.data() + __n, __from.size() - __n };
 308           __to = { (char*)__to.data() + __n, __to.size() - __n };
 309           __total_size += __n;
 310         }
 311       return __total_size;
 312     }
 313
 314   template<typename _MutableBufferSequence, typename _ConstBufferSequence>
 315     inline size_t
 316     buffer_copy(const _MutableBufferSequence& __dest,
 317                 const _ConstBufferSequence& __source) noexcept
 318     { return net::buffer_copy(__dest, __source, size_t(-1)); }
 319
 320
 321   // buffer arithmetic:
 322
 323   inline mutable_buffer
 324   operator+(const mutable_buffer& __b, size_t __n) noexcept
 325   {
 326     if (__n > __b.size())
 327       __n = __b.size();
 328     return { static_cast<char*>(__b.data()) + __n, __b.size() - __n };
 329   }
 330
 331   inline mutable_buffer
 332   operator+(size_t __n, const mutable_buffer& __b) noexcept
 333   { return __b + __n; }
 334
 335   inline const_buffer
 336   operator+(const const_buffer& __b, size_t __n) noexcept
 337   {
 338     if (__n > __b.size())
 339       __n = __b.size();
 340     return { static_cast<const char*>(__b.data()) + __n, __b.size() - __n };
 341   }
 342
 343   inline const_buffer
 344   operator+(size_t __n, const const_buffer& __b) noexcept
 345   { return __b + __n; }
 346
 347   // buffer creation:
 348
 349   inline mutable_buffer
 350   buffer(void* __p, size_t __n) noexcept
 351   { return { __p, __n }; }
 352
 353   inline const_buffer
 354   buffer(const void* __p, size_t __n) noexcept
 355   { return { __p, __n }; }
 356
 357   inline mutable_buffer
 358   buffer(const mutable_buffer& __b) noexcept
 359   { return __b; }
 360
 361   inline mutable_buffer
 362   buffer(const mutable_buffer& __b, size_t __n) noexcept
 363   { return { __b.data(), std::min(__b.size(), __n) }; }
 364
 365   inline const_buffer
 366   buffer(const const_buffer& __b) noexcept
 367   { return __b; }
 368
 369   inline const_buffer
 370   buffer(const const_buffer& __b, size_t __n) noexcept
 371   { return { __b.data(), std::min(__b.size(), __n) }; }
 372
 373   template<typename _Tp>
 374     inline mutable_buffer
 375     __to_mbuf(_Tp* __data, size_t __n)
 376     { return { __n ? __data : nullptr, __n * sizeof(_Tp) }; }
 377
 378   template<typename _Tp>
 379     inline const_buffer
 380     __to_cbuf(const _Tp* __data, size_t __n)
 381     { return { __n ? __data : nullptr, __n * sizeof(_Tp) }; }
 382
 383   template<typename _Tp, size_t _Nm>
 384     inline mutable_buffer
 385     buffer(_Tp (&__data)[_Nm]) noexcept
 386     { return net::__to_mbuf(__data, _Nm); }
 387
 388   template<typename _Tp, size_t _Nm>
 389     inline const_buffer
 390     buffer(const _Tp (&__data)[_Nm]) noexcept
 391     { return net::__to_cbuf(__data, _Nm); }
 392
 393   template<typename _Tp, size_t _Nm>
 394     inline mutable_buffer
 395     buffer(array<_Tp, _Nm>& __data) noexcept
 396     { return net::__to_mbuf(__data.data(), _Nm); }
 397
 398   template<typename _Tp, size_t _Nm>
 399     inline const_buffer
 400     buffer(array<const _Tp, _Nm>& __data) noexcept
 401     { return net::__to_cbuf(__data.data(), __data.size()); }
 402
 403   template<typename _Tp, size_t _Nm>
 404     inline const_buffer
 405     buffer(const array<_Tp, _Nm>& __data) noexcept
 406     { return net::__to_cbuf(__data.data(), __data.size()); }
 407
 408   template<typename _Tp, typename _Allocator>
 409     inline mutable_buffer
 410     buffer(vector<_Tp, _Allocator>& __data) noexcept
 411     { return net::__to_mbuf(__data.data(), __data.size()); }
 412
 413   template<typename _Tp, typename _Allocator>
 414     inline const_buffer
 415     buffer(const vector<_Tp, _Allocator>& __data) noexcept
 416     { return net::__to_cbuf(__data.data(), __data.size()); }
 417
 418   template<typename _CharT, typename _Traits, typename _Allocator>
 419     inline mutable_buffer
 420     buffer(basic_string<_CharT, _Traits, _Allocator>& __data) noexcept
 421     { return net::__to_mbuf(&__data.front(), __data.size()); }
 422
 423   template<typename _CharT, typename _Traits, typename _Allocator>
 424     inline const_buffer
 425     buffer(const basic_string<_CharT, _Traits, _Allocator>& __data) noexcept
 426     { return net::__to_cbuf(&__data.front(), __data.size()); }
 427
 428   template<typename _CharT, typename _Traits>
 429     inline const_buffer
 430     buffer(basic_string_view<_CharT, _Traits> __data) noexcept
 431     { return net::__to_cbuf(__data.data(), __data.size()); }
 432
 433   template<typename _Tp, size_t _Nm>
 434     inline mutable_buffer
 435     buffer(_Tp (&__data)[_Nm], size_t __n) noexcept
 436     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 437
 438   template<typename _Tp, size_t _Nm>
 439     inline const_buffer
 440     buffer(const _Tp (&__data)[_Nm], size_t __n) noexcept
 441     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 442
 443   template<typename _Tp, size_t _Nm>
 444     inline mutable_buffer
 445     buffer(array<_Tp, _Nm>& __data, size_t __n) noexcept
 446     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 447
 448   template<typename _Tp, size_t _Nm>
 449     inline const_buffer
 450     buffer(array<const _Tp, _Nm>& __data, size_t __n) noexcept
 451     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 452
 453   template<typename _Tp, size_t _Nm>
 454     inline const_buffer
 455     buffer(const array<_Tp, _Nm>& __data, size_t __n) noexcept
 456     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 457
 458   template<typename _Tp, typename _Allocator>
 459     inline mutable_buffer
 460     buffer(vector<_Tp, _Allocator>& __data, size_t __n) noexcept
 461     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 462
 463   template<typename _Tp, typename _Allocator>
 464     inline const_buffer
 465     buffer(const vector<_Tp, _Allocator>& __data, size_t __n) noexcept
 466     { return buffer(net::buffer(__data), __n * sizeof(_Tp)); }
 467
 468   template<typename _CharT, typename _Traits, typename _Allocator>
 469     inline mutable_buffer
 470     buffer(basic_string<_CharT, _Traits, _Allocator>& __data,
 471            size_t __n) noexcept
 472     { return buffer(net::buffer(__data), __n * sizeof(_CharT)); }
 473
 474   template<typename _CharT, typename _Traits, typename _Allocator>
 475     inline const_buffer
 476     buffer(const basic_string<_CharT, _Traits, _Allocator>& __data,
 477            size_t __n) noexcept
 478     { return buffer(net::buffer(__data), __n * sizeof(_CharT)); }
 479
 480   template<typename _CharT, typename _Traits>
 481     inline const_buffer
 482     buffer(basic_string_view<_CharT, _Traits> __data, size_t __n) noexcept
 483     { return buffer(net::buffer(__data), __n * sizeof(_CharT)); }
 484
 485
 486   template<typename _Sequence>
 487     class __dynamic_buffer_base
 488     {
 489     public:
 490       // types:
 491       using const_buffers_type = const_buffer;
 492       using mutable_buffers_type = mutable_buffer;
 493
 494       // constructors:
 495       explicit
 496       __dynamic_buffer_base(_Sequence& __seq) noexcept
 497       : _M_seq(__seq), _M_size(__seq.size()), _M_max_size(__seq.max_size())
 498       { }
 499
 500       __dynamic_buffer_base(_Sequence& __seq, size_t __maximum_size) noexcept
 501       : _M_seq(__seq), _M_size(__seq.size()), _M_max_size(__maximum_size)
 502       { __glibcxx_assert(__seq.size() <= __maximum_size); }
 503
 504       __dynamic_buffer_base(__dynamic_buffer_base&&) = default;
 505
 506       // members:
 507       size_t size() const noexcept { return _M_size; }
 508       size_t max_size() const noexcept { return _M_max_size; }
 509       size_t capacity() const noexcept { return _M_seq.capacity(); }
 510
 511       const_buffers_type
 512       data() const noexcept
 513       { return net::buffer(_M_seq, _M_size); }
 514
 515       mutable_buffers_type
 516       prepare(size_t __n)
 517       {
 518         if ((_M_size + __n) > _M_max_size)
 519           __throw_length_error("dynamic_vector_buffer::prepare");
 520
 521         _M_seq.resize(_M_size + __n);
 522         return buffer(net::buffer(_M_seq) + _M_size, __n);
 523       }
 524
 525       void
 526       commit(size_t __n)
 527       {
 528         _M_size += std::min(__n, _M_seq.size() - _M_size);
 529         _M_seq.resize(_M_size);
 530       }
 531
 532       void
 533       consume(size_t __n)
 534       {
 535         size_t __m = std::min(__n, _M_size);
 536         _M_seq.erase(_M_seq.begin(), _M_seq.begin() + __m);
 537         _M_size -= __m;
 538       }
 539
 540     private:
 541       _Sequence&        _M_seq;
 542       size_t            _M_size;
 543       const size_t      _M_max_size;
 544     };
 545
 546   template<typename _Tp, typename _Allocator>
 547     class dynamic_vector_buffer
 548     : public __dynamic_buffer_base<vector<_Tp, _Allocator>>
 549     {
 550     public:
 551       using __dynamic_buffer_base<vector<_Tp, _Allocator>>::__dynamic_buffer_base;
 552     };
 553
 554   template<typename _CharT, typename _Traits, typename _Allocator>
 555     class dynamic_string_buffer
 556     : public __dynamic_buffer_base<basic_string<_CharT, _Traits, _Allocator>>
 557     {
 558     public:
 559       using __dynamic_buffer_base<basic_string<_CharT, _Traits, _Allocator>>::
 560         __dynamic_buffer_base;
 561     };
 562
 563   // dynamic buffer creation:
 564
 565   template<typename _Tp, typename _Allocator>
 566     inline dynamic_vector_buffer<_Tp, _Allocator>
 567     dynamic_buffer(vector<_Tp, _Allocator>& __vec) noexcept
 568     { return dynamic_vector_buffer<_Tp, _Allocator>{__vec}; }
 569
 570   template<typename _Tp, typename _Allocator>
 571     inline dynamic_vector_buffer<_Tp, _Allocator>
 572     dynamic_buffer(vector<_Tp, _Allocator>& __vec, size_t __n) noexcept
 573     { return {__vec, __n}; }
 574
 575   template<typename _CharT, typename _Traits, typename _Allocator>
 576     inline dynamic_string_buffer<_CharT, _Traits, _Allocator>
 577     dynamic_buffer(basic_string<_CharT, _Traits, _Allocator>& __str) noexcept
 578     { return dynamic_string_buffer<_CharT, _Traits, _Allocator>{__str}; }
 579
 580   template<typename _CharT, typename _Traits, typename _Allocator>
 581     inline dynamic_string_buffer<_CharT, _Traits, _Allocator>
 582     dynamic_buffer(basic_string<_CharT, _Traits, _Allocator>& __str,
 583                    size_t __n) noexcept
 584     { return {__str, __n}; }
 585
 586   class transfer_all
 587   {
 588   public:
 589     size_t operator()(const error_code& __ec, size_t) const
 590     { return !__ec ? 1500 : 0; }
 591   };
 592
 593   class transfer_at_least
 594   {
 595   public:
 596     explicit transfer_at_least(size_t __m) : _M_minimum(__m) { }
 597
 598     size_t operator()(const error_code& __ec, size_t __n) const
 599     { return !__ec  && __n < _M_minimum ? _M_minimum - __n : 0; }
 600
 601   private:
 602     size_t _M_minimum;
 603   };
 604
 605   class transfer_exactly
 606   {
 607   public:
 608     explicit transfer_exactly(size_t __e) : _M_exact(__e) { }
 609
 610     size_t operator()(const error_code& __ec, size_t __n) const
 611     {
 612       size_t _Nm = -1;
 613       return !__ec  && __n < _M_exact ? std::min(_M_exact - __n, _Nm) : 0;
 614     }
 615
 616   private:
 617     size_t _M_exact;
 618   };
 619
 620   /** @brief synchronous read operations
 621    * @{
 622    */
 623
 624   template<typename _SyncReadStream, typename _MutableBufferSequence,
 625            typename _CompletionCondition>
 626     enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value,
 627                 size_t>
 628     read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers,
 629          _CompletionCondition __completion_condition, error_code& __ec)
 630     {
 631       __ec.clear();
 632       auto __i = net::buffer_sequence_begin(__buffers);
 633       auto __end = net::buffer_sequence_end(__buffers);
 634       mutable_buffer __to;
 635       size_t __total = 0;
 636       size_t __n;
 637       while ((__n = __completion_condition(__ec, __total))
 638           && (__i != __end || __to.size()))
 639         {
 640           if (__to.size() == 0)
 641             __to = mutable_buffer(*__i++);
 642           __n = __stream.read_some(buffer(__to, __n), __ec);
 643           __to = __to + __n;
 644           __total += __n;
 645         }
 646       return __total;
 647     }
 648
 649   template<typename _SyncReadStream, typename _MutableBufferSequence>
 650     inline
 651     enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value,
 652                 size_t>
 653     read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers)
 654     {
 655       error_code __ec;
 656       return net::read(__stream, __buffers, transfer_all{}, __ec);
 657     }
 658
 659   template<typename _SyncReadStream, typename _MutableBufferSequence>
 660     inline
 661     enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value,
 662                 size_t>
 663     read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers,
 664          error_code& __ec)
 665     { return net::read(__stream, __buffers, transfer_all{}, __ec); }
 666
 667   template<typename _SyncReadStream, typename _MutableBufferSequence,
 668            typename _CompletionCondition>
 669     inline
 670     enable_if_t<is_mutable_buffer_sequence<_MutableBufferSequence>::value,
 671                 size_t>
 672     read(_SyncReadStream& __stream, const _MutableBufferSequence& __buffers,
 673          _CompletionCondition __completion_condition)
 674     {
 675       error_code __ec;
 676       return net::read(__stream, __buffers, __completion_condition, __ec);
 677     }
 678
 679
 680   template<typename _SyncReadStream, typename _DynamicBuffer,
 681            typename _CompletionCondition>
 682     enable_if_t<is_dynamic_buffer<decay_t<_DynamicBuffer>>::value, size_t>
 683     read(_SyncReadStream& __stream, _DynamicBuffer&& __b,
 684          _CompletionCondition __completion_condition, error_code& __ec)
 685     {
 686       const size_t __limit = 64;
 687       __ec.clear();
 688       size_t __cap = std::max(__b.capacity() - __b.size(), __limit);
 689       size_t __total = 0;
 690       size_t __n;
 691       while ((__n = __completion_condition(__ec, __total))
 692           && __b.size() != __b.max_size())
 693         {
 694           __n =  std::min(__n, __b.max_size() - __b.size());
 695           size_t __cap = std::max(__b.capacity() - __b.size(), __limit);
 696           mutable_buffer __to = __b.prepare(std::min(__cap, __n));
 697           __n = __stream.read_some(__to, __ec);
 698           __to = __to + __n;
 699           __total += __n;
 700           __b.commit(__n);
 701         }
 702       return __total;
 703     }
 704
 705   template<typename _SyncReadStream, typename _DynamicBuffer>
 706     inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t>
 707     read(_SyncReadStream& __stream, _DynamicBuffer&& __b)
 708     {
 709       error_code __ec;
 710       return net::read(__stream, __b, transfer_all{}, __ec);
 711     }
 712
 713   template<typename _SyncReadStream, typename _DynamicBuffer>
 714     inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t>
 715     read(_SyncReadStream& __stream, _DynamicBuffer&& __b, error_code& __ec)
 716     {
 717       return net::read(__stream, __b, transfer_all{}, __ec);
 718     }
 719
 720   template<typename _SyncReadStream, typename _DynamicBuffer,
 721            typename _CompletionCondition>
 722     inline enable_if_t<is_dynamic_buffer<_DynamicBuffer>::value, size_t>
 723     read(_SyncReadStream& __stream, _DynamicBuffer&& __b,
 724          _CompletionCondition __completion_condition)
 725     {
 726       error_code __ec;
 727       return net::read(__stream, __b, __completion_condition, __ec);
 728     }
 729
 730   /// @}
 731
 732   /** @brief asynchronous read operations
 733    * @{
 734    */
 735
 736   template<typename _AsyncReadStream, typename _MutableBufferSequence,
 737            typename _CompletionCondition, typename _CompletionToken>
 738     __deduced_t<_CompletionToken, void(error_code, size_t)>
 739     async_read(_AsyncReadStream& __stream,
 740                const _MutableBufferSequence& __buffers,
 741                _CompletionCondition __completion_condition,
 742                _CompletionToken&& __token)
 743     {
 744       error_code __ec;
 745     }
 746
 747   template<typename _AsyncReadStream, typename _MutableBufferSequence,
 748            typename _CompletionToken>
 749     inline __deduced_t<_CompletionToken, void(error_code, size_t)>
 750     async_read(_AsyncReadStream& __stream,
 751                const _MutableBufferSequence& __buffers,
 752                _CompletionToken&& __token)
 753     {
 754       return net::async_read(__stream, __buffers, transfer_all{},
 755                              std::forward<_CompletionToken>(__token));
 756     }
 757
 758   template<typename _AsyncReadStream, typename _DynamicBuffer,
 759            typename _CompletionCondition, typename _CompletionToken>
 760     __deduced_t<_CompletionToken, void(error_code, size_t)>
 761     async_read(_AsyncReadStream& __stream, _DynamicBuffer&& __b,
 762                _CompletionCondition __completion_condition,
 763                _CompletionToken&& __token)
 764     {
 765       error_code __ec;
 766     }
 767
 768   template<typename _AsyncReadStream, typename _DynamicBuffer,
 769            typename _CompletionToken>
 770     inline __deduced_t<_CompletionToken, void(error_code, size_t)>
 771     async_read(_AsyncReadStream& __stream, _DynamicBuffer&& __b,
 772                _CompletionToken&& __token)
 773     {
 774       return net::async_read(__stream, __b, transfer_all{},
 775                              std::forward<_CompletionToken>(__token));
 776     }
 777
 778   /// @}
 779
 780 #if 0
 781   /** @brief synchronous write operations:
 782    * @{
 783    */
 784
 785   template<typename _SyncWriteStream, typename _ConstBufferSequence>
 786     size_t write(_SyncWriteStream& __stream,
 787                  const _ConstBufferSequence& __buffers);
 788   template<typename _SyncWriteStream, typename _ConstBufferSequence>
 789     size_t write(_SyncWriteStream& __stream,
 790                  const _ConstBufferSequence& __buffers, error_code& __ec);
 791   template<typename _SyncWriteStream, typename _ConstBufferSequence,
 792     typename _CompletionCondition>
 793       size_t write(_SyncWriteStream& __stream,
 794                    const _ConstBufferSequence& __buffers,
 795                    _CompletionCondition __completion_condition);
 796   template<typename _SyncWriteStream, typename _ConstBufferSequence,
 797     typename _CompletionCondition>
 798       size_t write(_SyncWriteStream& __stream,
 799                    const _ConstBufferSequence& __buffers,
 800                    _CompletionCondition __completion_condition,
 801                    error_code& __ec);
 802
 803   template<typename _SyncWriteStream, typename _DynamicBuffer>
 804     size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b);
 805   template<typename _SyncWriteStream, typename _DynamicBuffer>
 806     size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b, error_code& __ec);
 807   template<typename _SyncWriteStream, typename _DynamicBuffer, typename _CompletionCondition>
 808     size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b,
 809                  _CompletionCondition __completion_condition);
 810   template<typename _SyncWriteStream, typename _DynamicBuffer, typename _CompletionCondition>
 811     size_t write(_SyncWriteStream& __stream, _DynamicBuffer&& __b,
 812                  _CompletionCondition __completion_condition, error_code& __ec);
 813
 814   /// @}
 815
 816   /** @brief asynchronous write operations
 817    * @{
 818    */
 819
 820   template<typename _AsyncWriteStream, typename _ConstBufferSequence,
 821     typename _CompletionToken>
 822       DEDUCED async_write(_AsyncWriteStream& __stream,
 823                        const _ConstBufferSequence& __buffers,
 824                        _CompletionToken&& __token);
 825   template<typename _AsyncWriteStream, typename _ConstBufferSequence,
 826     typename _CompletionCondition, typename _CompletionToken>
 827       DEDUCED async_write(_AsyncWriteStream& __stream,
 828                        const _ConstBufferSequence& __buffers,
 829                        _CompletionCondition __completion_condition,
 830                        _CompletionToken&& __token);
 831
 832   template<typename _AsyncWriteStream, typename _DynamicBuffer, typename _CompletionToken>
 833     DEDUCED async_write(_AsyncWriteStream& __stream,
 834                      _DynamicBuffer&& __b, _CompletionToken&& __token);
 835   template<typename _AsyncWriteStream, typename _DynamicBuffer,
 836     typename _CompletionCondition, typename _CompletionToken>
 837       DEDUCED async_write(_AsyncWriteStream& __stream,
 838                        _DynamicBuffer&& __b,
 839                        _CompletionCondition __completion_condition,
 840                        _CompletionToken&& __token);
 841
 842   /// @}
 843
 844   /** @brief synchronous delimited read operations
 845    * @{
 846    */
 847
 848   template<typename _SyncReadStream, typename _DynamicBuffer>
 849     size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, char __delim);
 850   template<typename _SyncReadStream, typename _DynamicBuffer>
 851     size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b,
 852                       char __delim, error_code& __ec);
 853   template<typename _SyncReadStream, typename _DynamicBuffer>
 854     size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b, string_view __delim);
 855   template<typename _SyncReadStream, typename _DynamicBuffer>
 856     size_t read_until(_SyncReadStream& __s, _DynamicBuffer&& __b,
 857                       string_view __delim, error_code& __ec);
 858
 859   /// @}
 860
 861   /** @brief asynchronous delimited read operations
 862    * @{
 863    */
 864
 865   template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionToken>
 866     DEDUCED async_read_until(_AsyncReadStream& __s,
 867                           _DynamicBuffer&& __b, char __delim,
 868                           _CompletionToken&& __token);
 869   template<typename _AsyncReadStream, typename _DynamicBuffer, typename _CompletionToken>
 870     DEDUCED async_read_until(_AsyncReadStream& __s,
 871                           _DynamicBuffer&& __b, string_view __delim,
 872                           _CompletionToken&& __token);
 873
 874   /// @}
 875
 876 #endif
 877   /// @}
 878
 879 } // namespace v1
 880 } // namespace net
 881 } // namespace experimental
 882
 883   template<>
 884     struct is_error_code_enum<experimental::net::v1::stream_errc>
 885     : public true_type {};
 886
 887 _GLIBCXX_END_NAMESPACE_VERSION
 888 } // namespace std
 889
 890 #endif // C++14
 891
 892 #endif // _GLIBCXX_EXPERIMENTAL_BUFFER