algos use dynamic_buffer_view

klemens-morgenstern · klemens-morgenstern · commit b4f2126a83bb · 2023-07-22T13:18:41.000+08:00
diff --git a/include/boost/async/io/copy.hpp b/include/boost/async/io/copy.hpp
@@ -10,7 +10,7 @@
 
 #include <boost/async/io/stream.hpp>
 #include <boost/async/promise.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
+#include <boost/async/io/buffers/dynamic_buffer_view.hpp>
 
 namespace boost::async::io
 {
@@ -19,16 +19,9 @@ BOOST_ASYNC_DECL promise<std::pair<transfer_result, transfer_result>>
 copy(stream & source, stream & sink);
 
 BOOST_ASYNC_DECL promise<std::pair<transfer_result, transfer_result>>
-copy(stream & source, stream & sink, buffers::any_dynamic_buffer & buffer, std::size_t chunk_size = 4096);
+copy(stream & source, stream & sink, buffers::dynamic_buffer_view buffer, std::size_t chunk_size = 4096);
 
 
-template<buffers::dynamic_buffer DynamicBuffer>
-promise<transfer_result> read(stream & source, stream & sink, DynamicBuffer & buffer, std::size_t chunk_size = 4096)
-{
-  auto any = buffers::make_any(buffer);
-  buffers::any_dynamic_buffer & ab = any;
-  co_return co_await copy(source, sink,  ab, chunk_size);
-}
 
 }
 
diff --git a/include/boost/async/io/copy_n.hpp b/include/boost/async/io/copy_n.hpp
@@ -10,7 +10,7 @@
 
 #include <boost/async/io/stream.hpp>
 #include <boost/async/promise.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
