couchbase 4.3.1 → 4.4.0

package/deps/couchbase-cxx-client/core/protocol/cmd_get_meta.hxx

@@ -29,89 +29,91 @@ namespace couchbase::core::protocol
 
 class get_meta_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::get_meta;
-
-  private:
-    std::uint32_t deleted_;
-    std::uint32_t flags_;
-    std::uint32_t expiry_;
-    std::uint64_t sequence_number_;
-    std::uint8_t datatype_;
-
-  public:
-    [[nodiscard]] bool is_deleted() const
-    {
-        return deleted_ != 0;
-    }
-
-    [[nodiscard]] std::uint32_t flags() const
-    {
-        return flags_;
-    }
-
-    [[nodiscard]] std::uint32_t expiry() const
-    {
-        return expiry_;
-    }
-
-    [[nodiscard]] std::uint64_t sequence_number() const
-    {
-        return sequence_number_;
-    }
-
-    [[nodiscard]] std::uint8_t datatype() const
-    {
-        return datatype_;
-    }
-
-    bool parse(key_value_status_code status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t key_size,
-               std::uint8_t extras_size,
-               const std::vector<std::byte>& body,
-               const cmd_info& info);
+public:
+  static const inline client_opcode opcode = client_opcode::get_meta;
+
+private:
+  std::uint32_t deleted_{};
+  std::uint32_t flags_{};
+  std::uint32_t expiry_{};
+  std::uint64_t sequence_number_{};
+  std::uint8_t datatype_{};
+
+public:
+  [[nodiscard]] auto is_deleted() const -> bool
+  {
+    return deleted_ != 0;
+  }
+
+  [[nodiscard]] auto flags() const -> std::uint32_t
+  {
+    return flags_;
+  }
+
+  [[nodiscard]] auto expiry() const -> std::uint32_t
+  {
+    return expiry_;
+  }
+
+  [[nodiscard]] auto sequence_number() const -> std::uint64_t
+  {
+    return sequence_number_;
+  }
+
+  [[nodiscard]] auto datatype() const -> std::uint8_t
+  {
+    return datatype_;
+  }
+
+  auto parse(key_value_status_code status,
+             const header_buffer& header,
+             std::uint8_t framing_extras_size,
+             std::uint16_t key_size,
+             std::uint8_t extras_size,
+             const std::vector<std::byte>& body,
+             const cmd_info& info) -> bool;
 };
 
 class get_meta_request_body
 {
-  public:
-    using response_body_type = get_meta_response_body;
-    static const inline client_opcode opcode = client_opcode::get_meta;
-
-  private:
-    std::vector<std::byte> key_;
-    std::vector<std::byte> extras_{ std::byte{ 0x02 },
-                                    /* format version, supported since Couchbase Server 5.0, includes datatype into response */ };
-
-  public:
-    void id(const document_id& id);
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& extras() const
-    {
-        return extras_;
-    }
-
-    [[nodiscard]] const auto& value()
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        return extras_.size() + key_.size();
-    }
+public:
+  using response_body_type = get_meta_response_body;
+  static const inline client_opcode opcode = client_opcode::get_meta;
+
+private:
+  std::vector<std::byte> key_;
+  std::vector<std::byte> extras_{
+    std::byte{ 0x02 },
+    /* format version, supported since Couchbase Server 5.0, includes datatype into response */
+  };
+
+public:
+  void id(const document_id& id);
+
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
+
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto extras() const -> const auto&
+  {
+    return extras_;
+  }
+
+  [[nodiscard]] auto value() -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    return extras_.size() + key_.size();
+  }
 };
 
 } // namespace couchbase::core::protocol

package/deps/couchbase-cxx-client/core/protocol/cmd_get_replica.cxx

@@ -25,47 +25,47 @@
 
 namespace couchbase::core::protocol
 {
-std::uint32_t
-get_replica_response_body::flags() const
+auto
+get_replica_response_body::flags() const -> std::uint32_t
 {
-    return flags_;
+  return flags_;
 }
 
-bool
+auto
 get_replica_response_body::parse(key_value_status_code status,
                                  const header_buffer& header,
                                  std::uint8_t framing_extras_size,
                                  std::uint16_t key_size,
                                  std::uint8_t extras_size,
                                  const std::vector<std::byte>& body,
-                                 const cmd_info& /* info */)
+                                 const cmd_info& /* info */) -> bool
 {
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    if (status == key_value_status_code::success) {
-        std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
-        if (extras_size == 4) {
-            memcpy(&flags_, body.data() + offset, sizeof(flags_));
-            flags_ = utils::byte_swap(flags_);
-            offset += 4;
-        } else {
-            offset += extras_size;
-        }
-        offset += key_size;
-        value_.assign(body.begin() + offset, body.end());
-        return true;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
+    if (extras_size == 4) {
+      memcpy(&flags_, body.data() + offset, sizeof(flags_));
+      flags_ = utils::byte_swap(flags_);
+      offset += 4;
+    } else {
+      offset += extras_size;
     }
-    return false;
+    offset += key_size;
+    value_.assign(body.begin() + offset, body.end());
+    return true;
+  }
+  return false;
 }
 
 void
 get_replica_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
-std::size_t
-get_replica_request_body::size() const
+auto
+get_replica_request_body::size() const -> std::size_t
 {
-    return key_.size();
+  return key_.size();
 }
 } // namespace couchbase::core::protocol

package/deps/couchbase-cxx-client/core/protocol/cmd_get_replica.hxx

@@ -28,61 +28,61 @@ namespace couchbase::core::protocol
 
 class get_replica_response_body
 {
-  private:
-    std::uint32_t flags_{};
-    std::vector<std::byte> value_{};
-
-  public:
-    static const inline client_opcode opcode = client_opcode::get_replica;
-
-    [[nodiscard]] const auto& value() const
-    {
-        return value_;
-    }
-
-    [[nodiscard]] std::uint32_t flags() const;
-
-    [[nodiscard]] bool parse(key_value_status_code status,
-                             const header_buffer& header,
-                             std::uint8_t framing_extras_size,
-                             std::uint16_t key_size,
-                             std::uint8_t extras_size,
-                             const std::vector<std::byte>& body,
-                             const cmd_info& info);
+private:
+  std::uint32_t flags_{};
+  std::vector<std::byte> value_{};
+
+public:
+  static const inline client_opcode opcode = client_opcode::get_replica;
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return value_;
+  }
+
+  [[nodiscard]] auto flags() const -> std::uint32_t;
+
+  [[nodiscard]] auto parse(key_value_status_code status,
+                           const header_buffer& header,
+                           std::uint8_t framing_extras_size,
+                           std::uint16_t key_size,
+                           std::uint8_t extras_size,
+                           const std::vector<std::byte>& body,
+                           const cmd_info& info) -> bool;
 };
 
 class get_replica_request_body
 {
-  private:
-    std::vector<std::byte> key_;
+private:
+  std::vector<std::byte> key_;
 
-  public:
-    using response_body_type = get_replica_response_body;
-    static const inline client_opcode opcode = client_opcode::get_replica;
+public:
+  using response_body_type = get_replica_response_body;
+  static const inline client_opcode opcode = client_opcode::get_replica;
 
-    void id(const document_id& id);
+  void id(const document_id& id);
 
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
 
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return empty_buffer;
-    }
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
 
-    [[nodiscard]] const auto& extras() const
-    {
-        return empty_buffer;
-    }
+  [[nodiscard]] auto extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
 
-    [[nodiscard]] const auto& value() const
-    {
-        return empty_buffer;
-    }
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return empty_buffer;
+  }
 
-    [[nodiscard]] std::size_t size() const;
+  [[nodiscard]] auto size() const -> std::size_t;
 };
 
 } // namespace couchbase::core::protocol

package/deps/couchbase-cxx-client/core/protocol/cmd_hello.cxx

@@ -27,50 +27,51 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 hello_response_body::parse(key_value_status_code status,
                            const header_buffer& header,
                            std::uint8_t framing_extras_size,
                            std::uint16_t key_size,
                            std::uint8_t extras_size,
                            const std::vector<std::byte>& body,
-                           const cmd_info& /* info */)
+                           const cmd_info& /* info */) -> bool
 {
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    if (status == key_value_status_code::success) {
-        std::vector<std::uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
-        size_t value_size = body.size() - static_cast<std::size_t>(offset);
-        Expects(value_size % 2 == 0);
-        size_t num_features = value_size / 2;
-        supported_features_.reserve(num_features);
-        const auto* value = body.data() + offset;
-        for (size_t i = 0; i < num_features; i++) {
-            std::uint16_t field = 0;
-            std::memcpy(&field, value + i * 2, sizeof(std::uint16_t));
-            field = utils::byte_swap(field);
-            if (is_valid_hello_feature(field)) {
-                supported_features_.push_back(static_cast<hello_feature>(field));
-            }
-        }
-        return true;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    std::vector<std::uint8_t>::difference_type offset =
+      framing_extras_size + key_size + extras_size;
+    size_t value_size = body.size() - static_cast<std::size_t>(offset);
+    Expects(value_size % 2 == 0);
+    size_t num_features = value_size / 2;
+    supported_features_.reserve(num_features);
+    const auto* value = body.data() + offset;
+    for (size_t i = 0; i < num_features; i++) {
+      std::uint16_t field = 0;
+      std::memcpy(&field, value + i * 2, sizeof(std::uint16_t));
+      field = utils::byte_swap(field);
+      if (is_valid_hello_feature(field)) {
+        supported_features_.push_back(static_cast<hello_feature>(field));
+      }
     }
-    return false;
+    return true;
+  }
+  return false;
 }
 
 void
 hello_request_body::fill_body()
 {
-    value_.resize(2 * features_.size());
-    for (std::size_t idx = 0; idx < features_.size(); idx++) {
-        value_[idx * 2] = std::byte{ 0 }; // we don't need this byte while feature codes fit the 8-bit
-        value_[idx * 2 + 1] = static_cast<std::byte>(features_[idx]);
-    }
+  value_.resize(2 * features_.size());
+  for (std::size_t idx = 0; idx < features_.size(); idx++) {
+    value_[idx * 2] = std::byte{ 0 }; // we don't need this byte while feature codes fit the 8-bit
+    value_[idx * 2 + 1] = static_cast<std::byte>(features_[idx]);
+  }
 }
 
 void
 hello_request_body::user_agent(std::string_view val)
 {
-    key_.reserve(val.size());
-    utils::to_binary(val, std::back_insert_iterator(key_));
+  key_.reserve(val.size());
+  utils::to_binary(val, std::back_insert_iterator(key_));
 }
 } // namespace couchbase::core::protocol

package/deps/couchbase-cxx-client/core/protocol/cmd_hello.hxx

@@ -28,119 +28,120 @@ namespace couchbase::core::protocol
 
 class hello_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::hello;
-
-  private:
-    std::vector<hello_feature> supported_features_;
-
-  public:
-    [[nodiscard]] const std::vector<hello_feature>& supported_features() const
-    {
-        return supported_features_;
-    }
-
-    bool parse(key_value_status_code status,
-               const header_buffer& header,
-               std::uint8_t framing_extras_size,
-               std::uint16_t key_size,
-               std::uint8_t extras_size,
-               const std::vector<std::byte>& body,
-               const cmd_info& info);
+public:
+  static const inline client_opcode opcode = client_opcode::hello;
+
+private:
+  std::vector<hello_feature> supported_features_;
+
+public:
+  [[nodiscard]] auto supported_features() const -> const std::vector<hello_feature>&
+  {
+    return supported_features_;
+  }
+
+  auto parse(key_value_status_code status,
+             const header_buffer& header,
+             std::uint8_t framing_extras_size,
+             std::uint16_t key_size,
+             std::uint8_t extras_size,
+             const std::vector<std::byte>& body,
+             const cmd_info& info) -> bool;
 };
 
 class hello_request_body
 {
-  public:
-    using response_body_type = hello_response_body;
-    static const inline client_opcode opcode = client_opcode::hello;
-
-  private:
-    std::vector<std::byte> key_;
-    std::vector<hello_feature> features_{
-        hello_feature::tcp_nodelay,
-        hello_feature::xattr,
-        hello_feature::xerror,
-        hello_feature::select_bucket,
-        hello_feature::json,
-        hello_feature::duplex,
-        hello_feature::alt_request_support,
-        hello_feature::tracing,
-        hello_feature::sync_replication,
-        hello_feature::vattr,
-        hello_feature::collections,
-        hello_feature::subdoc_create_as_deleted,
-        hello_feature::preserve_ttl,
-        hello_feature::subdoc_replica_read,
-    };
-    std::vector<std::byte> value_;
-
-  public:
-    void user_agent(std::string_view val);
-
-    void enable_unordered_execution()
-    {
-        features_.emplace_back(hello_feature::unordered_execution);
-    }
-
-    void enable_clustermap_change_notification()
-    {
-        features_.emplace_back(hello_feature::clustermap_change_notification);
-    }
-
-    void enable_deduplicate_not_my_vbucket_clustermap()
-    {
-        features_.emplace_back(hello_feature::deduplicate_not_my_vbucket_clustermap);
-    }
-
-    void enable_compression()
-    {
-        features_.emplace_back(hello_feature::snappy);
-    }
-
-    void enable_mutation_tokens()
-    {
-        features_.emplace_back(hello_feature::mutation_seqno);
-    }
-
-    [[nodiscard]] const std::vector<hello_feature>& features() const
-    {
-        return features_;
-    }
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& value()
-    {
-        if (value_.empty()) {
-            fill_body();
-        }
-        return value_;
+public:
+  using response_body_type = hello_response_body;
+  static const inline client_opcode opcode = client_opcode::hello;
+
+private:
+  std::vector<std::byte> key_;
+  std::vector<hello_feature> features_{
+    hello_feature::tcp_nodelay,
+    hello_feature::xattr,
+    hello_feature::xerror,
+    hello_feature::select_bucket,
+    hello_feature::json,
+    hello_feature::duplex,
+    hello_feature::alt_request_support,
+    hello_feature::tracing,
+    hello_feature::sync_replication,
+    hello_feature::vattr,
+    hello_feature::collections,
+    hello_feature::subdoc_create_as_deleted,
+    hello_feature::preserve_ttl,
+    hello_feature::subdoc_replica_read,
+    hello_feature::subdoc_binary_xattr,
+  };
+  std::vector<std::byte> value_;
+
+public:
+  void user_agent(std::string_view val);
+
+  void enable_unordered_execution()
+  {
+    features_.emplace_back(hello_feature::unordered_execution);
+  }
+
+  void enable_clustermap_change_notification()
+  {
+    features_.emplace_back(hello_feature::clustermap_change_notification);
+  }
+
+  void enable_deduplicate_not_my_vbucket_clustermap()
+  {
+    features_.emplace_back(hello_feature::deduplicate_not_my_vbucket_clustermap);
+  }
+
+  void enable_compression()
+  {
+    features_.emplace_back(hello_feature::snappy);
+  }
+
+  void enable_mutation_tokens()
+  {
+    features_.emplace_back(hello_feature::mutation_seqno);
+  }
+
+  [[nodiscard]] auto features() const -> const std::vector<hello_feature>&
+  {
+    return features_;
+  }
+
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
+
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto value() -> const auto&
+  {
+    if (value_.empty()) {
+      fill_body();
     }
+    return value_;
+  }
 
-    [[nodiscard]] std::size_t size()
-    {
-        if (value_.empty()) {
-            fill_body();
-        }
-        return key_.size() + value_.size();
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    if (value_.empty()) {
+      fill_body();
     }
+    return key_.size() + value_.size();
+  }
 
-  private:
-    void fill_body();
+private:
+  void fill_body();
 };
 
 } // namespace couchbase::core::protocol