couchbase 4.3.1 → 4.4.0

package/deps/couchbase-cxx-client/couchbase/management/search_index.hxx

@@ -26,15 +26,15 @@ namespace couchbase::management::search
 {
 struct index {
 
-    std::string name;
-    std::string type = "fulltext-index";
-    std::string source_name;
-    std::string source_type = "couchbase";
+  std::string name;
+  std::string type = "fulltext-index";
+  std::string source_name;
+  std::string source_type = "couchbase";
 
-    std::optional<std::string> uuid; // Must be empty on create, set on update
-    std::optional<std::string> params_json;
-    std::optional<std::string> source_uuid;
-    std::optional<std::string> source_params_json;
-    std::optional<std::string> plan_params_json;
+  std::optional<std::string> uuid; // Must be empty on create, set on update
+  std::optional<std::string> params_json;
+  std::optional<std::string> source_uuid;
+  std::optional<std::string> source_params_json;
+  std::optional<std::string> plan_params_json;
 };
 } // namespace couchbase::management::search

package/deps/couchbase-cxx-client/couchbase/match_all_query.hxx

@@ -24,20 +24,21 @@ namespace couchbase
 /**
  * A query that matches all indexed documents.
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-all.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-all.html server
+ * documentation
  *
  * @since 1.0.0
  * @committed
  */
 class match_all_query : public search_query
 {
-  public:
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query override;
+public:
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query override;
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/match_none_query.hxx

@@ -24,20 +24,21 @@ namespace couchbase
 /**
  * A query that matches nothing.
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-none.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-none.html server
+ * documentation
  *
  * @since 1.0.0
  * @committed
  */
 class match_none_query : public search_query
 {
-  public:
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query override;
+public:
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query override;
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/match_operator.hxx

@@ -26,20 +26,21 @@ namespace couchbase
  * @committed
  */
 enum class match_operator {
-    /**
-     * Individual match terms are concatenated with a logical OR - this is the default if not provided.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    logical_or,
+  /**
+   * Individual match terms are concatenated with a logical OR - this is the default if not
+   * provided.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  logical_or,
 
-    /**
-     * Individual match terms are concatenated with a logical AND.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    logical_and,
+  /**
+   * Individual match terms are concatenated with a logical AND.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  logical_and,
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/match_phrase_query.hxx

@@ -25,15 +25,20 @@
 namespace couchbase
 {
 /**
- * The input text is analyzed and a phrase query is built with the terms resulting from the analysis. This type of query searches for terms
- * occurring in the specified positions and offsets. This depends on term vectors, which are consulted to determine phrase distance.
+ * The input text is analyzed and a phrase query is built with the terms resulting from the
+ * analysis. This type of query searches for terms occurring in the specified positions and offsets.
+ * This depends on term vectors, which are consulted to determine phrase distance.
  *
- * For example, a match phrase query for `"location for functions"` is matched with `"locate the function"`, if the standard analyzer is
- * used: this analyzer uses a **stemmer**, which tokenizes `"location"` and `"locate"` to `"locat"`, and reduces `"functions"` and
- * `"function"` to `"function"`. Additionally, the analyzer employs stop removal, which removes small and less significant words from input
- * and target text, so that matches are attempted on only the more significant elements of vocabulary: in this case `"for"` and `"the"` are
- * removed. Following this processing, the tokens `"locat"` and `"function"` are recognized as common to both input and target; and also as
- * being both in the same sequence as, and at the same distance from one another; and therefore a match is made.
+ * For example, a match phrase query for `"location for functions"` is matched with `"locate the
+ * function"`, if the standard analyzer is used: this analyzer uses a **stemmer**, which tokenizes
+ * `"location"` and `"locate"` to
+ * `"locat"`, and reduces `"functions"` and
+ * `"function"` to `"function"`. Additionally, the analyzer employs stop removal, which removes
+ * small and less significant words from input and target text, so that matches are attempted on
+ * only the more significant elements of vocabulary: in this case `"for"` and `"the"` are removed.
+ * Following this processing, the tokens `"locat"` and
+ * `"function"` are recognized as common to both input and target; and also as being both in the
+ * same sequence as, and at the same distance from one another; and therefore a match is made.
  * @snippet test_unit_search.cxx search-match-phrase
  *
  * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match-phrase.html
@@ -43,66 +48,66 @@ namespace couchbase
  */
 class match_phrase_query : public search_query
 {
-  public:
-    /**
-     * Create a new match phrase query.
-     *
-     * @param match_phrase the input string to be matched against
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    explicit match_phrase_query(std::string match_phrase)
-      : match_phrase_{ std::move(match_phrase) }
-    {
-    }
+public:
+  /**
+   * Create a new match phrase query.
+   *
+   * @param match_phrase the input string to be matched against
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit match_phrase_query(std::string match_phrase)
+    : match_phrase_{ std::move(match_phrase) }
+  {
+  }
 
-    /**
-     * Analyzers are used to transform input text into a stream of tokens for indexing. The Server comes with built-in analyzers and the
-     * users can create their own.
-     *
-     * @param analyzer_name the name of the analyzer used
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto analyzer(std::string analyzer_name) -> match_phrase_query&
-    {
-        analyzer_ = std::move(analyzer_name);
-        return *this;
-    }
+  /**
+   * Analyzers are used to transform input text into a stream of tokens for indexing. The Server
+   * comes with built-in analyzers and the users can create their own.
+   *
+   * @param analyzer_name the name of the analyzer used
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto analyzer(std::string analyzer_name) -> match_phrase_query&
+  {
+    analyzer_ = std::move(analyzer_name);
+    return *this;
+  }
 
-    /**
-     * If a field is specified, only terms in that field will be matched.
-     *
-     * This can also affect the used analyzer if one isn't specified explicitly.
-     *
-     * @param field_name name of the field to be matched
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto field(std::string field_name) -> match_phrase_query&
-    {
-        field_ = std::move(field_name);
-        return *this;
-    }
+  /**
+   * If a field is specified, only terms in that field will be matched.
+   *
+   * This can also affect the used analyzer if one isn't specified explicitly.
+   *
+   * @param field_name name of the field to be matched
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto field(std::string field_name) -> match_phrase_query&
+  {
+    field_ = std::move(field_name);
+    return *this;
+  }
 
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query override;
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query override;
 
-  private:
-    std::string match_phrase_;
-    std::optional<std::string> analyzer_{};
-    std::optional<std::string> field_{};
+private:
+  std::string match_phrase_;
+  std::optional<std::string> analyzer_{};
+  std::optional<std::string> field_{};
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/match_query.hxx

@@ -28,136 +28,137 @@
 namespace couchbase
 {
 /**
- * A match query analyzes the input text and uses that analyzed text to query the index. An attempt is made to use the same analyzer that
- * was used when the field was indexed.
+ * A match query analyzes the input text and uses that analyzed text to query the index. An attempt
+ * is made to use the same analyzer that was used when the field was indexed.
  *
- * Match documents with both `"location"` and `"hostel"` terms in the field `reviews.content`, ensuring common prefix length `4`, maximum
- * fuzziness and select standard analyzer.
+ * Match documents with both `"location"` and `"hostel"` terms in the field `reviews.content`,
+ * ensuring common prefix length `4`, maximum fuzziness and select standard analyzer.
  * @snippet test_unit_search.cxx search-match
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-match.html server
+ * documentation
  *
  * @since 1.0.0
  * @committed
  */
 class match_query : public search_query
 {
-  public:
-    /**
-     * Create a new match query.
-     *
-     * @param match the input string to be matched against
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    explicit match_query(std::string match)
-      : match_{ std::move(match) }
-    {
-    }
-
-    /**
-     * Require that the term also have the same prefix of the specified length (must be positive).
-     *
-     * @param length the length of the term prefix
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto prefix_length(std::uint32_t length) -> match_query&
-    {
-        if (length <= 0) {
-            throw std::invalid_argument("prefix_length must be positive");
-        }
+public:
+  /**
+   * Create a new match query.
+   *
+   * @param match the input string to be matched against
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit match_query(std::string match)
+    : match_{ std::move(match) }
+  {
+  }
 
-        prefix_length_ = length;
-        return *this;
+  /**
+   * Require that the term also have the same prefix of the specified length (must be positive).
+   *
+   * @param length the length of the term prefix
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto prefix_length(std::uint32_t length) -> match_query&
+  {
+    if (length <= 0) {
+      throw std::invalid_argument("prefix_length must be positive");
     }
 
-    /**
-     * Analyzers are used to transform input text into a stream of tokens for indexing. The Server comes with built-in analyzers and the
-     * users can create their own.
-     *
-     * @param analyzer_name the name of the analyzer used
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto analyzer(std::string analyzer_name) -> match_query&
-    {
-        analyzer_ = std::move(analyzer_name);
-        return *this;
-    }
+    prefix_length_ = length;
+    return *this;
+  }
 
-    /**
-     * If a field is specified, only terms in that field will be matched.
-     *
-     * This can also affect the used analyzer if one isn't specified explicitly.
-     *
-     * @param field_name name of the field to be matched
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto field(std::string field_name) -> match_query&
-    {
-        field_ = std::move(field_name);
-        return *this;
-    }
+  /**
+   * Analyzers are used to transform input text into a stream of tokens for indexing. The Server
+   * comes with built-in analyzers and the users can create their own.
+   *
+   * @param analyzer_name the name of the analyzer used
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto analyzer(std::string analyzer_name) -> match_query&
+  {
+    analyzer_ = std::move(analyzer_name);
+    return *this;
+  }
 
-    /**
-     * Perform fuzzy matching. If the fuzziness parameter is set to a non-zero integer the analyzed text will be matched with the specified
-     * level of fuzziness.
-     *
-     * @param fuzziness level of fuzziness (the maximum supported fuzziness is 2).
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto fuzziness(std::uint32_t fuzziness) -> match_query&
-    {
-        fuzziness_ = fuzziness;
-        return *this;
-    }
+  /**
+   * If a field is specified, only terms in that field will be matched.
+   *
+   * This can also affect the used analyzer if one isn't specified explicitly.
+   *
+   * @param field_name name of the field to be matched
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto field(std::string field_name) -> match_query&
+  {
+    field_ = std::move(field_name);
+    return *this;
+  }
 
-    /**
-     * Defines how the individual match terms should be logically concatenated
-     *
-     * @param concatenation_operator operator to be used
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto match_operator(couchbase::match_operator concatenation_operator) -> match_query&
-    {
-        operator_ = concatenation_operator;
-        return *this;
-    }
+  /**
+   * Perform fuzzy matching. If the fuzziness parameter is set to a non-zero integer the analyzed
+   * text will be matched with the specified level of fuzziness.
+   *
+   * @param fuzziness level of fuzziness (the maximum supported fuzziness is 2).
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto fuzziness(std::uint32_t fuzziness) -> match_query&
+  {
+    fuzziness_ = fuzziness;
+    return *this;
+  }
+
+  /**
+   * Defines how the individual match terms should be logically concatenated
+   *
+   * @param concatenation_operator operator to be used
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto match_operator(couchbase::match_operator concatenation_operator) -> match_query&
+  {
+    operator_ = concatenation_operator;
+    return *this;
+  }
 
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query override;
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query override;
 
-  private:
-    std::string match_;
-    std::optional<std::uint32_t> prefix_length_{};
-    std::optional<std::string> analyzer_{};
-    std::optional<std::string> field_{};
-    std::optional<std::uint32_t> fuzziness_{};
-    std::optional<couchbase::match_operator> operator_{};
+private:
+  std::string match_;
+  std::optional<std::uint32_t> prefix_length_{};
+  std::optional<std::string> analyzer_{};
+  std::optional<std::string> field_{};
+  std::optional<std::uint32_t> fuzziness_{};
+  std::optional<couchbase::match_operator> operator_{};
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/metrics/meter.hxx

@@ -25,44 +25,47 @@ namespace couchbase::metrics
 {
 class value_recorder
 {
-  public:
-    value_recorder() = default;
-    value_recorder(const value_recorder& other) = default;
-    value_recorder(value_recorder&& other) = default;
-    value_recorder& operator=(const value_recorder& other) = default;
-    value_recorder& operator=(value_recorder&& other) = default;
-    virtual ~value_recorder() = default;
+public:
+  value_recorder() = default;
+  value_recorder(const value_recorder& other) = default;
+  value_recorder(value_recorder&& other) = default;
+  auto operator=(const value_recorder& other) -> value_recorder& = default;
+  auto operator=(value_recorder&& other) -> value_recorder& = default;
+  virtual ~value_recorder() = default;
 
-    virtual void record_value(std::int64_t value) = 0;
+  virtual void record_value(int64_t value) = 0;
 };
 
 class meter
 {
-  public:
-    meter() = default;
-    meter(const meter& other) = default;
-    meter(meter&& other) = default;
-    meter& operator=(const meter& other) = default;
-    meter& operator=(meter&& other) = default;
-    virtual ~meter() = default;
+public:
+  meter() = default;
+  meter(const meter& other) = default;
+  meter(meter&& other) = default;
+  auto operator=(const meter& other) -> meter& = default;
+  auto operator=(meter&& other) -> meter& = default;
+  virtual ~meter() = default;
 
-    /**
-     * SDK invokes this method when cluster is ready to emit metrics. Override it as NO-OP if no action is necessary.
-     */
-    virtual void start()
-    {
-        /* do nothing */
-    }
+  /**
+   * SDK invokes this method when cluster is ready to emit metrics. Override it as NO-OP if no
+   * action is necessary.
+   */
+  virtual void start()
+  {
+    /* do nothing */
+  }
 
-    /**
-     * SDK invokes this method when cluster is closed. Override it as NO-OP if no action is necessary.
-     */
-    virtual void stop()
-    {
-        /* do nothing */
-    }
+  /**
+   * SDK invokes this method when cluster is closed. Override it as NO-OP if no action is necessary.
+   */
+  virtual void stop()
+  {
+    /* do nothing */
+  }
 
-    virtual std::shared_ptr<value_recorder> get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags) = 0;
+  virtual auto get_value_recorder(const std::string& name,
+                                  const std::map<std::string, std::string>& tags)
+    -> std::shared_ptr<value_recorder> = 0;
 };
 
 } // namespace couchbase::metrics