+#include <boost/async/io/buffers/dynamic_buffer_view.hpp>
 
 namespace boost::async::io
 {
@@ -19,19 +19,9 @@ BOOST_ASYNC_DECL promise<std::pair<transfer_result, transfer_result>>
 copy_n(stream & source, stream & sink, std::size_t n);
 
 BOOST_ASYNC_DECL promise<std::pair<transfer_result, transfer_result>>
-copy_n(stream & source, stream & sink, buffers::any_dynamic_buffer & buffer,
+copy_n(stream & source, stream & sink, buffers::dynamic_buffer_view buffer,
        std::size_t n, std::size_t chunk_size = 4096);
 
-
-template<buffers::dynamic_buffer DynamicBuffer>
-promise<transfer_result> copy_n(stream & source, stream & sink, DynamicBuffer & buffer,
-                                std::size_t n, std::size_t chunk_size = 4096)
-{
-  auto any = buffers::make_any(buffer);
-  buffers::any_dynamic_buffer & ab = any;
-  co_return co_await copy_n(source, sink,  ab, n, chunk_size);
-}
-
 }
 
 #endif //BOOST_ASYNC_IO_COPY_N_HPP
diff --git a/include/boost/async/io/read.hpp b/include/boost/async/io/read.hpp
@@ -10,8 +10,8 @@
 
 #include <boost/async/promise.hpp>
 #include <boost/async/io/stream.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
 #include <boost/async/io/buffers/mutable_buffer_span.hpp>
+#include <boost/async/io/buffers/range.hpp>
 #include <boost/container/pmr/vector.hpp>
 
 namespace boost::async::io
@@ -20,8 +20,6 @@ namespace boost::async::io
 BOOST_ASYNC_DECL promise<transfer_result> read(stream & source, buffers::mutable_buffer buffer);
 BOOST_ASYNC_DECL promise<transfer_result> read(stream & source, buffers::mutable_buffer_span buffer);
 BOOST_ASYNC_DECL promise<transfer_result> read(stream & source, buffers::mutable_buffer_subspan buffer);
-BOOST_ASYNC_DECL promise<transfer_result> read(stream & source, buffers::any_dynamic_buffer & buffer,
-                                               std::size_t chunk_size = 4096);
 
 template<buffers::mutable_buffer_sequence MutableBufferSequence>
   requires (!std::convertible_to<buffers::mutable_buffer_span, MutableBufferSequence>)
diff --git a/include/boost/async/io/read_all.hpp b/include/boost/async/io/read_all.hpp
@@ -10,25 +10,16 @@
 
 #include <boost/async/promise.hpp>
 #include <boost/async/io/stream.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
+#include <boost/async/io/buffers/dynamic_buffer_view.hpp>
 #include <boost/core/detail/string_view.hpp>
 #include <boost/container/pmr/vector.hpp>
 
 namespace boost::async::io
 {
 
-BOOST_ASYNC_DECL promise<transfer_result> read_all(stream & source, buffers::any_dynamic_buffer & buffer,
+BOOST_ASYNC_DECL promise<transfer_result> read_all(stream & source, buffers::dynamic_buffer_view buffer,
                                                    std::size_t chunk_size = 4096);
 
-template<buffers::dynamic_buffer DynamicBuffer>
-promise<transfer_result> read_all(stream & source, DynamicBuffer &&buffer, std::size_t chunk_size = 4096)
-{
-  auto any = buffers::make_any(std::forward<DynamicBuffer>(buffer));
-  buffers::any_dynamic_buffer & ab = any;
-  co_return co_await read_all(source, ab, chunk_size);
-}
-
-
 }
 
 #endif //BOOST_ASYNC_IO_READ_ALL_HPP
diff --git a/include/boost/async/io/read_until.hpp b/include/boost/async/io/read_until.hpp
@@ -10,37 +10,18 @@
 
 #include <boost/async/promise.hpp>
 #include <boost/async/io/stream.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
+#include <boost/async/io/buffers/dynamic_buffer_view.hpp>
 #include <boost/core/detail/string_view.hpp>
 #include <boost/container/pmr/vector.hpp>
 
 namespace boost::async::io
 {
 
-BOOST_ASYNC_DECL promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,
+BOOST_ASYNC_DECL promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,
                                                      char delim, std::size_t chunk_size = 4096);
-BOOST_ASYNC_DECL promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,
+BOOST_ASYNC_DECL promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,
                                                      core::string_view delim, std::size_t chunk_size = 4096);
 
-
-template<buffers::dynamic_buffer DynamicBuffer>
-promise<transfer_result> read_until(stream & source, DynamicBuffer &&buffer,
-                                    char delim, std::size_t chunk_size = 4096)
-{
-  auto any = buffers::make_any(std::forward<DynamicBuffer>(buffer));
-  buffers::any_dynamic_buffer & ab = any;
-  co_return co_await read_until(source, ab, delim, chunk_size);
-}
-
-template<buffers::dynamic_buffer DynamicBuffer>
-promise<transfer_result> read_until(stream & source, DynamicBuffer &&buffer,
-                                    core::string_view delim, std::size_t chunk_size = 4096)
-{
-  auto any = buffers::make_any(std::forward<DynamicBuffer>(buffer));
-  buffers::any_dynamic_buffer & ab = any;
-  co_return co_await read_until(source, ab, delim, chunk_size);
-}
-
 }
 
 #endif //BOOST_ASYNC_IO_READ_UNTIL_HPP
diff --git a/include/boost/async/io/write.hpp b/include/boost/async/io/write.hpp
@@ -10,8 +10,8 @@
 
 #include <boost/async/promise.hpp>
 #include <boost/async/io/stream.hpp>
-#include <boost/async/io/buffers/any_dynamic_buffer.hpp>
 #include <boost/async/io/buffers/const_buffer_span.hpp>
+#include <boost/async/io/buffers/range.hpp>
 #include <boost/container/pmr/vector.hpp>
 
 namespace boost::async::io
diff --git a/src/io/copy.cpp b/src/io/copy.cpp
@@ -24,6 +24,7 @@ copy(stream & source, stream & sink)
                   w = {};
 
   buf.commit(r.transferred);
+  printf("Copy 1 %ld/%ld ==> \n", r.transferred, w.transferred, 1024 * 1024);
 
   while (!r.has_error() && !w.has_error())
   {
@@ -40,18 +41,17 @@ copy(stream & source, stream & sink)
   // remaining readable stuff
   while (r.has_error() && !w.has_error() && buffers::buffer_size(buf.data()) > 0u)
   {
-    assert(false);
     auto w2 = co_await sink.write_some(buffers::const_buffer_span(buf.data()));
     buf.consume(w2.transferred);
     w.transferred = w2.transferred;
     w.error       = w2.error;
   }
-
+  printf("Copy %ld/%ld ==> \n", r.transferred, w.transferred, 1024 * 1024);
   co_return {r, w};
 }
 
 promise<std::pair<transfer_result, transfer_result>>
-copy(stream & source, stream & sink, buffers::any_dynamic_buffer & buf, std::size_t chunk_size)
+copy(stream & source, stream & sink, buffers::dynamic_buffer_view buf, std::size_t chunk_size)
 {
   transfer_result r = co_await source.read_some(buffers::mutable_buffer_span(buf.prepare(chunk_size))),
       w = {};
@@ -73,12 +73,12 @@ copy(stream & source, stream & sink, buffers::any_dynamic_buffer & buf, std::siz
   // remaining readable stuff
   while (r.has_error() && !w.has_error() && buffers::buffer_size(buf.data()) > 0u)
   {
-    assert(false);
     auto w2 = co_await sink.write_some(buffers::const_buffer_span(buf.data()));
     buf.consume(w2.transferred);
     w.transferred = w2.transferred;
     w.error       = w2.error;
   }
+  printf("Copy %ld/%ld\n", r.transferred, w.transferred);
   co_return {r, w};
 }
 
diff --git a/src/io/copy_n.cpp b/src/io/copy_n.cpp
@@ -52,7 +52,7 @@ copy_n(stream & source, stream & sink, std::size_t n)
 }
 
 promise<std::pair<transfer_result, transfer_result>>
-copy_n(stream & source, stream & sink, buffers::any_dynamic_buffer & buf,
+copy_n(stream & source, stream & sink, buffers::dynamic_buffer_view buf,
        std::size_t n, std::size_t chunk_size)
 {
   transfer_result r = co_await source.read_some(buffers::mutable_buffer_span(buf.prepare(chunk_size))),
diff --git a/src/io/read_all.cpp b/src/io/read_all.cpp
@@ -17,18 +17,18 @@
 namespace boost::async::io
 {
 
-promise<transfer_result> read_all(stream & source, buffers::any_dynamic_buffer & buffer, std::size_t chunk_size)
+promise<transfer_result> read_all(stream & source, buffers::dynamic_buffer_view buffer, std::size_t chunk_size)
 {
   transfer_result tr;
 
   do
   {
-    auto rd = co_await source.read_some(buffer.prepare(chunk_size));
+    auto rd = co_await source.read_some(buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size())));
     tr.transferred += rd.transferred;
     tr.error = rd.error;
     buffer.commit(rd.transferred);
   }
-  while (buffer.size() >= 0 && !tr.has_error());
+  while (buffer.max_size() > buffer.size() && !tr.has_error());
   co_return tr;
 }
 
diff --git a/src/io/read_until.cpp b/src/io/read_until.cpp
@@ -17,15 +17,15 @@
 namespace boost::async::io
 {
 
-promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,
+promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,
                                     char delim, std::size_t chunk_size)
 {
   transfer_result tr{};
 
   bool matched = false;
   do
   {
-    auto buf = buffer.prepare(chunk_size);
+    auto buf = buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size()));
     auto rd = co_await source.read_some(buf);
 
     auto begin = asio::buffers_begin(buf);
@@ -39,7 +39,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer
   co_return tr;
 }
 
-promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,
+promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,
                                     core::string_view delim, std::size_t chunk_size)
 {
   transfer_result tr;
@@ -51,7 +51,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer
   bool matched = false;
   do
   {
-    auto buf = buffer.prepare(chunk_size);
+    auto buf = buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size()));
     auto rd = co_await source.read_some(buf);
     tr.transferred += rd.transferred;
     tr.error = rd.error;
@@ -63,7 +63,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer
     auto itr = std::search(begin, end, delim.begin(), delim.end());
     matched = (itr != end);
   }
-  while (buffer.size() > 0 && !tr.has_error() && !matched);
+  while (buffer.max_size() >=  buffer.size() && !tr.has_error() && !matched);
   co_return tr;
 }
 
