couchbase 4.0.0 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/operations/management/view_index_get.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/design_document.hxx>
+#include <couchbase/management/design_document.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -28,7 +28,7 @@ namespace couchbase::operations::management
 {
 struct view_index_get_response {
     error_context::http ctx;
-    design_document document{};
+    couchbase::management::views::design_document document{};
 };
 
 struct view_index_get_request {
@@ -41,7 +41,7 @@ struct view_index_get_request {
 
     std::string bucket_name;
     std::string document_name;
-    design_document::name_space name_space;
+    design_document_namespace ns;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/couchbase/operations/management/view_index_get_all.cxx

@@ -56,7 +56,7 @@ view_index_get_all_request::make_response(error_context::http&& ctx, const encod
                         continue;
                     }
 
-                    design_document document{};
+                    couchbase::management::views::design_document document{};
                     document.rev = meta->at("rev").get_string();
                     auto id = meta->at("id").get_string();
                     if (static const std::string prefix = "_design/"; id.find(prefix) == 0) {
@@ -64,13 +64,13 @@ view_index_get_all_request::make_response(error_context::http&& ctx, const encod
                     } else {
                         document.name = id; // fall back, should not happen
                     }
-                    if (static const std::string name_space_prefix = "dev_"; document.name.find(name_space_prefix) == 0) {
-                        document.name = document.name.substr(name_space_prefix.size());
-                        document.ns = couchbase::operations::design_document::name_space::development;
+                    if (static const std::string namespace_prefix = "dev_"; document.name.find(namespace_prefix) == 0) {
+                        document.name = document.name.substr(namespace_prefix.size());
+                        document.ns = couchbase::design_document_namespace::development;
                     } else {
-                        document.ns = couchbase::operations::design_document::name_space::production;
+                        document.ns = couchbase::design_document_namespace::production;
                     }
-                    if (document.ns != name_space) {
+                    if (document.ns != ns) {
                         continue;
                     }
 
@@ -80,7 +80,7 @@ view_index_get_all_request::make_response(error_context::http&& ctx, const encod
                     }
                     if (const auto* views = json->find("views"); views != nullptr && views->is_object()) {
                         for (const auto& [name, view_entry] : views->get_object()) {
-                            couchbase::operations::design_document::view view;
+                            couchbase::management::views::design_document::view view;
                             view.name = name;
                             if (view_entry.is_object()) {
                                 if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {

package/deps/couchbase-cxx-client/couchbase/operations/management/view_index_get_all.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/design_document.hxx>
+#include <couchbase/management/design_document.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -28,7 +28,7 @@ namespace couchbase::operations::management
 {
 struct view_index_get_all_response {
     error_context::http ctx;
-    std::vector<design_document> design_documents{};
+    std::vector<couchbase::management::views::design_document> design_documents{};
 };
 
 struct view_index_get_all_request {
@@ -40,7 +40,7 @@ struct view_index_get_all_request {
     static const inline service_type type = service_type::management;
 
     std::string bucket_name;
-    design_document::name_space name_space;
+    design_document_namespace ns;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/couchbase/operations/management/view_index_upsert.cxx

@@ -42,7 +42,7 @@ view_index_upsert_request::encode_to(encoded_request_type& encoded, http_context
     encoded.headers["content-type"] = "application/json";
     encoded.method = "PUT";
     encoded.path =
-      fmt::format("/{}/_design/{}{}", bucket_name, document.ns == design_document::name_space::development ? "dev_" : "", document.name);
+      fmt::format("/{}/_design/{}{}", bucket_name, document.ns == design_document_namespace::development ? "dev_" : "", document.name);
     encoded.body = utils::json::generate(body);
     return {};
 }

package/deps/couchbase-cxx-client/couchbase/operations/management/view_index_upsert.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/design_document.hxx>
+#include <couchbase/management/design_document.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -39,7 +39,7 @@ struct view_index_upsert_request {
     static const inline service_type type = service_type::view;
 
     std::string bucket_name;
-    design_document document;
+    couchbase::management::views::design_document document;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/couchbase/origin.hxx

@@ -118,6 +118,16 @@ struct origin {
         return credentials_.key_path;
     }
 
+    [[nodiscard]] std::vector<std::string> get_hostnames() const
+    {
+        std::vector<std::string> res;
+        res.reserve(nodes_.size());
+        for (const auto& [hostname, _] : nodes_) {
+            res.emplace_back(hostname);
+        }
+        return res;
+    }
+
     [[nodiscard]] std::vector<std::string> get_nodes() const
     {
         std::vector<std::string> res;

package/deps/couchbase-cxx-client/couchbase/platform/string_hex.cc

@@ -28,9 +28,11 @@ from_hex_digit(char c)
 {
     if ('0' <= c && c <= '9') {
         return static_cast<uint8_t>(c - '0');
-    } else if ('A' <= c && c <= 'F') {
+    }
+    if ('A' <= c && c <= 'F') {
         return static_cast<uint8_t>(c + 10 - 'A');
-    } else if ('a' <= c && c <= 'f') {
+    }
+    if ('a' <= c && c <= 'f') {
         return static_cast<uint8_t>(c + 10 - 'a');
     }
     throw std::invalid_argument("couchbase::from_hex_digit: character was not in hexadecimal range");

package/deps/couchbase-cxx-client/couchbase/protocol/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(
   cmd_touch.cxx
   cmd_unlock.cxx
   cmd_upsert.cxx
+  frame_info_utils.cxx
   status.cxx)
 set_target_properties(couchbase_protocol PROPERTIES POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(

package/deps/couchbase-cxx-client/couchbase/protocol/client_opcode.hxx

@@ -253,7 +253,7 @@ enum class subdoc_opcode : uint8_t {
 constexpr bool
 is_valid_client_opcode(uint8_t code)
 {
-    switch (client_opcode(code)) {
+    switch (static_cast<client_opcode>(code)) {
         case client_opcode::get:
         case client_opcode::upsert:
         case client_opcode::insert:
@@ -332,7 +332,7 @@ is_valid_client_opcode(uint8_t code)
 constexpr bool
 is_valid_subdoc_opcode(uint8_t code)
 {
-    switch (subdoc_opcode(code)) {
+    switch (static_cast<subdoc_opcode>(code)) {
         case subdoc_opcode::get:
         case subdoc_opcode::exists:
         case subdoc_opcode::dict_add:
@@ -354,6 +354,6 @@ is_valid_subdoc_opcode(uint8_t code)
     return false;
 }
 
-const inline static std::vector<std::uint8_t> empty_buffer;
+const inline static std::vector<std::byte> empty_buffer;
 const inline static std::string empty_string;
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/client_request.cxx

@@ -16,20 +16,21 @@
  */
 
 #include <couchbase/protocol/client_request.hxx>
+#include <couchbase/utils/binary.hxx>
 
 #include <snappy.h>
 
 namespace couchbase::protocol
 {
 std::pair<bool, std::uint32_t>
-compress_value(const std::vector<std::uint8_t>& value, std::vector<uint8_t>::iterator& output)
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output)
 {
     static const double min_ratio = 0.83;
 
     std::string compressed;
     std::size_t compressed_size = snappy::Compress(reinterpret_cast<const char*>(value.data()), value.size(), &compressed);
     if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(value.size()) < min_ratio) {
-        std::copy(compressed.begin(), compressed.end(), output);
+        utils::to_binary(compressed, output);
         return { true, gsl::narrow_cast<std::uint32_t>(compressed_size) };
     }
     return { false, 0 };

package/deps/couchbase-cxx-client/couchbase/protocol/client_request.hxx

@@ -20,15 +20,17 @@
 #include <couchbase/protocol/client_opcode.hxx>
 #include <couchbase/protocol/client_response.hxx>
 #include <couchbase/protocol/magic.hxx>
+#include <couchbase/utils/binary.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
+#include <algorithm>
 #include <cstring>
 #include <gsl/util>
 
 namespace couchbase::protocol
 {
 std::pair<bool, std::uint32_t>
-compress_value(const std::vector<std::uint8_t>& value, std::vector<std::uint8_t>::iterator& output);
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output);
 
 template<typename Body>
 class client_request
@@ -46,7 +48,6 @@ class client_request
     std::uint32_t opaque_{ 0 };
     std::uint64_t cas_{ 0 };
     Body body_;
-    std::vector<std::uint8_t> payload_;
 
   public:
     [[nodiscard]] client_opcode opcode() const
@@ -59,7 +60,7 @@ class client_request
         opaque_ = val;
     }
 
-    void cas(protocol::cas val)
+    void cas(cas val)
     {
         cas_ = utils::byte_swap(val.value);
     }
@@ -84,74 +85,73 @@ class client_request
         return body_;
     }
 
-    std::vector<std::uint8_t>& data(bool try_to_compress = false)
+    [[nodiscard]] std::vector<std::byte> data(bool try_to_compress = false)
     {
         switch (opcode_) {
             case protocol::client_opcode::insert:
             case protocol::client_opcode::upsert:
             case protocol::client_opcode::replace:
-                write_payload(try_to_compress);
-                break;
+                return generate_payload(try_to_compress);
             default:
-                write_payload(false);
                 break;
         }
-        return payload_;
+        return generate_payload(false);
     }
 
   private:
-    void write_payload(bool try_to_compress)
+    [[nodiscard]] std::vector<std::byte> generate_payload(bool try_to_compress)
     {
-        payload_.resize(header_size + body_.size(), 0);
-        payload_[0] = static_cast<uint8_t>(magic_);
-        payload_[1] = static_cast<uint8_t>(opcode_);
+        std::vector<std::byte> payload;
+        payload.resize(header_size + body_.size(), std::byte{ 0 });
+        payload[0] = static_cast<std::byte>(magic_);
+        payload[1] = static_cast<std::byte>(opcode_);
 
-        auto framing_extras = body_.framing_extras();
+        const auto& framing_extras = body_.framing_extras();
 
         uint16_t key_size = gsl::narrow_cast<uint16_t>(body_.key().size());
         if (framing_extras.size() == 0) {
             key_size = utils::byte_swap(key_size);
-            memcpy(payload_.data() + 2, &key_size, sizeof(key_size));
+            memcpy(payload.data() + 2, &key_size, sizeof(key_size));
         } else {
             magic_ = protocol::magic::alt_client_request;
-            payload_[0] = static_cast<uint8_t>(magic_);
-            payload_[2] = gsl::narrow_cast<std::uint8_t>(framing_extras.size());
-            payload_[3] = gsl::narrow_cast<std::uint8_t>(key_size);
+            payload[0] = static_cast<std::byte>(magic_);
+            payload[2] = gsl::narrow_cast<std::byte>(framing_extras.size());
+            payload[3] = gsl::narrow_cast<std::byte>(key_size);
         }
 
         uint8_t ext_size = gsl::narrow_cast<uint8_t>(body_.extras().size());
-        memcpy(payload_.data() + 4, &ext_size, sizeof(ext_size));
+        memcpy(payload.data() + 4, &ext_size, sizeof(ext_size));
 
         uint16_t vbucket = utils::byte_swap(gsl::narrow_cast<uint16_t>(partition_));
-        memcpy(payload_.data() + 6, &vbucket, sizeof(vbucket));
+        memcpy(payload.data() + 6, &vbucket, sizeof(vbucket));
 
         uint32_t body_size = utils::byte_swap(gsl::narrow_cast<uint32_t>(body_.size()));
-        memcpy(payload_.data() + 8, &body_size, sizeof(body_size));
+        memcpy(payload.data() + 8, &body_size, sizeof(body_size));
 
-        memcpy(payload_.data() + 12, &opaque_, sizeof(opaque_));
-        memcpy(payload_.data() + 16, &cas_, sizeof(cas_));
+        memcpy(payload.data() + 12, &opaque_, sizeof(opaque_));
+        memcpy(payload.data() + 16, &cas_, sizeof(cas_));
 
-        auto body_itr = payload_.begin() + header_size;
+        auto body_itr = payload.begin() + header_size;
         if (framing_extras.size() > 0) {
             body_itr = std::copy(framing_extras.begin(), framing_extras.end(), body_itr);
         }
         body_itr = std::copy(body_.extras().begin(), body_.extras().end(), body_itr);
-        body_itr = std::copy(body_.key().begin(), body_.key().end(), body_itr);
+        body_itr = utils::to_binary(body_.key(), body_itr);
 
-        static const std::size_t min_size_to_compress = 32;
-        if (try_to_compress && body_.value().size() > min_size_to_compress) {
+        if (static const std::size_t min_size_to_compress = 32; try_to_compress && body_.value().size() > min_size_to_compress) {
             if (auto [compressed, new_value_size] = compress_value(body_.value(), body_itr); compressed) {
                 /* the compressed value meets requirements and was copied to the payload */
-                payload_[5] |= static_cast<std::uint8_t>(protocol::datatype::snappy);
+                payload[5] |= static_cast<std::byte>(protocol::datatype::snappy);
                 std::uint32_t new_body_size =
                   utils::byte_swap(body_size) - gsl::narrow_cast<std::uint32_t>(body_.value().size()) + new_value_size;
-                payload_.resize(header_size + new_body_size);
+                payload.resize(header_size + new_body_size);
                 new_body_size = utils::byte_swap(new_body_size);
-                memcpy(payload_.data() + 8, &new_body_size, sizeof(new_body_size));
-                return;
+                memcpy(payload.data() + 8, &new_body_size, sizeof(new_body_size));
+                return payload;
             }
         }
         std::copy(body_.value().begin(), body_.value().end(), body_itr);
+        return payload;
     }
 };
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/client_response.cxx

@@ -36,9 +36,9 @@ parse_server_duration_us(const io::mcbp_message& msg)
     }
     std::size_t offset = 0;
     while (offset < framing_extras_size) {
-        auto frame_size = static_cast<std::uint8_t>(msg.body[offset] & 0xfU);
-        auto frame_id = static_cast<std::uint8_t>((static_cast<std::uint32_t>(msg.body[offset]) >> 4U) & 0xfU);
-        offset++;
+        auto frame_size = std::to_integer<std::uint8_t>(msg.body[offset] & std::byte{ 0b1111 });
+        auto frame_id = std::to_integer<std::uint8_t>((msg.body[offset] >> 4U) & std::byte{ 0b1111 });
+        ++offset;
         if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
             if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
                 std::uint16_t encoded_duration{};
@@ -53,7 +53,7 @@ parse_server_duration_us(const io::mcbp_message& msg)
 }
 
 bool
-parse_enhanced_error(const std::string& str, enhanced_error_info& info)
+parse_enhanced_error(std::string_view str, enhanced_error_info& info)
 {
     if (auto error = utils::json::parse(str); error.is_object()) {
         if (const auto* err_obj = error.find("error"); err_obj != nullptr && err_obj->is_object()) {

package/deps/couchbase-cxx-client/couchbase/protocol/client_response.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
+#include <couchbase/cas.hxx>
 #include <couchbase/io/mcbp_message.hxx>
-#include <couchbase/protocol/cas.hxx>
 #include <couchbase/protocol/client_opcode.hxx>
 #include <couchbase/protocol/client_opcode_fmt.hxx>
 #include <couchbase/protocol/cmd_info.hxx>
@@ -45,7 +45,7 @@ double
 parse_server_duration_us(const io::mcbp_message& msg);
 
 bool
-parse_enhanced_error(const std::string& str, enhanced_error_info& info);
+parse_enhanced_error(std::string_view str, enhanced_error_info& info);
 
 template<typename Body>
 class client_response
@@ -55,8 +55,8 @@ class client_response
     magic magic_{ magic::client_response };
     client_opcode opcode_{ client_opcode::invalid };
     header_buffer header_{};
-    uint8_t data_type_{ 0 };
-    std::vector<std::uint8_t> data_{};
+    std::uint8_t data_type_{ 0 };
+    std::vector<std::byte> data_{};
     std::uint16_t key_size_{ 0 };
     std::uint8_t framing_extras_size_{ 0 };
     std::uint8_t extras_size_{ 0 };
@@ -93,14 +93,9 @@ class client_response
         return status_;
     }
 
-    [[nodiscard]] std::size_t body_size() const
+    [[nodiscard]] couchbase::cas cas() const
     {
-        return body_size_;
-    }
-
-    [[nodiscard]] protocol::cas cas() const
-    {
-        return protocol::cas{ cas_ };
+        return couchbase::cas{ cas_ };
     }
 
     [[nodiscard]] std::uint32_t opaque() const
@@ -125,23 +120,22 @@ class client_response
 
     void verify_header()
     {
-        Expects(header_[0] == static_cast<std::uint8_t>(magic::alt_client_response) ||
-                header_[0] == static_cast<std::uint8_t>(magic::client_response));
-        Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        magic_ = magic(header_[0]);
-        opcode_ = client_opcode(header_[1]);
-        data_type_ = header_[5];
+        Expects(header_[0] == static_cast<std::byte>(magic::alt_client_response) ||
+                header_[0] == static_cast<std::byte>(magic::client_response));
+        Expects(header_[1] == static_cast<std::byte>(Body::opcode));
+        magic_ = static_cast<magic>(header_[0]);
+        opcode_ = static_cast<client_opcode>(header_[1]);
+        data_type_ = std::to_integer<std::uint8_t>(header_[5]);
 
         uint16_t status = 0;
         memcpy(&status, header_.data() + 6, sizeof(status));
         status = utils::byte_swap(status);
-        Expects(protocol::is_valid_status(status));
-        status_ = protocol::status(status);
+        status_ = static_cast<protocol::status>(status);
 
-        extras_size_ = header_[4];
+        extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
         if (magic_ == magic::alt_client_response) {
-            framing_extras_size_ = header_[2];
-            key_size_ = header_[3];
+            framing_extras_size_ = std::to_integer<std::uint8_t>(header_[2]);
+            key_size_ = std::to_integer<std::uint8_t>(header_[3]);
         } else {
             memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
             key_size_ = utils::byte_swap(key_size_);
@@ -177,7 +171,10 @@ class client_response
         bool parsed = body_.parse(status_, header_, framing_extras_size_, key_size_, extras_size_, data_, info_);
         if (status_ != protocol::status::success && !parsed && has_json_datatype(data_type_)) {
             enhanced_error_info err;
-            if (parse_enhanced_error(std::string(data_.begin() + framing_extras_size_ + extras_size_ + key_size_, data_.end()), err)) {
+            std::vector<uint8_t>::difference_type offset = framing_extras_size_ + extras_size_ + key_size_;
+            std::string_view enhanced_error_text{ reinterpret_cast<const char*>(data_.data()) + offset,
+                                                  data_.size() - static_cast<std::size_t>(offset) };
+            if (parse_enhanced_error(enhanced_error_text, err)) {
                 error_.emplace(err);
             }
         }
@@ -190,9 +187,9 @@ class client_response
         }
         size_t offset = 0;
         while (offset < framing_extras_size_) {
-            std::uint8_t frame_size = data_[offset] & 0xfU;
-            std::uint8_t frame_id = (static_cast<std::uint32_t>(data_[offset]) >> 4U) & 0xfU;
-            offset++;
+            auto frame_size = std::to_integer<std::uint8_t>(data_[offset] & std::byte{ 0b1111 });
+            auto frame_id = std::to_integer<std::uint8_t>((data_[offset] >> 4U) & std::byte{ 0b1111 });
+            ++offset;
             if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration) && frame_size == 2 &&
                 framing_extras_size_ - offset >= frame_size) {
                 std::uint16_t encoded_duration{};
@@ -204,7 +201,7 @@ class client_response
         }
     }
 
-    [[nodiscard]] std::vector<std::uint8_t>& data()
+    [[nodiscard]] std::vector<std::byte>& data()
     {
         return data_;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_append.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -32,10 +32,10 @@ protocol::append_response_body::parse(protocol::status status,
                                       std::uint8_t framing_extras_size,
                                       std::uint16_t /* key_size */,
                                       std::uint8_t extras_size,
-                                      const std::vector<uint8_t>& body,
+                                      const std::vector<std::byte>& body,
                                       const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 16) {
@@ -50,14 +50,11 @@ protocol::append_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 protocol::append_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -66,17 +63,7 @@ protocol::append_request_body::durability(protocol::durability_level level, std:
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    if (timeout) {
-        framing_extras_.resize(4);
-        framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(2);
-        framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.hxx

@@ -25,8 +25,8 @@
 #include <couchbase/protocol/cmd_info.hxx>
 #include <couchbase/protocol/status.hxx>
 
+#include <couchbase/mutation_token.hxx>
 #include <couchbase/protocol/durability_level.hxx>
-#include <couchbase/protocol/mutation_token.hxx>
 
 namespace couchbase::protocol
 {
@@ -50,7 +50,7 @@ class append_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -61,10 +61,10 @@ class append_request_body
     static const inline client_opcode opcode = client_opcode::append;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
+    std::vector<std::byte> framing_extras_{};
 
     static inline std::vector<std::uint8_t> empty;
 
@@ -73,27 +73,27 @@ class append_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_cluster_map_change_notification.cxx

@@ -27,12 +27,12 @@
 namespace couchbase::protocol
 {
 bool
-cluster_map_change_notification_request_body::parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info)
+cluster_map_change_notification_request_body::parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
-    using offset_type = std::vector<uint8_t>::difference_type;
+    Expects(header[1] == static_cast<std::byte>(opcode));
+    using offset_type = std::vector<std::byte>::difference_type;
 
-    uint8_t ext_size = header[4];
+    auto ext_size = std::to_integer<std::uint8_t>(header[4]);
     offset_type offset = ext_size;
     if (ext_size == 4) {
         memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
@@ -41,10 +41,12 @@ cluster_map_change_notification_request_body::parse(const header_buffer& header,
     uint16_t key_size = 0;
     memcpy(&key_size, header.data() + 2, sizeof(key_size));
     key_size = utils::byte_swap(key_size);
-    bucket_.assign(body.begin() + offset, body.begin() + offset + key_size);
+    const auto* data_ptr = reinterpret_cast<const char*>(body.data());
+    bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
     offset += key_size;
     if (body.size() > static_cast<std::size_t>(offset)) {
-        config_ = parse_config(std::string(body.begin() + offset, body.end()), info.endpoint_address, info.endpoint_port);
+        std::string_view config_text{ data_ptr + offset, body.size() - static_cast<std::size_t>(offset) };
+        config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
     }
     return true;
 }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_cluster_map_change_notification.hxx

@@ -51,7 +51,7 @@ class cluster_map_change_notification_request_body
         return config_;
     }
 
-    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info);
+    bool parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info);
 };
 
 } // namespace couchbase::protocol