couchbase 3.5.1 → 3.5.2

data/ext/couchbase/couchbase/term_facet.hxx

@@ -26,23 +26,23 @@ namespace couchbase
  */
 class term_facet : public search_facet
 {
-  public:
-    explicit term_facet(std::string field)
-      : search_facet{ std::move(field) }
-    {
-    }
+public:
+  explicit term_facet(std::string field)
+    : search_facet{ std::move(field) }
+  {
+  }
 
-    term_facet(std::string field, std::uint32_t size)
-      : search_facet{ std::move(field), size }
-    {
-    }
+  term_facet(std::string field, std::uint32_t size)
+    : search_facet{ std::move(field), size }
+  {
+  }
 
-    /**
-     * @return encoded representation of the search facet.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_facet override;
+  /**
+   * @return encoded representation of the search facet.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_facet override;
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/term_facet_result.hxx

@@ -35,21 +35,21 @@ class internal_term_facet_result;
  */
 class term_facet_result : public search_facet_result
 {
-  public:
-    /**
-     * @since 1.0.0
-     * @internal
-     */
-    explicit term_facet_result(internal_term_facet_result internal);
+public:
+  /**
+   * @since 1.0.0
+   * @internal
+   */
+  explicit term_facet_result(internal_term_facet_result internal);
 
-    [[nodiscard]] auto name() const -> const std::string& override;
-    [[nodiscard]] auto field() const -> const std::string& override;
-    [[nodiscard]] auto total() const -> std::uint64_t override;
-    [[nodiscard]] auto missing() const -> std::uint64_t override;
-    [[nodiscard]] auto other() const -> std::uint64_t override;
-    [[nodiscard]] auto terms() const -> const std::vector<search_term_range>&;
+  [[nodiscard]] auto name() const -> const std::string& override;
+  [[nodiscard]] auto field() const -> const std::string& override;
+  [[nodiscard]] auto total() const -> std::uint64_t override;
+  [[nodiscard]] auto missing() const -> std::uint64_t override;
+  [[nodiscard]] auto other() const -> std::uint64_t override;
+  [[nodiscard]] auto terms() const -> const std::vector<search_term_range>&;
 
-  private:
-    std::unique_ptr<internal_term_facet_result> internal_;
+private:
+  std::unique_ptr<internal_term_facet_result> internal_;
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/term_query.hxx

@@ -28,10 +28,12 @@
 namespace couchbase
 {
 /**
- * A query that looks for **exact** matches of the term in the index (no analyzer, no stemming). Useful to check what the actual content of
- * the index is. It can also apply fuzziness on the term. Usual better alternative is @ref match_query.
+ * A query that looks for **exact** matches of the term in the index (no analyzer, no stemming).
+ * Useful to check what the actual content of the index is. It can also apply fuzziness on the term.
+ * Usual better alternative is @ref match_query.
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term.html server
+ * documentation
  * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-fuzzy.html fuzzy search
  *
  * @since 1.0.0
@@ -39,113 +41,114 @@ namespace couchbase
  */
 class term_query : public search_query
 {
-  public:
-    /**
-     * Create a new term query.
-     *
-     * The mandatory term is the exact string that will be searched into the index. Note that the index can (and usually will) contain terms
-     * that are derived from the text in documents, as analyzers can apply process like stemming. For example, indexing "programming" could
-     * store "program" in the index. As a term query doesn't apply the analyzers, one would need to look for "program" to have a match on
-     * that index entry.
-     *
-     * @param term the input string to be matched against
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    explicit term_query(std::string term)
-      : term_{ std::move(term) }
-    {
-    }
-
-    /**
-     * Require that the term also have the same prefix of the specified length (must be positive).
-     *
-     * The prefix length only makes sense when fuzziness is enabled. It allows to apply the fuzziness only on the part of the term that is
-     * after the `length` character mark.
-     *
-     * For example, with the term "something" and a prefix length of 4, only the "thing" part of the term will be fuzzy-searched, and hits
-     * must start with "some".
-     *
-     * @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) -> term_query&
-    {
-        if (length <= 0) {
-            throw std::invalid_argument("prefix_length must be positive");
-        }
+public:
+  /**
+   * Create a new term query.
+   *
+   * The mandatory term is the exact string that will be searched into the index. Note that the
+   * index can (and usually will) contain terms that are derived from the text in documents, as
+   * analyzers can apply process like stemming. For example, indexing "programming" could store
+   * "program" in the index. As a term query doesn't apply the analyzers, one would need to look for
+   * "program" to have a match on that index entry.
+   *
+   * @param term the input string to be matched against
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit term_query(std::string term)
+    : term_{ std::move(term) }
+  {
+  }
 
-        prefix_length_ = length;
-        return *this;
+  /**
+   * Require that the term also have the same prefix of the specified length (must be positive).
+   *
+   * The prefix length only makes sense when fuzziness is enabled. It allows to apply the fuzziness
+   * only on the part of the term that is after the `length` character mark.
+   *
+   * For example, with the term "something" and a prefix length of 4, only the "thing" part of the
+   * term will be fuzzy-searched, and hits must start with "some".
+   *
+   * @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) -> term_query&
+  {
+    if (length <= 0) {
+      throw std::invalid_argument("prefix_length must be positive");
     }
 
-    /**
-     * If a field is specified, only terms in that field will be matched.
-     *
-     * @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) -> term_query&
-    {
-        field_ = std::move(field_name);
-        return *this;
-    }
+    prefix_length_ = length;
+    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) -> term_query&
-    {
-        fuzziness_ = fuzziness;
-        return *this;
-    }
+  /**
+   * If a field is specified, only terms in that field will be matched.
+   *
+   * @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) -> term_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) -> term_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) -> term_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) -> term_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 term_;
-    std::optional<std::uint32_t> prefix_length_{};
-    std::optional<std::string> field_{};
-    std::optional<std::uint32_t> fuzziness_{};
-    std::optional<couchbase::match_operator> operator_{};
+private:
+  std::string term_;
+  std::optional<std::uint32_t> prefix_length_{};
+  std::optional<std::string> field_{};
+  std::optional<std::uint32_t> fuzziness_{};
+  std::optional<couchbase::match_operator> operator_{};
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/term_range_query.hxx

@@ -26,117 +26,120 @@
 namespace couchbase
 {
 /**
- * The term range query finds documents containing a string value in the specified field within the specified range. Either min or max can
- * be omitted, but not both.
+ * The term range query finds documents containing a string value in the specified field within the
+ * specified range. Either min or max can be omitted, but not both.
  *
  * Match documents where field `desc` contains terms in the range `("foo", "foof")`:
  * @snippet test_unit_search.cxx search-term-range
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term-range.html server documentation.
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-term-range.html server
+ * documentation.
  *
  * @since 1.0.0
  * @committed
  */
 class term_range_query : public search_query
 {
-  public:
-    /**
-     * Set lower limit of the range. Whether to include limit into the range will be decided by server defaults.
-     *
-     * @param value  lower limit of the range.
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto min(std::string value) -> term_range_query&
-    {
-        min_ = std::move(value);
-        return *this;
-    }
+public:
+  /**
+   * Set lower limit of the range. Whether to include limit into the range will be decided by server
+   * defaults.
+   *
+   * @param value  lower limit of the range.
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto min(std::string value) -> term_range_query&
+  {
+    min_ = std::move(value);
+    return *this;
+  }
 
-    /**
-     * Set lower limit and specify whether to include it into the limit.
-     *
-     * @param value  lower limit of the range.
-     * @param inclusive whether to include limit value into the interval.
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto min(std::string value, bool inclusive) -> term_range_query&
-    {
-        min_ = std::move(value);
-        inclusive_min_ = inclusive;
-        return *this;
-    }
+  /**
+   * Set lower limit and specify whether to include it into the limit.
+   *
+   * @param value  lower limit of the range.
+   * @param inclusive whether to include limit value into the interval.
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto min(std::string value, bool inclusive) -> term_range_query&
+  {
+    min_ = std::move(value);
+    inclusive_min_ = inclusive;
+    return *this;
+  }
 
-    /**
-     * Set upper limit of the range. Whether to include limit into the range will be decided by server defaults.
-     *
-     * @param value  upper limit of the range
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto max(std::string value) -> term_range_query&
-    {
-        max_ = std::move(value);
-        return *this;
-    }
+  /**
+   * Set upper limit of the range. Whether to include limit into the range will be decided by server
+   * defaults.
+   *
+   * @param value  upper limit of the range
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto max(std::string value) -> term_range_query&
+  {
+    max_ = std::move(value);
+    return *this;
+  }
 
-    /**
-     * Set upper limit and specify whether to include it into the limit.
-     *
-     * @param value  upper limit of the range.
-     * @param inclusive whether to include limit value into the interval.
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto max(std::string value, bool inclusive) -> term_range_query&
-    {
-        max_ = std::move(value);
-        inclusive_max_ = inclusive;
-        return *this;
-    }
+  /**
+   * Set upper limit and specify whether to include it into the limit.
+   *
+   * @param value  upper limit of the range.
+   * @param inclusive whether to include limit value into the interval.
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto max(std::string value, bool inclusive) -> term_range_query&
+  {
+    max_ = std::move(value);
+    inclusive_max_ = inclusive;
+    return *this;
+  }
 
-    /**
-     * If a field is specified, only terms in that field will be matched.
-     *
-     * @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) -> term_range_query&
-    {
-        field_ = std::move(field_name);
-        return *this;
-    }
+  /**
+   * If a field is specified, only terms in that field will be matched.
+   *
+   * @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) -> term_range_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::optional<std::string> min_{};
-    std::optional<std::string> max_{};
-    std::optional<bool> inclusive_min_{};
-    std::optional<bool> inclusive_max_{};
-    std::optional<std::string> field_{};
+private:
+  std::optional<std::string> min_{};
+  std::optional<std::string> max_{};
+  std::optional<bool> inclusive_min_{};
+  std::optional<bool> inclusive_max_{};
+  std::optional<std::string> field_{};
 };
 } // namespace couchbase