couchbase 4.1.1 → 4.1.2

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

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_remove.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>
 
@@ -31,12 +31,12 @@ remove_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) {
-        using offset_type = std::vector<uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size;
         if (extras_size == 16) {
             memcpy(&token_.partition_uuid, body.data() + offset, sizeof(token_.partition_uuid));
@@ -54,11 +54,7 @@ remove_response_body::parse(protocol::status status,
 void
 remove_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
@@ -67,17 +63,7 @@ remove_request_body::durability(protocol::durability_level level, std::optional<
     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_remove.hxx

@@ -45,7 +45,7 @@ class remove_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);
 };
 
@@ -56,30 +56,30 @@ class remove_request_body
     static const inline client_opcode opcode = client_opcode::remove;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    [[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 empty_buffer;
     }

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

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_replace.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 @@ replace_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) {
@@ -54,11 +54,7 @@ replace_response_body::parse(protocol::status status,
 void
 replace_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
@@ -67,28 +63,14 @@ replace_request_body::durability(protocol::durability_level level, std::optional
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    auto extras_size = framing_extras_.size();
-    if (timeout) {
-        framing_extras_.resize(extras_size + 4);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(extras_size + 2);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 
 void
 replace_request_body::preserve_expiry()
 {
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
-    auto extras_size = framing_extras_.size();
-    framing_extras_.resize(extras_size + 1);
-    framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    add_preserve_expiry_frame_info(framing_extras_);
 }
 
 void

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

@@ -52,7 +52,7 @@ class replace_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);
 };
 
@@ -63,12 +63,12 @@ class replace_request_body
     static const inline client_opcode opcode = client_opcode::replace;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
     std::uint32_t flags_{};
     std::uint32_t expiry_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
@@ -77,7 +77,7 @@ class replace_request_body
 
     void preserve_expiry();
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
@@ -92,17 +92,17 @@ class replace_request_body
         expiry_ = value;
     }
 
-    [[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()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -110,7 +110,7 @@ class replace_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }

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

@@ -17,8 +17,12 @@
 
 #include <couchbase/protocol/cmd_sasl_auth.hxx>
 
+#include <couchbase/utils/binary.hxx>
+
 #include <gsl/assert>
 
+#include <algorithm>
+
 namespace couchbase::protocol
 {
 bool
@@ -27,14 +31,31 @@ sasl_auth_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 || status == protocol::status::auth_continue) {
-        value_.assign(body.begin() + framing_extras_size + extras_size + key_size, body.end());
+        std::transform(body.begin() + framing_extras_size + extras_size + key_size,
+                       body.end(),
+                       std::back_insert_iterator(value_),
+                       [](auto b) { return static_cast<char>(b); });
         return true;
     }
     return false;
 }
+
+void
+sasl_auth_request_body::mechanism(std::string_view mech)
+{
+    key_.reserve(mech.size());
+    utils::to_binary(mech, std::back_insert_iterator(key_));
+}
+
+void
+sasl_auth_request_body::sasl_data(std::string_view data)
+{
+    value_.reserve(data.size());
+    utils::to_binary(data, std::back_insert_iterator(value_));
+}
 } // namespace couchbase::protocol

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

@@ -38,7 +38,7 @@ class sasl_auth_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);
 
     [[nodiscard]] std::string_view value() const
@@ -54,36 +54,30 @@ class sasl_auth_request_body
     static const inline client_opcode opcode = client_opcode::sasl_auth;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> value_;
+    std::vector<std::byte> key_;
+    std::vector<std::byte> value_;
 
   public:
-    void mechanism(std::string_view mech)
-    {
-        key_ = mech;
-    }
+    void mechanism(std::string_view mech);
 
-    void sasl_data(std::string_view data)
-    {
-        value_.assign(data.begin(), data.end());
-    }
+    void sasl_data(std::string_view data);
 
-    [[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 empty_buffer;
     }
 
-    [[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 value_;
     }

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

@@ -28,19 +28,24 @@ sasl_list_mechs_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) {
         auto previous = body.begin();
-        auto current = std::find(body.begin() + framing_extras_size + extras_size + key_size, body.end(), ' ');
+        auto current = std::find(body.begin() + framing_extras_size + extras_size + key_size, body.end(), std::byte{ ' ' });
+        std::string mech;
         while (current != body.end()) {
-            supported_mechs_.emplace_back(previous, current);
+            mech.resize(static_cast<std::size_t>(std::distance(previous, current)));
+            std::transform(previous, current, mech.begin(), [](auto b) { return static_cast<char>(b); });
+            supported_mechs_.emplace_back(mech);
             previous = current + 1;
-            current = std::find(previous, body.end(), ' ');
+            current = std::find(previous, body.end(), std::byte{ ' ' });
         }
-        supported_mechs_.emplace_back(previous, current);
+        mech.resize(static_cast<std::size_t>(std::distance(previous, current)));
+        std::transform(previous, current, mech.begin(), [](auto b) { return static_cast<char>(b); });
+        supported_mechs_.emplace_back(mech);
         return true;
     }
     return false;

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

@@ -43,7 +43,7 @@ class sasl_list_mechs_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);
 };
 