diff --git a/src/io/write.cpp b/src/io/write.cpp
@@ -13,13 +13,12 @@ namespace boost::async::io
 
 promise<transfer_result> write(stream & source, buffers::const_buffer buffer)
 {
-  transfer_result tr;
+  transfer_result tr{};
 
   do
   {
     auto rd = co_await source.write_some(buffer);
-    tr.transferred += rd.transferred;
-    tr.error = rd.error;
+    tr += rd;
     buffer += rd.transferred;
   }
   while (buffer.size() > 0 && !tr.has_error());
diff --git a/test/io/copy.cpp b/test/io/copy.cpp
@@ -20,9 +20,10 @@
 
 using namespace boost::async;
 
-promise<void> do_write__(io::stream & str, std::string & input )
+promise<void> do_write__(io::stream & str, const std::string & input )
 {
-  boost::ignore_unused(co_await io::write(str, {input.data(), input.size()}));
+  auto w = co_await io::write(str, input);
+  CHECK(w.transferred == input.size());
   str.close().value();
 };
 
@@ -53,12 +54,12 @@ CO_TEST_CASE("copy")
   auto p = do_write__(w, input);
   auto c = do_copy(ri, wi);
   std::string output;
-  auto res = co_await io::read_all(r, io::buffers::string_buffer(&output));
+  auto res = co_await io::read_all(r, output);
 
   CHECK(res.transferred == output.size());
   CHECK(res.transferred == input.size());
 
-  CHECK(std::equal(output.begin(), output.end(), input.begin()));
+  CHECK(std::equal(output.begin(), std::next(output.begin(), res.transferred), input.begin()));
 
   CHECK(!r.close().has_error());
   co_await p;
diff --git a/test/io/read_until.cpp b/test/io/read_until.cpp
@@ -42,7 +42,7 @@ CO_TEST_CASE("read_until char")
 
 
     std::string output;
-    auto res = co_await io::read_until(r, io::buffers::string_buffer(&output), '\n');
+    auto res = co_await io::read_until(r, output, '\n');
 
     CHECK(res.transferred >= 4242);
     CHECK(res.transferred <  10000);
@@ -75,7 +75,7 @@ CO_TEST_CASE("read_until string")
 
 
   std::string output;
-  auto res = co_await io::read_until(r, io::buffers::string_buffer(&output), "\r\n");
+  auto res = co_await io::read_until(r, output, "\r\n");
 
   CHECK(res.transferred >= 8001);
   CHECK(res.transferred <  16000);

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ copy(stream & source, stream & sink)`
`24`	`24`	`w = {};`
`25`	`25`
`26`	`26`	`buf.commit(r.transferred);`
	`27`	`+ printf("Copy 1 %ld/%ld ==> \n", r.transferred, w.transferred, 1024 * 1024);`
`27`	`28`
`28`	`29`	`while (!r.has_error() && !w.has_error())`
`29`	`30`	`{`
`@@ -40,18 +41,17 @@ copy(stream & source, stream & sink)`
`40`	`41`	`// remaining readable stuff`
`41`	`42`	`while (r.has_error() && !w.has_error() && buffers::buffer_size(buf.data()) > 0u)`
`42`	`43`	`{`
`43`		`- assert(false);`
`44`	`44`	`auto w2 = co_await sink.write_some(buffers::const_buffer_span(buf.data()));`
`45`	`45`	`buf.consume(w2.transferred);`
`46`	`46`	`w.transferred = w2.transferred;`
`47`	`47`	`w.error = w2.error;`
`48`	`48`	`}`
`49`		`-`
	`49`	`+ printf("Copy %ld/%ld ==> \n", r.transferred, w.transferred, 1024 * 1024);`
`50`	`50`	`co_return {r, w};`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`promise<std::pair<transfer_result, transfer_result>>`
`54`		`-copy(stream & source, stream & sink, buffers::any_dynamic_buffer & buf, std::size_t chunk_size)`
	`54`	`+copy(stream & source, stream & sink, buffers::dynamic_buffer_view buf, std::size_t chunk_size)`
`55`	`55`	`{`
`56`	`56`	`transfer_result r = co_await source.read_some(buffers::mutable_buffer_span(buf.prepare(chunk_size))),`
`57`	`57`	`w = {};`
`@@ -73,12 +73,12 @@ copy(stream & source, stream & sink, buffers::any_dynamic_buffer & buf, std::siz`
`73`	`73`	`// remaining readable stuff`
`74`	`74`	`while (r.has_error() && !w.has_error() && buffers::buffer_size(buf.data()) > 0u)`
`75`	`75`	`{`
`76`		`- assert(false);`
`77`	`76`	`auto w2 = co_await sink.write_some(buffers::const_buffer_span(buf.data()));`
`78`	`77`	`buf.consume(w2.transferred);`
`79`	`78`	`w.transferred = w2.transferred;`
`80`	`79`	`w.error = w2.error;`
`81`	`80`	`}`
	`81`	`+ printf("Copy %ld/%ld\n", r.transferred, w.transferred);`
`82`	`82`	`co_return {r, w};`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ copy_n(stream & source, stream & sink, std::size_t n)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`promise<std::pair<transfer_result, transfer_result>>`
`55`		`-copy_n(stream & source, stream & sink, buffers::any_dynamic_buffer & buf,`
	`55`	`+copy_n(stream & source, stream & sink, buffers::dynamic_buffer_view buf,`
`56`	`56`	`std::size_t n, std::size_t chunk_size)`
`57`	`57`	`{`
`58`	`58`	`transfer_result r = co_await source.read_some(buffers::mutable_buffer_span(buf.prepare(chunk_size))),`
Original file line number	Diff line number	Diff line change
`@@ -17,18 +17,18 @@`
`17`	`17`	`namespace boost::async::io`
`18`	`18`	`{`
`19`	`19`
`20`		`-promise<transfer_result> read_all(stream & source, buffers::any_dynamic_buffer & buffer, std::size_t chunk_size)`
	`20`	`+promise<transfer_result> read_all(stream & source, buffers::dynamic_buffer_view buffer, std::size_t chunk_size)`
`21`	`21`	`{`
`22`	`22`	`transfer_result tr;`
`23`	`23`
`24`	`24`	`do`
`25`	`25`	`{`
`26`		`- auto rd = co_await source.read_some(buffer.prepare(chunk_size));`
	`26`	`+ auto rd = co_await source.read_some(buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size())));`
`27`	`27`	`tr.transferred += rd.transferred;`
`28`	`28`	`tr.error = rd.error;`
`29`	`29`	`buffer.commit(rd.transferred);`
`30`	`30`	`}`
`31`		`- while (buffer.size() >= 0 && !tr.has_error());`
	`31`	`+ while (buffer.max_size() > buffer.size() && !tr.has_error());`
`32`	`32`	`co_return tr;`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@`
`17`	`17`	`namespace boost::async::io`
`18`	`18`	`{`
`19`	`19`
`20`		`-promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,`
	`20`	`+promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,`
`21`	`21`	`char delim, std::size_t chunk_size)`
`22`	`22`	`{`
`23`	`23`	`transfer_result tr{};`
`24`	`24`
`25`	`25`	`bool matched = false;`
`26`	`26`	`do`
`27`	`27`	`{`
`28`		`- auto buf = buffer.prepare(chunk_size);`
	`28`	`+ auto buf = buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size()));`
`29`	`29`	`auto rd = co_await source.read_some(buf);`
`30`	`30`
`31`	`31`	`auto begin = asio::buffers_begin(buf);`
`@@ -39,7 +39,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer`
`39`	`39`	`co_return tr;`
`40`	`40`	`}`
`41`	`41`
`42`		`-promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer & buffer,`
	`42`	`+promise<transfer_result> read_until(stream & source, buffers::dynamic_buffer_view buffer,`
`43`	`43`	`core::string_view delim, std::size_t chunk_size)`
`44`	`44`	`{`
`45`	`45`	`transfer_result tr;`
`@@ -51,7 +51,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer`
`51`	`51`	`bool matched = false;`
`52`	`52`	`do`
`53`	`53`	`{`
`54`		`- auto buf = buffer.prepare(chunk_size);`
	`54`	`+ auto buf = buffer.prepare((std::min)(chunk_size, buffer.max_size() - buffer.size()));`
`55`	`55`	`auto rd = co_await source.read_some(buf);`
`56`	`56`	`tr.transferred += rd.transferred;`
`57`	`57`	`tr.error = rd.error;`
`@@ -63,7 +63,7 @@ promise<transfer_result> read_until(stream & source, buffers::any_dynamic_buffer`
`63`	`63`	`auto itr = std::search(begin, end, delim.begin(), delim.end());`
`64`	`64`	`matched = (itr != end);`
`65`	`65`	`}`
`66`		`- while (buffer.size() > 0 && !tr.has_error() && !matched);`
	`66`	`+ while (buffer.max_size() >= buffer.size() && !tr.has_error() && !matched);`
`67`	`67`	`co_return tr;`
`68`	`68`	`}`
`69`	`69`