couchbase 3.5.1 → 3.5.2

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

@@ -26,71 +26,71 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 decrement_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) {
-        using offset_type = std::vector<std::byte>::difference_type;
-        offset_type offset = framing_extras_size;
-        if (extras_size == 16) {
-            std::uint64_t partition_uuid{};
-            memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-            partition_uuid = utils::byte_swap(partition_uuid);
-            offset += 8;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    using offset_type = std::vector<std::byte>::difference_type;
+    offset_type offset = framing_extras_size;
+    if (extras_size == 16) {
+      std::uint64_t partition_uuid{};
+      memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
+      partition_uuid = utils::byte_swap(partition_uuid);
+      offset += 8;
 
-            std::uint64_t sequence_number{};
-            memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-            sequence_number = utils::byte_swap(sequence_number);
+      std::uint64_t sequence_number{};
+      memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
+      sequence_number = utils::byte_swap(sequence_number);
 
-            token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
-            offset += 8;
-        }
-        offset += key_size;
-        memcpy(&content_, body.data() + offset, sizeof(content_));
-        content_ = utils::byte_swap(content_);
-        return true;
+      token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
+      offset += 8;
     }
-    return false;
+    offset += key_size;
+    memcpy(&content_, body.data() + offset, sizeof(content_));
+    content_ = utils::byte_swap(content_);
+    return true;
+  }
+  return false;
 }
 
 void
 decrement_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 void
 decrement_request_body::durability(durability_level level, std::optional<std::uint16_t> timeout)
 {
-    if (level == durability_level::none) {
-        return;
-    }
-    add_durability_frame_info(framing_extras_, level, timeout);
+  if (level == durability_level::none) {
+    return;
+  }
+  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<std::byte>::difference_type;
-    offset_type offset = 0;
+  extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiry_));
+  using offset_type = std::vector<std::byte>::difference_type;
+  offset_type offset = 0;
 
-    std::uint64_t num = utils::byte_swap(delta_);
-    memcpy(extras_.data() + offset, &num, sizeof(num));
-    offset += static_cast<offset_type>(sizeof(delta_));
+  std::uint64_t num = utils::byte_swap(delta_);
+  memcpy(extras_.data() + offset, &num, sizeof(num));
+  offset += static_cast<offset_type>(sizeof(delta_));
 
-    num = utils::byte_swap(initial_value_);
-    memcpy(extras_.data() + offset, &num, sizeof(num));
-    offset += static_cast<offset_type>(sizeof(delta_));
+  num = utils::byte_swap(initial_value_);
+  memcpy(extras_.data() + offset, &num, sizeof(num));
+  offset += static_cast<offset_type>(sizeof(delta_));
 
-    std::uint32_t ttl = utils::byte_swap(expiry_);
-    memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
+  std::uint32_t ttl = utils::byte_swap(expiry_);
+  memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
 }
 } // namespace couchbase::core::protocol

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

@@ -31,100 +31,100 @@ namespace couchbase::core::protocol
 
 class decrement_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::decrement;
-
-  private:
-    mutation_token token_{};
-    std::uint64_t content_{};
-
-  public:
-    [[nodiscard]] std::uint64_t content() const
-    {
-        return content_;
-    }
-
-    [[nodiscard]] const mutation_token& token() const
-    {
-        return token_;
-    }
-
-    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::decrement;
+
+private:
+  mutation_token token_{};
+  std::uint64_t content_{};
+
+public:
+  [[nodiscard]] auto content() const -> std::uint64_t
+  {
+    return content_;
+  }
+
+  [[nodiscard]] auto token() const -> const mutation_token&
+  {
+    return token_;
+  }
+
+  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 decrement_request_body
 {
-  public:
-    using response_body_type = decrement_response_body;
-    static const inline client_opcode opcode = client_opcode::decrement;
-
-  private:
-    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::byte> extras_{};
-
-  public:
-    void id(const document_id& id);
-
-    void delta(std::uint64_t value)
-    {
-        delta_ = value;
-    }
-
-    void initial_value(std::uint64_t value)
-    {
-        initial_value_ = value;
-    }
-
-    void expiry(std::uint32_t value)
-    {
-        expiry_ = value;
+public:
+  using response_body_type = decrement_response_body;
+  static const inline client_opcode opcode = client_opcode::decrement;
+
+private:
+  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::byte> extras_{};
+
+public:
+  void id(const document_id& id);
+
+  void delta(std::uint64_t value)
+  {
+    delta_ = value;
+  }
+
+  void initial_value(std::uint64_t value)
+  {
+    initial_value_ = value;
+  }
+
+  void expiry(std::uint32_t value)
+  {
+    expiry_ = value;
+  }
+
+  void durability(durability_level level, std::optional<std::uint16_t> timeout);
+
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
+
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return framing_extras_;
+  }
+
+  [[nodiscard]] auto extras() -> const auto&
+  {
+    if (extras_.empty()) {
+      fill_extras();
     }
-
-    void durability(durability_level level, std::optional<std::uint16_t> timeout);
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
-    }
-
-    [[nodiscard]] const auto& extras()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_.size() + framing_extras_.size() + key_.size();
+    return extras_;
+  }
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    if (extras_.empty()) {
+      fill_extras();
     }
+    return extras_.size() + framing_extras_.size() + key_.size();
+  }
 
-  private:
-    void fill_extras();
+private:
+  void fill_extras();
 };
 
 } // namespace couchbase::core::protocol

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

@@ -25,35 +25,35 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 get_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_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 } // namespace couchbase::core::protocol

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

@@ -28,69 +28,69 @@ namespace couchbase::core::protocol
 
 class get_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::get;
-
-  private:
-    std::uint32_t flags_;
-    std::vector<std::byte> value_;
-
-  public:
-    [[nodiscard]] const auto& value() const
-    {
-        return value_;
-    }
-
-    [[nodiscard]] std::uint32_t flags() const
-    {
-        return flags_;
-    }
-
-    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;
+
+private:
+  std::uint32_t flags_{};
+  std::vector<std::byte> value_;
+
+public:
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return value_;
+  }
+
+  [[nodiscard]] auto flags() const -> std::uint32_t
+  {
+    return flags_;
+  }
+
+  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_request_body
 {
-  public:
-    using response_body_type = get_response_body;
-    static const inline client_opcode opcode = client_opcode::get;
-
-  private:
-    std::vector<std::byte> key_;
-
-  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 empty_buffer;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] std::size_t size() const
-    {
-        return key_.size();
-    }
+public:
+  using response_body_type = get_response_body;
+  static const inline client_opcode opcode = client_opcode::get;
+
+private:
+  std::vector<std::byte> key_;
+
+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 empty_buffer;
+  }
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto size() const -> std::size_t
+  {
+    return key_.size();
+  }
 };
 
 } // namespace couchbase::core::protocol

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

@@ -24,43 +24,43 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 get_and_lock_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_and_lock_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 void
 get_and_lock_request_body::fill_extras()
 {
-    extras_.resize(sizeof(lock_time_));
-    std::uint32_t field = utils::byte_swap(lock_time_);
-    memcpy(extras_.data(), &field, sizeof(field));
+  extras_.resize(sizeof(lock_time_));
+  std::uint32_t field = utils::byte_swap(lock_time_);
+  memcpy(extras_.data(), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol