couchbase 4.3.1 → 4.4.1-dev.1

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

@@ -27,137 +27,145 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 mutate_in_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 || status == key_value_status_code::subdoc_multi_path_failure) {
-        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);
-
-            token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
-            offset += 8;
-        } else {
-            offset += extras_size;
-        }
-        offset += key_size;
-        fields_.reserve(16); /* we won't have more than 16 entries anyway */
-        while (static_cast<std::size_t>(offset) < body.size()) {
-            mutate_in_field field;
-
-            field.index = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
-            offset++;
-
-            std::uint16_t entry_status = 0;
-            memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-            entry_status = utils::byte_swap(entry_status);
-            Expects(is_valid_status(entry_status));
-            field.status = static_cast<key_value_status_code>(entry_status);
-            offset += static_cast<offset_type>(sizeof(entry_status));
-
-            if (field.status == key_value_status_code::success) {
-                std::uint32_t entry_size = 0;
-                memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-                entry_size = utils::byte_swap(entry_size);
-                Expects(entry_size < 20 * 1024 * 1024);
-                offset += static_cast<offset_type>(sizeof(entry_size));
-
-                field.value.resize(entry_size);
-                memcpy(field.value.data(), body.data() + offset, entry_size);
-                offset += static_cast<offset_type>(entry_size);
-            }
-
-            fields_.emplace_back(field);
-        }
-        return true;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success ||
+      status == key_value_status_code::subdoc_multi_path_failure) {
+    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);
+
+      token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
+      offset += 8;
+    } else {
+      offset += extras_size;
     }
-    return false;
+    offset += key_size;
+    fields_.reserve(16); /* we won't have more than 16 entries anyway */
+    while (static_cast<std::size_t>(offset) < body.size()) {
+      mutate_in_field field;
+
+      field.index = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
+      offset++;
+
+      std::uint16_t entry_status = 0;
+      memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
+      entry_status = utils::byte_swap(entry_status);
+      Expects(is_valid_status(entry_status));
+      field.status = static_cast<key_value_status_code>(entry_status);
+      offset += static_cast<offset_type>(sizeof(entry_status));
+
+      if (field.status == key_value_status_code::success) {
+        std::uint32_t entry_size = 0;
+        memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
+        entry_size = utils::byte_swap(entry_size);
+        Expects(entry_size < 20 * 1024 * 1024);
+        offset += static_cast<offset_type>(sizeof(entry_size));
+
+        field.value.resize(entry_size);
+        memcpy(field.value.data(), body.data() + offset, entry_size);
+        offset += static_cast<offset_type>(entry_size);
+      }
+
+      fields_.emplace_back(field);
+    }
+    return true;
+  }
+  return false;
 }
 
 void
 mutate_in_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 void
 mutate_in_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
 mutate_in_request_body::preserve_expiry()
 {
-    add_preserve_expiry_frame_info(framing_extras_);
+  add_preserve_expiry_frame_info(framing_extras_);
 }
 
 void
 mutate_in_request_body::fill_extras()
 {
-    if (expiry_ != 0) {
-        extras_.resize(sizeof(expiry_));
-        std::uint32_t field = utils::byte_swap(expiry_);
-        memcpy(extras_.data(), &field, sizeof(field));
-    }
-    if (flags_ != std::byte{ 0U }) {
-        std::size_t offset = extras_.size();
-        extras_.resize(offset + sizeof(flags_));
-        extras_[offset] = std::byte{ flags_ };
-    }
+  if (expiry_ != 0 || user_flags_) {
+    extras_.resize(sizeof(expiry_));
+    std::uint32_t field = utils::byte_swap(expiry_);
+    memcpy(extras_.data(), &field, sizeof(field));
+  }
+  if (user_flags_) {
+    std::size_t offset = extras_.size();
+    extras_.resize(offset + sizeof(std::uint32_t));
+    std::uint32_t field = utils::byte_swap(user_flags_.value());
+    memcpy(extras_.data() + offset, &field, sizeof(field));
+  }
+  if (flags_ != std::byte{ 0U }) {
+    std::size_t offset = extras_.size();
+    extras_.resize(offset + sizeof(flags_));
+    extras_[offset] = std::byte{ flags_ };
+  }
 }
 
 void
 mutate_in_request_body::fill_value()
 {
-    size_t value_size = 0;
-    for (const auto& spec : specs_) {
-        value_size += sizeof(spec.opcode_) + sizeof(std::uint8_t) + sizeof(std::uint16_t) + spec.path_.size() + sizeof(std::uint32_t) +
-                      spec.value_.size();
-    }
-    Expects(value_size > 0);
-    value_.resize(value_size);
-    std::vector<std::byte>::size_type offset = 0;
-    for (const auto& spec : specs_) {
-        value_[offset] = static_cast<std::byte>(spec.opcode_);
-        ++offset;
-        value_[offset] = spec.flags_;
-        ++offset;
-
-        std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
-        std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
-        offset += sizeof(path_size);
-
-        std::uint32_t param_size = utils::byte_swap(gsl::narrow_cast<std::uint32_t>(spec.value_.size()));
-        std::memcpy(value_.data() + offset, &param_size, sizeof(param_size));
-        offset += sizeof(param_size);
-
-        std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());
-        offset += spec.path_.size();
-
-        if (param_size != 0U) {
-            std::memcpy(value_.data() + offset, spec.value_.data(), spec.value_.size());
-            offset += spec.value_.size();
-        }
+  size_t value_size = 0;
+  for (const auto& spec : specs_) {
+    value_size += sizeof(spec.opcode_) + sizeof(std::uint8_t) + sizeof(std::uint16_t) +
+                  spec.path_.size() + sizeof(std::uint32_t) + spec.value_.size();
+  }
+  Expects(value_size > 0);
+  value_.resize(value_size);
+  std::vector<std::byte>::size_type offset = 0;
+  for (const auto& spec : specs_) {
+    value_[offset] = static_cast<std::byte>(spec.opcode_);
+    ++offset;
+    value_[offset] = spec.flags_;
+    ++offset;
+
+    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
+    offset += sizeof(path_size);
+
+    std::uint32_t param_size =
+      utils::byte_swap(gsl::narrow_cast<std::uint32_t>(spec.value_.size()));
+    std::memcpy(value_.data() + offset, &param_size, sizeof(param_size));
+    offset += sizeof(param_size);
+
+    std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());
+    offset += spec.path_.size();
+
+    if (param_size != 0U) {
+      std::memcpy(value_.data() + offset, spec.value_.data(), spec.value_.size());
+      offset += spec.value_.size();
     }
+  }
 }
 } // namespace couchbase::core::protocol

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

@@ -37,180 +37,188 @@ namespace couchbase::core::protocol
 
 class mutate_in_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::subdoc_multi_mutation;
-
-    struct mutate_in_field {
-        std::uint8_t index{};
-        key_value_status_code status{};
-        std::string value{};
-    };
-
-  private:
-    std::vector<mutate_in_field> fields_;
-    mutation_token token_;
-
-  public:
-    [[nodiscard]] const std::vector<mutate_in_field>& fields() const
-    {
-        return fields_;
-    }
-
-    [[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::subdoc_multi_mutation;
+
+  struct mutate_in_field {
+    std::uint8_t index{};
+    key_value_status_code status{};
+    std::string value{};
+  };
+
+private:
+  std::vector<mutate_in_field> fields_;
+  mutation_token token_;
+
+public:
+  [[nodiscard]] auto fields() const -> const std::vector<mutate_in_field>&
+  {
+    return fields_;
+  }
+
+  [[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 mutate_in_request_body
 {
-  public:
-    using response_body_type = mutate_in_response_body;
-    static const inline client_opcode opcode = client_opcode::subdoc_multi_mutation;
-
-    /**
-     * Create the document if it does not exist. Implies `path_flag_create_parents`.
-     * and `upsert` mutation semantics. Not valid with `insert`.
-     */
-    static constexpr std::byte doc_flag_mkdoc{ 0b0000'0001U };
-
-    /**
-     * Add the document only if it does not exist. Implies `path_flag_create_parents`.
-     * Not valid with `doc_flag_mkdoc`.
-     */
-    static constexpr std::byte doc_flag_add{ 0b0000'0010U };
-
-    /**
-     * Allow access to XATTRs for deleted documents (instead of returning KEY_ENOENT).
-     */
-    static constexpr std::byte doc_flag_access_deleted{ 0b0000'0100U };
-
-    /**
-     * Used with `doc_flag_mkdoc` / `doc_flag_add`; if the document does not exist then create
-     * it in the "Deleted" state, instead of the normal "Alive" state.
-     * Not valid unless `doc_flag_mkdoc` or `doc_flag_add` specified.
-     */
-    static constexpr std::byte doc_flag_create_as_deleted{ 0b0000'1000U };
-
-    /**
-     * If the document exists and isn't deleted the operation will fail with .
-     * If the input document _is_ deleted the result of the operation will store the
-     * document as a "live" document instead of a deleted document.
-     */
-    static constexpr std::byte doc_flag_revive_document{ 0b0001'0000U };
-
-  private:
-    std::vector<std::byte> key_;
-    std::vector<std::byte> extras_{};
-    std::vector<std::byte> value_{};
-
-    std::uint32_t expiry_{ 0 };
-    std::byte flags_{ 0 };
-    std::vector<couchbase::core::impl::subdoc::command> specs_;
-    std::vector<std::byte> framing_extras_{};
-
-  public:
-    void id(const document_id& id);
-
-    void expiry(std::uint32_t value)
-    {
-        expiry_ = value;
+public:
+  using response_body_type = mutate_in_response_body;
+  static const inline client_opcode opcode = client_opcode::subdoc_multi_mutation;
+
+  /**
+   * Create the document if it does not exist. Implies
+   * `path_flag_create_parents`. and `upsert` mutation semantics. Not valid with
+   * `insert`.
+   */
+  static constexpr std::byte doc_flag_mkdoc{ 0b0000'0001U };
+
+  /**
+   * Add the document only if it does not exist. Implies
+   * `path_flag_create_parents`. Not valid with `doc_flag_mkdoc`.
+   */
+  static constexpr std::byte doc_flag_add{ 0b0000'0010U };
+
+  /**
+   * Allow access to XATTRs for deleted documents (instead of returning
+   * KEY_ENOENT).
+   */
+  static constexpr std::byte doc_flag_access_deleted{ 0b0000'0100U };
+
+  /**
+   * Used with `doc_flag_mkdoc` / `doc_flag_add`; if the document does not exist
+   * then create it in the "Deleted" state, instead of the normal "Alive" state.
+   * Not valid unless `doc_flag_mkdoc` or `doc_flag_add` specified.
+   */
+  static constexpr std::byte doc_flag_create_as_deleted{ 0b0000'1000U };
+
+  /**
+   * If the document exists and isn't deleted the operation will fail with .
+   * If the input document _is_ deleted the result of the operation will store
+   * the document as a "live" document instead of a deleted document.
+   */
+  static constexpr std::byte doc_flag_revive_document{ 0b0001'0000U };
+
+private:
+  std::vector<std::byte> key_;
+  std::vector<std::byte> extras_{};
+  std::vector<std::byte> value_{};
+
+  std::optional<std::uint32_t> user_flags_{};
+  std::uint32_t expiry_{ 0 };
+  std::byte flags_{ 0 };
+  std::vector<couchbase::core::impl::subdoc::command> specs_;
+  std::vector<std::byte> framing_extras_{};
+
+public:
+  void id(const document_id& id);
+
+  void user_flags(std::uint32_t value)
+  {
+    user_flags_ = value;
+  }
+
+  void expiry(std::uint32_t value)
+  {
+    expiry_ = value;
+  }
+
+  void access_deleted(bool value)
+  {
+    if (value) {
+      flags_ |= doc_flag_access_deleted;
+    } else {
+      flags_ &= ~doc_flag_access_deleted;
     }
-
-    void access_deleted(bool value)
-    {
-        if (value) {
-            flags_ |= doc_flag_access_deleted;
-        } else {
-            flags_ &= ~doc_flag_access_deleted;
-        }
+  }
+
+  void create_as_deleted(bool value)
+  {
+    if (value) {
+      flags_ |= doc_flag_create_as_deleted;
+    } else {
+      flags_ &= ~doc_flag_create_as_deleted;
     }
-
-    void create_as_deleted(bool value)
-    {
-        if (value) {
-            flags_ |= doc_flag_create_as_deleted;
-        } else {
-            flags_ &= ~doc_flag_create_as_deleted;
-        }
+  }
+
+  void store_semantics(couchbase::store_semantics semantics)
+  {
+    flags_ &= std::byte{ 0b1111'1100U }; /* reset first two bits */
+    switch (semantics) {
+      case couchbase::store_semantics::replace:
+        /* leave bits as zeros */
+        break;
+      case couchbase::store_semantics::upsert:
+        flags_ |= doc_flag_mkdoc;
+        break;
+      case couchbase::store_semantics::insert:
+        flags_ |= doc_flag_add;
+        break;
+      case store_semantics::revive:
+        break;
     }
+  }
 
-    void store_semantics(couchbase::store_semantics semantics)
-    {
-        flags_ &= std::byte{ 0b1111'1100U }; /* reset first two bits */
-        switch (semantics) {
-            case couchbase::store_semantics::replace:
-                /* leave bits as zeros */
-                break;
-            case couchbase::store_semantics::upsert:
-                flags_ |= doc_flag_mkdoc;
-                break;
-            case couchbase::store_semantics::insert:
-                flags_ |= doc_flag_add;
-                break;
-            case store_semantics::revive:
-                break;
-        }
-    }
+  void specs(std::vector<couchbase::core::impl::subdoc::command> specs)
+  {
+    specs_ = std::move(specs);
+  }
 
-    void specs(std::vector<couchbase::core::impl::subdoc::command> specs)
-    {
-        specs_ = std::move(specs);
-    }
+  void durability(durability_level level, std::optional<std::uint16_t> timeout);
 
-    void durability(durability_level level, std::optional<std::uint16_t> timeout);
+  void preserve_expiry();
 
-    void preserve_expiry();
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
 
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return framing_extras_;
+  }
 
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
+  [[nodiscard]] auto extras() -> const auto&
+  {
+    if (extras_.empty()) {
+      fill_extras();
     }
+    return extras_;
+  }
 
-    [[nodiscard]] const auto& extras()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        return extras_;
+  [[nodiscard]] auto value() -> const auto&
+  {
+    if (value_.empty()) {
+      fill_value();
     }
+    return value_;
+  }
 
-    [[nodiscard]] const auto& value()
-    {
-        if (value_.empty()) {
-            fill_value();
-        }
-        return value_;
+  [[nodiscard]] auto size() -> std::size_t
+  {
+    if (extras_.empty()) {
+      fill_extras();
     }
-
-    [[nodiscard]] std::size_t size()
-    {
-        if (extras_.empty()) {
-            fill_extras();
-        }
-        if (value_.empty()) {
-            fill_value();
-        }
-        return framing_extras_.size() + extras_.size() + key_.size() + value_.size();
+    if (value_.empty()) {
+      fill_value();
     }
+    return framing_extras_.size() + extras_.size() + key_.size() + value_.size();
+  }
 
-  private:
-    void fill_extras();
+private:
+  void fill_extras();
 
-    void fill_value();
+  void fill_value();
 };
 
 } // namespace couchbase::core::protocol

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

@@ -21,16 +21,16 @@
 
 namespace couchbase::core::protocol
 {
-bool
+auto
 mcbp_noop_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));
-    return false;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  return false;
 }
 } // namespace couchbase::core::protocol