CXX-1314 Switch order of pointer/length parameters to gridfs::uploader::write and gridfs::downloader::read

Author: saghm

examples/mongocxx/gridfs.cpp

@@ -45,7 +45,7 @@ int main() {
 
     // Write 50 bytes to the file.
     for (auto i = 0; i < 5; ++i) {
-        uploader.write(10, bytes);
+        uploader.write(bytes, 10);
     }
 
     auto result = uploader.close();
@@ -62,7 +62,7 @@ int main() {
     auto buffer_size = std::min(file_length, static_cast<std::int64_t>(downloader.chunk_size()));
     auto buffer = make_unique<std::uint8_t[]>(buffer_size);
 
-    while (auto length_read = downloader.read(buffer_size, buffer.get())) {
+    while (auto length_read = downloader.read(buffer.get(), buffer_size)) {
         bytes_counter += length_read;
 
         // Do something with the contents of buffer.

src/mongocxx/gridfs/bucket.cpp

@@ -154,7 +154,7 @@ void bucket::upload_from_stream_with_id(bsoncxx::types::value id,
 
     while (!source->eof()) {
         source->read(reinterpret_cast<char*>(buffer.get()), static_cast<std::size_t>(chunk_size));
-        upload_stream.write(source->gcount(), buffer.get());
+        upload_stream.write(buffer.get(), source->gcount());
     }
 
     upload_stream.close();
@@ -209,7 +209,7 @@ void bucket::download_to_stream(bsoncxx::types::value id, std::ostream* destinat
     std::size_t bytes_read;
 
     while ((bytes_read =
-                download_stream.read(static_cast<std::size_t>(chunk_size), buffer.get())) != 0) {
+                download_stream.read(buffer.get(), static_cast<std::size_t>(chunk_size))) != 0) {
         destination->write(reinterpret_cast<char*>(buffer.get()), bytes_read);
     }
 

src/mongocxx/gridfs/downloader.cpp

@@ -42,7 +42,7 @@ downloader::operator bool() const noexcept {
     return static_cast<bool>(_impl);
 }
 
-std::size_t downloader::read(std::size_t length_requested, std::uint8_t* buffer) {
+std::size_t downloader::read(std::uint8_t* buffer, std::size_t length_requested) {
     if (_get_impl().closed) {
         throw logic_error{error_code::k_gridfs_stream_not_open};
     }

src/mongocxx/gridfs/downloader.hpp

@@ -71,12 +71,12 @@ class MONGOCXX_API downloader {
     ///
     /// Reads a specified number of bytes from the GridFS file being downloaded.
     ///
-    /// @param length
-    ///   The number of bytes to read from the file.
-    ///
     /// @param buffer
     ///   A pointer to a buffer to store the bytes read from the file.
     ///
+    /// @param length
+    ///   The number of bytes to read from the file.
+    ///
     /// @return
     ///   The number of bytes actually read. If zero, the downloader has reached the end of the
     ///   file.
@@ -88,7 +88,7 @@ class MONGOCXX_API downloader {
     /// @throws mongocxx::query_exception
     ///   if an error occurs when reading chunk data from the database for the requested file.
     ///
-    std::size_t read(std::size_t length, std::uint8_t* buffer);
+    std::size_t read(std::uint8_t* buffer, std::size_t length);
 
     ///
     /// Closes the downloader stream.

src/mongocxx/gridfs/uploader.cpp

@@ -68,7 +68,7 @@ uploader::operator bool() const noexcept {
     return static_cast<bool>(_impl);
 }
 
-void uploader::write(std::size_t length, const std::uint8_t* bytes) {
+void uploader::write(const std::uint8_t* bytes, std::size_t length) {
     if (_get_impl().closed) {
         throw logic_error{error_code::k_gridfs_stream_not_open};
     }

src/mongocxx/gridfs/uploader.hpp

@@ -72,12 +72,12 @@ class MONGOCXX_API uploader {
     ///
     /// Writes a specified number of bytes to a GridFS file.
     ///
-    /// @param length
-    ///   The number of bytes to write.
-    ///
     /// @param bytes
     ///   A pointer to the bytes to write.
     ///
+    /// @param length
+    ///   The number of bytes to write.
+    ///
     /// @throws mongocxx::logic_error if the upload stream was already closed.
     ///
     /// @throws mongocxx::bulk_write_exception
@@ -87,7 +87,7 @@ class MONGOCXX_API uploader {
     ///   if the uploader requires more than 2^31-1 chunks to store the file at the requested chunk
     ///   size.
     ///
-    void write(std::size_t length, const std::uint8_t* bytes);
+    void write(const std::uint8_t* bytes, std::size_t length);
 
     ///
     /// Closes the uploader stream.

src/mongocxx/test/gridfs/bucket.cpp

@@ -297,7 +297,7 @@ TEST_CASE("downloading throws error when chunks document is corrupt", "[gridfs::
     auto downloader_read_one = [&downloader]() {
         stdx::optional<std::uint8_t> result;
         std::uint8_t byte;
-        std::size_t bytes_downloaded = downloader.read(1, &byte);
+        std::size_t bytes_downloaded = downloader.read(&byte, 1);
         if (bytes_downloaded > 0) {
             result = byte;
         }
@@ -407,7 +407,7 @@ TEST_CASE("mongocxx::gridfs::downloader::read with arbitrary sizes", "[gridfs::d
     std::size_t total_bytes_read = 0;
     auto downloader = bucket.open_download_stream(bsoncxx::types::value{id});
 
-    while (std::size_t bytes_read = downloader.read(read_size, buffer.data())) {
+    while (std::size_t bytes_read = downloader.read(buffer.data(), read_size)) {
         std::vector<std::uint8_t> expected_bytes{expected.data() + total_bytes_read,
                                                  expected.data() + total_bytes_read + bytes_read};
         std::vector<std::uint8_t> actual_bytes{buffer.data(), buffer.data() + bytes_read};
@@ -510,7 +510,7 @@ TEST_CASE("mongocxx::gridfs::uploader::write with arbitrary sizes", "[gridfs::up
             std::min(static_cast<std::int64_t>(write_size),
                      file_length - static_cast<std::int64_t>(bytes_written)));
 
-        uploader.write(actual_write_size, bytes.data() + bytes_written);
+        uploader.write(bytes.data() + bytes_written, actual_write_size);
         bytes_written += actual_write_size;
     }
 
@@ -565,15 +565,15 @@ TEST_CASE("gridfs upload/download round trip", "[gridfs::uploader] [gridfs::down
     std::array<std::uint8_t, 100> downloaded_bytes;
 
     auto uploader = bucket.open_upload_stream("file");
-    uploader.write(100, uploaded_bytes.data());
+    uploader.write(uploaded_bytes.data(), 100);
     auto result = uploader.close();
 
     auto downloader = bucket.open_download_stream(result.id());
-    auto bytes_read = downloader.read(100, downloaded_bytes.data());
+    auto bytes_read = downloader.read(downloaded_bytes.data(), 100);
     REQUIRE(bytes_read == 100);
 
     std::uint8_t c;
-    REQUIRE(downloader.read(1, &c) == 0);
+    REQUIRE(downloader.read(&c, 1) == 0);
 
     REQUIRE(uploaded_bytes == downloaded_bytes);
 }

src/mongocxx/test/gridfs/downloader.cpp

@@ -26,5 +26,5 @@ TEST_CASE("mongocxx::gridfs::downloader default constructor makes invalid downlo
     gridfs::downloader downloader;
     REQUIRE(!downloader);
     std::uint8_t c;
-    REQUIRE_THROWS_AS(downloader.read(1, &c), logic_error);
+    REQUIRE_THROWS_AS(downloader.read(&c, 1), logic_error);
 }

src/mongocxx/test/gridfs/uploader.cpp

@@ -26,5 +26,5 @@ TEST_CASE("mongocxx::gridfs::uploader default constructor makes invalid uploader
     gridfs::uploader uploader;
     REQUIRE(!uploader);
     std::uint8_t c = 0x0;
-    REQUIRE_THROWS_AS(uploader.write(1, &c), logic_error);
+    REQUIRE_THROWS_AS(uploader.write(&c, 1), logic_error);
 }

src/mongocxx/test/spec/gridfs.cpp

@@ -223,7 +223,7 @@ void test_download(database db,
 
         // Otherwise, an error should occur when reading from the stream.
         gridfs::downloader downloader = bucket.open_download_stream(id);
-        REQUIRE_THROWS_AS(downloader.read(length, actual.get()), std::exception);
+        REQUIRE_THROWS_AS(downloader.read(actual.get(), length), std::exception);
 
         return;
     }
@@ -233,7 +233,7 @@ void test_download(database db,
 
     gridfs::downloader downloader = bucket.open_download_stream(id);
 
-    std::int64_t actual_size = downloader.read(length, actual.get());
+    std::int64_t actual_size = downloader.read(actual.get(), length);
     REQUIRE(actual_size == length);
 
     // The GridFS spec specifies the expected binary data in the form of { $hex: "<hexadecimal
@@ -283,7 +283,7 @@ void test_upload(database db,
     std::string hex = source["$hex"].get_utf8().value.to_string();
     std::basic_string<std::uint8_t> source_bytes = test_util::convert_hex_string_to_bytes(hex);
 
-    uploader.write(source_bytes.size(), source_bytes.data());
+    uploader.write(source_bytes.data(), source_bytes.size());
     result::gridfs::upload upload_result = uploader.close();
     auto id = upload_result.id();