@@ -58,17 +58,17 @@ class sasl_list_mechs_request_body
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[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 empty_buffer;
     }

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

@@ -17,8 +17,12 @@
 
 #include <couchbase/protocol/cmd_sasl_step.hxx>
 
+#include <couchbase/utils/binary.hxx>
+
 #include <gsl/assert>
 
+#include <algorithm>
+
 namespace couchbase::protocol
 {
 bool
@@ -27,14 +31,31 @@ sasl_step_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) {
-        value_ = { body.begin() + framing_extras_size + extras_size + key_size, body.end() };
+        std::transform(body.begin() + framing_extras_size + extras_size + key_size,
+                       body.end(),
+                       std::back_insert_iterator(value_),
+                       [](auto b) { return static_cast<char>(b); });
         return true;
     }
     return false;
 }
+
+void
+sasl_step_request_body::mechanism(std::string_view mech)
+{
+    key_.reserve(mech.size());
+    utils::to_binary(mech, std::back_insert_iterator(key_));
+}
+
+void
+sasl_step_request_body::sasl_data(std::string_view data)
+{
+    value_.reserve(data.size());
+    utils::to_binary(data, std::back_insert_iterator(value_));
+}
 } // namespace couchbase::protocol

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

@@ -38,7 +38,7 @@ class sasl_step_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);
 
     [[nodiscard]] std::string_view value() const
@@ -54,36 +54,30 @@ class sasl_step_request_body
     static const inline client_opcode opcode = client_opcode::sasl_step;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> value_{};
 
   public:
-    void mechanism(std::string_view mech)
-    {
-        key_ = mech;
-    }
+    void mechanism(std::string_view mech);
 
-    void sasl_data(std::string_view data)
-    {
-        value_.assign(data.begin(), data.end());
-    }
+    void sasl_data(std::string_view data);
 
-    [[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 empty_buffer;
     }
 
-    [[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 value_;
     }

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

@@ -17,6 +17,8 @@
 
 #include <couchbase/protocol/cmd_select_bucket.hxx>
 
+#include <couchbase/utils/binary.hxx>
+
 #include <gsl/assert>
 
 namespace couchbase::protocol
@@ -27,10 +29,17 @@ select_bucket_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));
     return false;
 }
+
+void
+select_bucket_request_body::bucket_name(std::string_view name)
+{
+    key_.reserve(name.size());
+    utils::to_binary(name, std::back_insert_iterator(key_));
+}
 } // namespace couchbase::protocol

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

@@ -34,7 +34,7 @@ class select_bucket_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);
 };
 
@@ -45,30 +45,27 @@ class select_bucket_request_body
     static const inline client_opcode opcode = client_opcode::select_bucket;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
 
   public:
-    void bucket_name(std::string_view name)
-    {
-        key_ = name;
-    }
+    void bucket_name(std::string_view name);
 
-    [[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 empty_buffer;
     }
 
-    [[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 empty_buffer;
     }

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

@@ -31,21 +31,17 @@ touch_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));
     return false;
 }
 
 void
 touch_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
 touch_request_body::expiry(std::uint32_t seconds)

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

@@ -36,7 +36,7 @@ class touch_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);
 };
 
@@ -47,30 +47,30 @@ class touch_request_body
     static const inline client_opcode opcode = client_opcode::touch;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
 
     void expiry(std::uint32_t seconds);
 
-    [[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 empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }