couchbase 3.5.1 → 3.5.3

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

@@ -28,54 +28,54 @@ namespace couchbase::core::protocol
 
 class unlock_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::unlock;
+public:
+  static const inline client_opcode opcode = client_opcode::unlock;
 
-    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 unlock_request_body
 {
-  public:
-    using response_body_type = unlock_response_body;
-    static const inline client_opcode opcode = client_opcode::unlock;
+public:
+  using response_body_type = unlock_response_body;
+  static const inline client_opcode opcode = client_opcode::unlock;
 
-  private:
-    std::vector<std::byte> key_;
+private:
+  std::vector<std::byte> key_;
 
-  public:
-    void id(const document_id& id);
+public:
+  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
-    {
-        return key_.size();
-    }
+  [[nodiscard]] auto size() const -> std::size_t
+  {
+    return key_.size();
+  }
 };
 
 } // namespace couchbase::core::protocol

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

@@ -28,65 +28,65 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 upsert_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 == 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) {
+    std::vector<std::uint8_t>::difference_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);
-            return true;
-        }
+      token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 void
 upsert_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 void
 upsert_request_body::durability(durability_level level, std::optional<std::uint16_t> timeout)
 {
-    if (level == durability_level::none) {
-        return;
-    }
+  if (level == durability_level::none) {
+    return;
+  }
 
-    add_durability_frame_info(framing_extras_, level, timeout);
+  add_durability_frame_info(framing_extras_, level, timeout);
 }
 
 void
 upsert_request_body::preserve_expiry()
 {
-    add_preserve_expiry_frame_info(framing_extras_);
+  add_preserve_expiry_frame_info(framing_extras_);
 }
 
 void
 upsert_request_body::fill_extras()
 {
-    extras_.resize(sizeof(flags_) + sizeof(expiry_));
+  extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
-    std::uint32_t field = utils::byte_swap(flags_);
-    memcpy(extras_.data(), &field, sizeof(field));
+  std::uint32_t field = utils::byte_swap(flags_);
+  memcpy(extras_.data(), &field, sizeof(field));
 
-    field = utils::byte_swap(expiry_);
-    memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
+  field = utils::byte_swap(expiry_);
+  memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

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

@@ -31,96 +31,96 @@ namespace couchbase::core::protocol
 
 class upsert_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::upsert;
-
-  private:
-    mutation_token token_;
-
-  public:
-    [[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::upsert;
+
+private:
+  mutation_token token_;
+
+public:
+  [[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 upsert_request_body
 {
-  public:
-    using response_body_type = upsert_response_body;
-    static const inline client_opcode opcode = client_opcode::upsert;
-
-  private:
-    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::byte> framing_extras_{};
-
-  public:
-    void id(const document_id& id);
-
-    void durability(durability_level level, std::optional<std::uint16_t> timeout);
-
-    void preserve_expiry();
-
-    void content(const std::vector<std::byte>& content)
-    {
-        content_ = { content.begin(), content.end() };
-    }
-
-    void flags(std::uint32_t flags)
-    {
-        flags_ = flags;
+public:
+  using response_body_type = upsert_response_body;
+  static const inline client_opcode opcode = client_opcode::upsert;
+
+private:
+  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::byte> framing_extras_{};
+
+public:
+  void id(const document_id& id);
+
+  void durability(durability_level level, std::optional<std::uint16_t> timeout);
+
+  void preserve_expiry();
+
+  void content(const std::vector<std::byte>& content)
+  {
+    content_ = { content.begin(), content.end() };
+  }
+
+  void flags(std::uint32_t flags)
+  {
+    flags_ = flags;
+  }
+
+  void expiry(std::uint32_t value)
+  {
+    expiry_ = value;
+  }
+
+  [[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 expiry(std::uint32_t value)
-    {
-        expiry_ = value;
-    }
-
-    [[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 content_;
-    }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return framing_extras_.size() + extras_.size() + key_.size() + content_.size();
+    return extras_;
+  }
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return content_;
+  }
+
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    if (extras_.empty()) {
+      fill_extras();
     }
+    return framing_extras_.size() + extras_.size() + key_.size() + content_.size();
+  }
 
-  private:
-    void fill_extras();
+private:
+  void fill_extras();
 };
 
 } // namespace couchbase::core::protocol

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

@@ -17,32 +17,33 @@
 
 #pragma once
 
+#include <cstdint>
+
 namespace couchbase::core::protocol
 {
 enum class datatype : std::uint8_t {
-    raw = 0x00,
-    json = 0x01,
-    snappy = 0x02,
-    xattr = 0x04,
-
+  raw = 0x00,
+  json = 0x01,
+  snappy = 0x02,
+  xattr = 0x04,
 };
 
-constexpr bool
-is_valid_datatype(std::uint8_t code)
+constexpr auto
+is_valid_datatype(std::uint8_t code) -> bool
 {
-    switch (static_cast<datatype>(code)) {
-        case datatype::raw:
-        case datatype::json:
-        case datatype::snappy:
-        case datatype::xattr:
-            return true;
-    }
-    return false;
+  switch (static_cast<datatype>(code)) {
+    case datatype::raw:
+    case datatype::json:
+    case datatype::snappy:
+    case datatype::xattr:
+      return true;
+  }
+  return false;
 }
 
-constexpr bool
-has_json_datatype(std::uint8_t code)
+constexpr auto
+has_json_datatype(std::uint8_t code) -> bool
 {
-    return (code & static_cast<std::uint8_t>(datatype::json)) != 0;
+  return (code & static_cast<std::uint8_t>(datatype::json)) != 0;
 }
 } // namespace couchbase::core::protocol

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

@@ -20,123 +20,128 @@
 namespace couchbase::core::protocol
 {
 enum class request_frame_info_id : std::uint8_t {
-    /**
-     * No commands may be executed in parallel (received on the same connection) as this command (the command before MUST be completed
-     * before execution of this command is started, and this command MUST be completed before execution of the next command is started).
-     * FrameInfo encoded as:
-     *
-     *    Byte/     0       |
-     *       /              |
-     *      |0 1 2 3 4 5 6 7|
-     *      +---------------+
-     *     0|  ID:0 | Len:0 |
-     */
-    barrier = 0x00,
+  /**
+   * No commands may be executed in parallel (received on the same connection) as this command (the
+   * command before MUST be completed before execution of this command is started, and this command
+   * MUST be completed before execution of the next command is started). FrameInfo encoded as:
+   *
+   *    Byte/     0       |
+   *       /              |
+   *      |0 1 2 3 4 5 6 7|
+   *      +---------------+
+   *     0|  ID:0 | Len:0 |
+   */
+  barrier = 0x00,
 
-    /**
-     * This command contains durability requirements. FrameInfo encoded as:
-     *
-     *    Byte/     0            |
-     *       /                   |
-     *      |   0 1 2 3 4 5 6 7  |
-     *      +--------------------+
-     *     0|  ID:1 | Len:1 or 3 |
-     *
-     * The size of the durability requirement is variable length. The first byte contains the durability level by using the following table:
-     *
-     *    0x01 = majority
-     *    0x02 = majority and persist on master
-     *    0x03 = persist to majority
-     *
-     * The (optional) 2nd and 3rd byte contains the timeout specified in milliseconds (network byte order). If the timeout is omitted the
-     * default timeout value configured on the server will be used.
-     *
-     * If timeout is specified, the valid range is 1..65535. Values 0x0 and 0xffff are reserved and will result in the request failing with
-     * invalid_argument (0x4) if used.
-     */
-    durability_requirement = 0x01,
+  /**
+   * This command contains durability requirements. FrameInfo encoded as:
+   *
+   *    Byte/     0            |
+   *       /                   |
+   *      |   0 1 2 3 4 5 6 7  |
+   *      +--------------------+
+   *     0|  ID:1 | Len:1 or 3 |
+   *
+   * The size of the durability requirement is variable length. The first byte contains the
+   * durability level by using the following table:
+   *
+   *    0x01 = majority
+   *    0x02 = majority and persist on master
+   *    0x03 = persist to majority
+   *
+   * The (optional) 2nd and 3rd byte contains the timeout specified in milliseconds (network byte
+   * order). If the timeout is omitted the default timeout value configured on the server will be
+   * used.
+   *
+   * If timeout is specified, the valid range is 1..65535. Values 0x0 and 0xffff are reserved and
+   * will result in the request failing with invalid_argument (0x4) if used.
+   */
+  durability_requirement = 0x01,
 
-    /**
-     * This command contains a DCP stream-ID as per the stream-request which created the stream.
-     *
-     *     Byte/     0       |
-     *        /              |
-     *       |0 1 2 3 4 5 6 7|
-     *       +---------------+
-     *      0|  ID:2 | Len:2 |
-     *
-     * The 2nd and 3rd byte contain a network byte order (std::uint16) storing the stream ID value which was specified in the DCP
-     * stream-request that created the stream.
-     */
-    dcp_stream_id = 0x02,
+  /**
+   * This command contains a DCP stream-ID as per the stream-request which created the stream.
+   *
+   *     Byte/     0       |
+   *        /              |
+   *       |0 1 2 3 4 5 6 7|
+   *       +---------------+
+   *      0|  ID:2 | Len:2 |
+   *
+   * The 2nd and 3rd byte contain a network byte order (std::uint16) storing the stream ID value
+   * which was specified in the DCP stream-request that created the stream.
+   */
+  dcp_stream_id = 0x02,
 
-    /**
-     * Request the server to submit trace information by using the supplied context information as the parent span. The context must be
-     * present (length > 0)
-     */
-    open_tracing_context = 0x03,
+  /**
+   * Request the server to submit trace information by using the supplied context information as the
+   * parent span. The context must be present (length > 0)
+   */
+  open_tracing_context = 0x03,
 
-    /**
-     * Request the server to execute the command as the provided user username (must be present) to identify users defined outside Couchbase
-     * (ldap) the username must be prefixed with ^ (ex: ^trond). Local users do not need a prefix.
-     *
-     * The authenticated user must possess the impersonate privilege in order to utilize the feature (otherwise an error will be returned),
-     * and the effective privilege set when executing the command is an intersection of the authenticated users privilege set and the
-     * impersonated persons privilege set.
-     */
-    impersonate_user = 0x04,
+  /**
+   * Request the server to execute the command as the provided user username (must be present) to
+   * identify users defined outside Couchbase (ldap) the username must be prefixed with ^ (ex:
+   * ^trond). Local users do not need a prefix.
+   *
+   * The authenticated user must possess the impersonate privilege in order to utilize the feature
+   * (otherwise an error will be returned), and the effective privilege set when executing the
+   * command is an intersection of the authenticated users privilege set and the impersonated
+   * persons privilege set.
+   */
+  impersonate_user = 0x04,
 
-    /**
-     * If the request modifies an existing document the expiry time from the existing document should be used instead of the TTL provided.
-     * If document don't exist the provided TTL should be used. The frame info contains no value (length = 0).
-     */
-    preserve_ttl = 0x05,
+  /**
+   * If the request modifies an existing document the expiry time from the existing document should
+   * be used instead of the TTL provided. If document don't exist the provided TTL should be used.
+   * The frame info contains no value (length = 0).
+   */
+  preserve_ttl = 0x05,
 };
 
-constexpr bool
-is_valid_request_frame_info_id(std::uint8_t value)
+constexpr auto
+is_valid_request_frame_info_id(std::uint8_t value) -> bool
 {
-    switch (request_frame_info_id(value)) {
-        case request_frame_info_id::barrier:
-        case request_frame_info_id::durability_requirement:
-        case request_frame_info_id::dcp_stream_id:
-        case request_frame_info_id::open_tracing_context:
-        case request_frame_info_id::impersonate_user:
-        case request_frame_info_id::preserve_ttl:
-            return true;
-    }
-    return false;
+  switch (request_frame_info_id(value)) {
+    case request_frame_info_id::barrier:
+    case request_frame_info_id::durability_requirement:
+    case request_frame_info_id::dcp_stream_id:
+    case request_frame_info_id::open_tracing_context:
+    case request_frame_info_id::impersonate_user:
+    case request_frame_info_id::preserve_ttl:
+      return true;
+  }
+  return false;
 }
 
 enum class response_frame_info_id : std::uint8_t {
-    /**
-     * Time (in microseconds) server spent on the operation. Measured from receiving header from OS to when response given to OS. Size: 2
-     * bytes; encoded as variable-precision value (see below)
-     *
-     * FrameInfo encoded as:
-     *
-     *     Byte/     0       |       1       |       2       |
-     *        /              |               |               |
-     *       |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
-     *       +---------------+---------------+---------------+
-     *      0|  ID:0 | Len:2 |  Server Recv->Send Duration   |
-     *
-     * The duration in micros is encoded as:
-     *
-     *     encoded =  (micros * 2) ^ (1.0 / 1.74)
-     *     decoded =  (encoded ^ 1.74) / 2
-     */
-    server_duration = 0x00,
+  /**
+   * Time (in microseconds) server spent on the operation. Measured from receiving header from OS to
+   * when response given to OS. Size: 2 bytes; encoded as variable-precision value (see below)
+   *
+   * FrameInfo encoded as:
+   *
+   *     Byte/     0       |       1       |       2       |
+   *        /              |               |               |
+   *       |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7|
+   *       +---------------+---------------+---------------+
+   *      0|  ID:0 | Len:2 |  Server Recv->Send Duration   |
+   *
+   * The duration in micros is encoded as:
+   *
+   *     encoded =  (micros * 2) ^ (1.0 / 1.74)
+   *     decoded =  (encoded ^ 1.74) / 2
+   */
+  server_duration = 0x00,
 };
 
-constexpr bool
-is_valid_response_frame_info_id(std::uint8_t value)
+constexpr auto
+is_valid_response_frame_info_id(std::uint8_t value) -> bool
 {
-    switch (response_frame_info_id(value)) {
-        case response_frame_info_id::server_duration:
-            return true;
-    }
-    return false;
+  switch (response_frame_info_id(value)) {
+    case response_frame_info_id::server_duration:
+      return true;
+  }
+  return false;
 }
 
 } // namespace couchbase::core::protocol