couchbase 3.5.1 → 3.5.3

data/ext/couchbase/core/protocol/cmd_get_collection_id.hxx

@@ -27,69 +27,69 @@ namespace couchbase::core::protocol
 
 class get_collection_id_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::get_collection_id;
-
-  private:
-    std::uint64_t manifest_uid_;
-    std::uint32_t collection_uid_;
-
-  public:
-    [[nodiscard]] std::uint64_t manifest_uid() const
-    {
-        return manifest_uid_;
-    }
-
-    [[nodiscard]] std::uint32_t collection_uid() const
-    {
-        return collection_uid_;
-    }
-
-    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_collection_id;
+
+private:
+  std::uint64_t manifest_uid_{};
+  std::uint32_t collection_uid_{};
+
+public:
+  [[nodiscard]] auto manifest_uid() const -> std::uint64_t
+  {
+    return manifest_uid_;
+  }
+
+  [[nodiscard]] auto collection_uid() const -> std::uint32_t
+  {
+    return collection_uid_;
+  }
+
+  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_collection_id_request_body
 {
-  public:
-    using response_body_type = get_collection_id_response_body;
-    static const inline client_opcode opcode = client_opcode::get_collection_id;
-
-  private:
-    std::vector<std::byte> value_{};
-
-  public:
-    void collection_path(const std::string_view& path);
-
-    [[nodiscard]] const std::string& key() const
-    {
-        return empty_string;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return value_;
-    }
-
-    [[nodiscard]] std::size_t size() const
-    {
-        return value_.size();
-    }
+public:
+  using response_body_type = get_collection_id_response_body;
+  static const inline client_opcode opcode = client_opcode::get_collection_id;
+
+private:
+  std::vector<std::byte> value_{};
+
+public:
+  void collection_path(const std::string_view& path);
+
+  [[nodiscard]] auto key() const -> const std::string&
+  {
+    return empty_string;
+  }
+
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return value_;
+  }
+
+  [[nodiscard]] auto size() const -> std::size_t
+  {
+    return value_.size();
+  }
 };
 
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_collections_manifest.cxx

@@ -22,30 +22,33 @@
 #include "core/utils/json.hxx"
 
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 get_collections_manifest_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;
-        std::string_view manifest_text{ reinterpret_cast<const char*>(body.data()) + offset,
-                                        body.size() - static_cast<std::size_t>(offset) };
-        try {
-            manifest_ = utils::json::parse(manifest_text).as<topology::collections_manifest>();
-        } catch (const tao::pegtl::parse_error& e) {
-            CB_LOG_DEBUG("unable to parse collections manifest as JSON: {}, {}", e.message(), manifest_text);
-        }
-        return true;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    const std::vector<std::uint8_t>::difference_type offset =
+      framing_extras_size + key_size + extras_size;
+    std::string_view manifest_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                    body.size() - static_cast<std::size_t>(offset) };
+    try {
+      manifest_ = utils::json::parse(manifest_text).as<topology::collections_manifest>();
+    } catch (const tao::pegtl::parse_error& e) {
+      CB_LOG_DEBUG(
+        "unable to parse collections manifest as JSON: {}, {}", e.message(), manifest_text);
     }
-    return false;
+    return true;
+  }
+  return false;
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_collections_manifest.hxx

@@ -28,57 +28,57 @@ namespace couchbase::core::protocol
 
 class get_collections_manifest_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::get_collections_manifest;
+public:
+  static const inline client_opcode opcode = client_opcode::get_collections_manifest;
 
-  private:
-    topology::collections_manifest manifest_;
+private:
+  topology::collections_manifest manifest_;
 
-  public:
-    [[nodiscard]] const couchbase::core::topology::collections_manifest& manifest() const
-    {
-        return manifest_;
-    }
+public:
+  [[nodiscard]] auto manifest() const -> const couchbase::core::topology::collections_manifest&
+  {
+    return manifest_;
+  }
 
-    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);
+  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_collections_manifest_request_body
 {
-  public:
-    using response_body_type = get_collections_manifest_response_body;
-    static const inline client_opcode opcode = client_opcode::get_collections_manifest;
+public:
+  using response_body_type = get_collections_manifest_response_body;
+  static const inline client_opcode opcode = client_opcode::get_collections_manifest;
 
-    [[nodiscard]] const std::string& key() const
-    {
-        return empty_string;
-    }
+  [[nodiscard]] auto key() const -> const std::string&
+  {
+    return empty_string;
+  }
 
-    [[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
-    {
-        return 0;
-    }
+  [[nodiscard]] auto size() const -> std::size_t
+  {
+    return 0;
+  }
 };
 
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_error_map.cxx

@@ -24,38 +24,40 @@
 
 #include <cstring>
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 get_error_map_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;
-        std::string_view error_map_text{ reinterpret_cast<const char*>(body.data()) + offset,
-                                         body.size() - static_cast<std::size_t>(offset) };
-        try {
-            errmap_ = utils::json::parse(error_map_text).as<error_map>();
-        } catch (const tao::pegtl::parse_error& e) {
-            CB_LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), error_map_text);
-        }
-        return true;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    const std::vector<std::uint8_t>::difference_type offset =
+      framing_extras_size + key_size + extras_size;
+    std::string_view error_map_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                     body.size() - static_cast<std::size_t>(offset) };
+    try {
+      errmap_ = utils::json::parse(error_map_text).as<error_map>();
+    } catch (const tao::pegtl::parse_error& e) {
+      CB_LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), error_map_text);
     }
