couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_decrement.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_decrement.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 @@ decrement_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,48 +54,27 @@ decrement_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 decrement_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
 decrement_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
 {
     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);
-    }
-}
-void
-decrement_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_durability_frame_info(framing_extras_, level, timeout);
 }
+
 void
 decrement_request_body::fill_extras()
 {
     extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiry_));
-    using offset_type = std::vector<uint8_t>::difference_type;
+    using offset_type = std::vector<std::byte>::difference_type;
     offset_type offset = 0;
 
     std::uint64_t num = utils::byte_swap(delta_);

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_decrement.hxx

@@ -53,7 +53,7 @@ class decrement_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);
 };
 
@@ -64,12 +64,12 @@ class decrement_request_body
     static const inline client_opcode opcode = client_opcode::decrement;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> framing_extras_{};
     std::uint64_t delta_{ 1 };
     std::uint64_t initial_value_{ 0 };
     std::uint32_t expiry_{ 0 };
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -91,19 +91,17 @@ class decrement_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void preserve_expiry();
-
-    [[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();
@@ -111,7 +109,7 @@ class decrement_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_exists.cxx

@@ -31,12 +31,12 @@ exists_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<std::uint8_t>& body,
+                            const std::vector<std::byte>& body,
                             const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<std::uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
-        using offset_type = std::vector<std::uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size + extras_size + key_size;
 
         memcpy(&partition_id_, body.data() + offset, sizeof(partition_id_));
@@ -52,7 +52,7 @@ exists_response_body::parse(protocol::status status,
         memcpy(key_.data(), body.data() + offset, key_len);
         offset += key_len;
 
-        status_ = body[static_cast<std::size_t>(offset)];
+        status_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
         offset++;
 
         memcpy(&cas_, body.data() + offset, sizeof(cas_));
@@ -65,17 +65,13 @@ void
 exists_request_body::id(std::uint16_t partition_id, const document_id& id)
 {
     partition_id_ = partition_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
 exists_request_body::fill_body()
 {
-    std::vector<std::uint8_t>::size_type offset = 0;
+    std::vector<std::byte>::size_type offset = 0;
 
     value_.resize(2 * sizeof(std::uint16_t) + key_.size());
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_exists.hxx

@@ -34,7 +34,7 @@ class exists_response_body
 
   private:
     std::uint16_t partition_id_;
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint8_t status_;
     std::uint64_t cas_;
 
@@ -49,7 +49,7 @@ class exists_response_body
         return couchbase::cas{ cas_ };
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
@@ -64,7 +64,7 @@ class exists_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);
 };
 
@@ -76,8 +76,8 @@ class exists_request_body
 
   private:
     std::uint16_t partition_id_;
-    std::string key_;
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> value_{};
 
   public:
     void id(std::uint16_t partition_id, const document_id& id);
@@ -88,17 +88,17 @@ class exists_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()
+    [[nodiscard]] const auto& value()
     {
         if (value_.empty()) {
             fill_body();

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get.cxx

@@ -31,10 +31,10 @@ get_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 == 4) {
@@ -54,10 +54,6 @@ get_response_body::parse(protocol::status status,
 void
 get_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);
 }
 } // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get.hxx

@@ -33,19 +33,14 @@ class get_response_body
 
   private:
     std::uint32_t flags_;
-    std::string value_;
+    std::vector<std::byte> value_;
 
   public:
-    [[nodiscard]] const std::string& value() const
+    [[nodiscard]] const auto& value() const
     {
         return value_;
     }
 
-    [[nodiscard]] std::string&& value()
-    {
-        return std::move(value_);
-    }
-
     [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
@@ -56,7 +51,7 @@ class get_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);
 };
 
@@ -67,27 +62,27 @@ class get_request_body
     static const inline client_opcode opcode = client_opcode::get;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
 
   public:
     void id(const document_id& id);
 
-    [[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-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_lock.cxx

@@ -30,10 +30,10 @@ get_and_lock_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 == 4) {
@@ -49,15 +49,13 @@ get_and_lock_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 get_and_lock_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
 get_and_lock_request_body::fill_extras()
 {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_lock.hxx

@@ -33,19 +33,14 @@ class get_and_lock_response_body
 
   private:
     std::uint32_t flags_;
-    std::string value_;
+    std::vector<std::byte> value_;
 
   public:
-    [[nodiscard]] const std::string& value() const
+    [[nodiscard]] const auto& value() const
     {
         return value_;
     }
 
-    [[nodiscard]] std::string&& value()
-    {
-        return std::move(value_);
-    }
-
     [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
@@ -56,7 +51,7 @@ class get_and_lock_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);
 };
 
@@ -67,9 +62,9 @@ class get_and_lock_request_body
     static const inline client_opcode opcode = client_opcode::get_and_lock;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint32_t lock_time_;
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -79,17 +74,17 @@ class get_and_lock_request_body
         lock_time_ = 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()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -97,7 +92,7 @@ class get_and_lock_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_touch.cxx

@@ -30,10 +30,10 @@ get_and_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));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 4) {
@@ -53,11 +53,7 @@ get_and_touch_response_body::parse(protocol::status status,
 void
 get_and_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

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_touch.hxx

@@ -33,19 +33,14 @@ class get_and_touch_response_body
 
   private:
     std::uint32_t flags_;
-    std::string value_;
+    std::vector<std::byte> value_;
 
   public:
-    [[nodiscard]] const std::string& value() const
+    [[nodiscard]] const auto& value() const
     {
         return value_;
     }
 
-    [[nodiscard]] std::string&& value()
-    {
-        return std::move(value_);
-    }
-
     [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
@@ -56,7 +51,7 @@ class get_and_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);
 };
 
@@ -67,9 +62,9 @@ class get_and_touch_request_body
     static const inline client_opcode opcode = client_opcode::get_and_touch;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint32_t expiry_;
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -79,17 +74,17 @@ class get_and_touch_request_body
         expiry_ = 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()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -97,7 +92,7 @@ class get_and_touch_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_cluster_config.cxx

@@ -26,7 +26,7 @@
 namespace couchbase::protocol
 {
 topology::configuration
-parse_config(const std::string& input, std::string_view endpoint_address, uint16_t endpoint_port)
+parse_config(std::string_view input, std::string_view endpoint_address, uint16_t endpoint_port)
 {
     auto config = utils::json::parse(input).as<topology::configuration>();
     for (auto& node : config.nodes) {
@@ -38,7 +38,7 @@ parse_config(const std::string& input, std::string_view endpoint_address, uint16
     // workaround for servers which don't specify this_node
     {
         bool has_this_node = false;
-        for (auto& node : config.nodes) {
+        for (const auto& node : config.nodes) {
             if (node.this_node) {
                 has_this_node = true;
                 break;
@@ -66,16 +66,17 @@ get_cluster_config_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 + key_size + extras_size;
+        std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset, body.size() - static_cast<std::size_t>(offset) };
         try {
-            config_ = parse_config(std::string(body.begin() + offset, body.end()), info.endpoint_address, info.endpoint_port);
+            config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), std::string(body.begin(), body.end()));
+            LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
         }
         return true;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -29,7 +29,7 @@ namespace couchbase::protocol
 {
 
 topology::configuration
-parse_config(const std::string& input, std::string_view endpoint_address, uint16_t endpoint_port);
+parse_config(std::string_view input, std::string_view endpoint_address, uint16_t endpoint_port);
 
 class get_cluster_config_response_body
 {
@@ -50,7 +50,7 @@ class get_cluster_config_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);
 };
 
@@ -65,17 +65,17 @@ class get_cluster_config_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-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_collection_id.cxx

@@ -17,11 +17,14 @@
 
 #include <couchbase/protocol/cmd_get_collection_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
 #include <gsl/assert>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::protocol
 {
 bool
@@ -30,10 +33,10 @@ get_collection_id_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 && extras_size == 12) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size;
 
@@ -47,4 +50,11 @@ get_collection_id_response_body::parse(protocol::status status,
     }
     return false;
 }
+
+void
+get_collection_id_request_body::collection_path(const std::string_view& path)
+{
+    value_.reserve(path.size());
+    utils::to_binary(path, std::back_insert_iterator(value_));
+}
 } // namespace couchbase::protocol