-    return false;
+    return true;
+  }
+  return false;
 }
 
 void
 get_error_map_request_body::fill_body()
 {
-    std::uint16_t version = utils::byte_swap(version_);
-    value_.resize(sizeof(version));
-    std::memcpy(value_.data(), &version, sizeof(version));
+  std::uint16_t version = utils::byte_swap(version_);
+  value_.resize(sizeof(version));
+  std::memcpy(value_.data(), &version, sizeof(version));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_error_map.hxx

@@ -28,76 +28,76 @@ namespace couchbase::core::protocol
 
 class get_error_map_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::get_error_map;
-
-  private:
-    error_map errmap_{};
-
-  public:
-    [[nodiscard]] const couchbase::core::error_map& errmap() const
-    {
-        return errmap_;
-    }
-
-    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_error_map;
+
+private:
+  error_map errmap_{};
+
+public:
+  [[nodiscard]] auto errmap() const -> const couchbase::core::error_map&
+  {
+    return errmap_;
+  }
+
+  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_error_map_request_body
 {
-  public:
-    using response_body_type = get_error_map_response_body;
-    static const inline client_opcode opcode = client_opcode::get_error_map;
-
-  private:
-    std::uint16_t version_{ 2 };
-    std::vector<std::byte> value_;
-
-  public:
-    void version(std::uint16_t version)
-    {
-        version_ = version;
-    }
-
-    [[nodiscard]] const std::string& key() const
-    {
-        return empty_string;
-    }
-
-    [[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 = get_error_map_response_body;
+  static const inline client_opcode opcode = client_opcode::get_error_map;
+
+private:
+  std::uint16_t version_{ 2 };
+  std::vector<std::byte> value_;
+
+public:
+  void version(std::uint16_t version)
+  {
+    version_ = version;
+  }
+
+  [[nodiscard]] auto key() const -> const std::string&
+  {
+    return empty_string;
+  }
+
+  [[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 value_.size();
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    if (value_.empty()) {
+      fill_body();
     }
+    return value_.size();
+  }
 
-  private:
-    void fill_body();
+private:
+  void fill_body();
 };
 
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_meta.cxx

@@ -25,46 +25,47 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 get_meta_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 == sizeof(deleted_) + sizeof(flags_) + sizeof(expiry_) + sizeof(sequence_number_) + sizeof(datatype_)) {
-            memcpy(&deleted_, body.data() + offset, sizeof(deleted_));
-            deleted_ = utils::byte_swap(deleted_);
-            offset += 4;
+  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 == sizeof(deleted_) + sizeof(flags_) + sizeof(expiry_) +
+                         sizeof(sequence_number_) + sizeof(datatype_)) {
+      memcpy(&deleted_, body.data() + offset, sizeof(deleted_));
+      deleted_ = utils::byte_swap(deleted_);
+      offset += 4;
 
-            memcpy(&flags_, body.data() + offset, sizeof(flags_));
-            flags_ = utils::byte_swap(flags_);
-            offset += 4;
+      memcpy(&flags_, body.data() + offset, sizeof(flags_));
+      flags_ = utils::byte_swap(flags_);
+      offset += 4;
 
-            memcpy(&expiry_, body.data() + offset, sizeof(expiry_));
-            expiry_ = utils::byte_swap(expiry_);
-            offset += 4;
+      memcpy(&expiry_, body.data() + offset, sizeof(expiry_));
+      expiry_ = utils::byte_swap(expiry_);
+      offset += 4;
 
-            memcpy(&sequence_number_, body.data() + offset, sizeof(sequence_number_));
-            sequence_number_ = utils::byte_swap(sequence_number_);
-            offset += 8;
+      memcpy(&sequence_number_, body.data() + offset, sizeof(sequence_number_));
+      sequence_number_ = utils::byte_swap(sequence_number_);
+      offset += 8;
 
-            datatype_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
-        }
-        return true;
+      datatype_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
     }
-    return false;
+    return true;
+  }
+  return false;
 }
 
 void
 get_meta_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 } // namespace couchbase::core::protocol