couchbase 4.7.0 → 4.7.1

package/deps/couchbase-cxx-client/core/operations/document_query.cxx

@@ -20,6 +20,7 @@
 #include "core/cluster_options.hxx"
 #include "core/logger/logger.hxx"
 #include "core/operations/management/error_utils.hxx"
+#include "core/utils/contains_string.hxx"
 #include "core/utils/duration_parser.hxx"
 #include "core/utils/json.hxx"
 
@@ -28,13 +29,11 @@
 #include <gsl/assert>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations
 {
 auto
-query_request::encode_to(query_request::encoded_request_type& encoded,
-                         http_context& context) -> std::error_code
+query_request::encode_to(query_request::encoded_request_type& encoded, http_context& context)
+  -> std::error_code
 {
   ctx_.emplace(context);
   tao::json::value body{
@@ -209,8 +208,8 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
 }
 
 auto
-query_request::make_response(error_context::query&& ctx,
-                             const encoded_response_type& encoded) -> query_response
+query_request::make_response(error_context::query&& ctx, const encoded_response_type& encoded)
+  -> query_response
 {
   query_response response{ std::move(ctx) };
   response.ctx.statement = statement;
@@ -374,13 +373,14 @@ query_request::make_response(error_context::query&& ctx,
             response.ctx.ec = errc::common::index_exists;
             break;
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(response.ctx.first_error_message,
-                                  std::regex{ ".*[iI]ndex .*already exist.*" })) {
+            if (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                utils::contains_string(response.ctx.first_error_message, "already exist", true)) {
               response.ctx.ec = errc::common::index_exists;
-            } else if (response.ctx.first_error_message.find("Index does not exist") !=
-                         std::string::npos ||
-                       std::regex_search(response.ctx.first_error_message,
-                                         std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+            } else if (utils::contains_string(response.ctx.first_error_message,
+                                              "Index does not exist") ||
+                       (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                        utils::contains_string(
+                          response.ctx.first_error_message, "not found", true))) {
               response.ctx.ec = errc::common::index_not_found;
             } else if (response.ctx.first_error_message.find("Bucket Not Found") !=
                        std::string::npos) {

package/deps/couchbase-cxx-client/core/operations/management/collection_create.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_create_request::encode_to(encoded_request_type& encoded,
-                                     http_context& /*context*/) const -> std::error_code
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections",
@@ -58,18 +56,20 @@ collection_create_request::make_response(error_context::http&& ctx,
 {
   collection_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
-        const std::regex collection_exists("Collection with name .+ already exists");
-        if (std::regex_search(encoded.body.data(), collection_exists)) {
+        const auto prefix_pos = body.find("Collection with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" already exists", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::management::collection_exists;
         } else {
           response.ctx.ec = errc::common::invalid_argument;
         }
       } break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" is not found", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -78,7 +78,7 @@ collection_create_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -86,7 +86,7 @@ collection_create_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

package/deps/couchbase-cxx-client/core/operations/management/collection_drop.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_drop_request::encode_to(encoded_request_type& encoded,
-                                   http_context& /* context */) const -> std::error_code
+collection_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
@@ -47,16 +45,18 @@ collection_drop_request::make_response(error_context::http&& ctx,
 {
   collection_drop_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400:
         response.ctx.ec = errc::common::unsupported_operation;
         break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        const std::regex collection_not_found("Collection with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), collection_not_found)) {
+        const auto collection_prefix_pos = body.find("Collection with name ");
+        const auto scope_prefix_pos = body.find("Scope with name ");
+        if (collection_prefix_pos != std::string_view::npos &&
+            body.find(" is not found", collection_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::collection_not_found;
-        } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        } else if (scope_prefix_pos != std::string_view::npos &&
+                   body.find(" is not found", scope_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -65,7 +65,7 @@ collection_drop_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -73,7 +73,7 @@ collection_drop_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

package/deps/couchbase-cxx-client/core/operations/management/collection_update.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_update_request::encode_to(encoded_request_type& encoded,
-                                     http_context& /*context*/) const -> std::error_code
+collection_update_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   encoded.method = "PATCH";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
@@ -60,16 +58,18 @@ collection_update_request::make_response(error_context::http&& ctx,
 {
   collection_update_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
         response.ctx.ec = errc::common::invalid_argument;
       } break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        const std::regex collection_not_found("Collection with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), collection_not_found)) {
+        const auto collection_prefix_pos = body.find("Collection with name ");
+        const auto scope_prefix_pos = body.find("Scope with name ");
+        if (collection_prefix_pos != std::string_view::npos &&
+            body.find(" is not found", collection_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::collection_not_found;
-        } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        } else if (scope_prefix_pos != std::string_view::npos &&
+                   body.find(" is not found", scope_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -78,7 +78,7 @@ collection_update_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -86,7 +86,7 @@ collection_update_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

package/deps/couchbase-cxx-client/core/operations/management/error_utils.cxx

@@ -16,12 +16,11 @@
  */
 
 #include "error_utils.hxx"
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 
@@ -143,12 +142,16 @@ translate_query_error_code(std::uint64_t error, const std::string& message, std:
 {
   switch (error) {
     case 5000: /* IKey: "Internal Error" */
-      if (std::regex_search(message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+      if (utils::contains_string(message, "index", true) &&
+          utils::contains_string(message, "already exist", true)) {
         return errc::common::index_exists;
-      } else if (message.find("Index does not exist") != std::string::npos ||
-                 std::regex_search(message, std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+      }
+      if (utils::contains_string(message, "Index does not exist") ||
+          (utils::contains_string(message, "index", true) &&
+           utils::contains_string(message, "not found", true))) {
         return errc::common::index_not_found;
-      } else if (message.find("Bucket Not Found") != std::string::npos) {
+      }
+      if (message.find("Bucket Not Found") != std::string::npos) {
         return errc::common::bucket_not_found;
       }
       break;

package/deps/couchbase-cxx-client/core/operations/management/query_index_create.cxx

@@ -17,6 +17,7 @@
 
 #include "query_index_create.hxx"
 
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
@@ -24,8 +25,6 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
@@ -118,13 +117,15 @@ query_index_create_request::make_response(error_context::http&& ctx,
         error.message = entry.at("msg").get_string();
         switch (error.code) {
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+          {
+            if (utils::contains_string(error.message, "index", true) &&
+                utils::contains_string(error.message, "already exist", true)) {
               index_already_exists = true;
             }
             if (error.message.find("Bucket Not Found") != std::string::npos) {
               bucket_not_found = true;
             }
-            break;
+          } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
             if (error.message.find("missing_collection") != std::string::npos) {

package/deps/couchbase-cxx-client/core/operations/management/query_index_drop.cxx

@@ -17,6 +17,7 @@
 
 #include "query_index_drop.hxx"
 
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
@@ -24,13 +25,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-query_index_drop_request::encode_to(encoded_request_type& encoded,
-                                    http_context& /*context*/) const -> std::error_code
+query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   if (!utils::check_query_management_request(*this)) {
     return errc::common::invalid_argument;
@@ -87,10 +86,12 @@ query_index_drop_request::make_response(error_context::http&& ctx,
         error.message = entry.at("msg").get_string();
         switch (error.code) {
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+          {
+            if (utils::contains_string(error.message, "index", true) &&
+                utils::contains_string(error.message, "not found", true)) {
               index_not_found = true;
             }
-            break;
+          } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
             if (error.message.find("missing_collection") != std::string::npos) {

package/deps/couchbase-cxx-client/core/operations/management/scope_create.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-scope_create_request::encode_to(encoded_request_type& encoded,
-                                http_context& /* context */) const -> std::error_code
+scope_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes",
@@ -41,18 +39,19 @@ scope_create_request::encode_to(encoded_request_type& encoded,
 }
 
 auto
-scope_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded)
-  const -> scope_create_response
+scope_create_request::make_response(error_context::http&& ctx,
+                                    const encoded_response_type& encoded) const
+  -> scope_create_response
 {
   scope_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
-        const std::regex scope_exists("Scope with name .+ already exists");
-        if (std::regex_search(encoded.body.data(), scope_exists)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" already exists", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::management::scope_exists;
-        } else if (encoded.body.data().find("Not allowed on this version of cluster") !=
-                   std::string::npos) {
+        } else if (body.find("Not allowed on this version of cluster") != std::string::npos) {
           response.ctx.ec = errc::common::feature_not_available;
         } else {
           response.ctx.ec = errc::common::invalid_argument;
@@ -64,7 +63,7 @@ scope_create_request::make_response(error_context::http&& ctx, const encoded_res
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -72,7 +71,7 @@ scope_create_request::make_response(error_context::http&& ctx, const encoded_res
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

package/deps/couchbase-cxx-client/core/operations/management/scope_drop.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-scope_drop_request::encode_to(encoded_request_type& encoded,
-                              http_context& /* context */) const -> std::error_code
+scope_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}",
@@ -45,13 +43,14 @@ scope_drop_request::make_response(error_context::http&& ctx,
 {
   scope_drop_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400:
         response.ctx.ec = errc::common::unsupported_operation;
         break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" is not found", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -60,7 +59,7 @@ scope_drop_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -68,7 +67,7 @@ scope_drop_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

package/deps/couchbase-cxx-client/core/topology/configuration.cxx

@@ -17,6 +17,7 @@
 
 #include "configuration.hxx"
 
+#include "core/impl/node_id.hxx"
 #include "core/logger/logger.hxx"
 #include "core/service_type_fmt.hxx"
 #include "core/utils/crc32.hxx"
@@ -171,6 +172,26 @@ configuration::node::endpoint(const std::string& network, service_type type, boo
   return fmt::format("{}:{}", hostname_for(network), p);
 }
 
+auto
+configuration::node::effective_node_id(bool is_tls) const -> couchbase::node_id
+{
+  return internal_node_id::build(node_uuid, hostname, port_or(service_type::key_value, is_tls, 0));
+}
+
+auto
+configuration::effective_node_ids(bool is_tls) const -> std::vector<couchbase::node_id>
+{
+  std::vector<couchbase::node_id> result;
+  result.reserve(nodes.size());
+  for (const auto& n : nodes) {
+    if (n.port_or(service_type::key_value, is_tls, 0) == 0) {
+      continue;
+    }
+    result.push_back(n.effective_node_id(is_tls));
+  }
+  return result;
+}
+
 auto
 configuration::has_node(const std::string& network,
                         service_type type,

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -21,6 +21,8 @@
 #include "core/platform/uuid.h"
 #include "core/service_type.hxx"
 
+#include <couchbase/node_id.hxx>
+
 #include <map>
 #include <optional>
 #include <set>
@@ -83,10 +85,36 @@ struct configuration {
 
     [[nodiscard]] auto endpoint(const std::string& network, service_type type, bool is_tls) const
       -> std::optional<std::string>;
+
+    /**
+     * Returns a node_id built from this node's UUID (when available on
+     * Server 8.0.1+) with fallback to a deterministic hash of hostname +
+     * KV port for older servers.
+     *
+     * The KV port selected mirrors what mcbp_session uses for the same node
+     * (TLS port when @p is_tls, plain port otherwise), ensuring that the
+     * node_id surfaced on the request side via collection::node_id_for
+     * matches the node_id attached to results and errors.
+     */
+    [[nodiscard]] auto effective_node_id(bool is_tls) const -> couchbase::node_id;
   };
 
   [[nodiscard]] auto select_network(const std::string& bootstrap_hostname) const -> std::string;
 
+  /**
+   * Returns one node_id per cluster node that currently serves the
+   * key-value service over the requested transport. Nodes that do not
+   * expose a KV port for @p is_tls are filtered out — without a KV port
+   * the fallback hash would be derived from a meaningless port=0 and
+   * could collide with a sibling node that is also missing its KV port.
+   *
+   * The returned vector preserves topology order; callers that want a
+   * set semantic should hash the entries themselves (couchbase::node_id
+   * is hashable). Topology nodes are unique by construction, so no
+   * dedup is performed here.
+   */
+  [[nodiscard]] auto effective_node_ids(bool is_tls) const -> std::vector<couchbase::node_id>;
+
   using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
   std::optional<std::int64_t> epoch{};

package/deps/couchbase-cxx-client/core/utils/contains_string.cxx

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "contains_string.hxx"
+
+namespace couchbase::core::utils
+{
+
+namespace
+{
+constexpr auto ascii_lower = [](unsigned char c) -> unsigned char {
+  return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c + ('a' - 'A')) : c;
+};
+} // namespace
+
+auto
+contains_string(std::string_view input, std::string_view substr, bool ignore_case) -> bool
+{
+  if (substr.empty()) {
+    return true;
+  }
+
+  if (input.empty() || substr.size() > input.size()) {
+    return false;
+  }
+
+  if (!ignore_case) {
+    return input.find(substr) != std::string_view::npos;
+  }
+
+  const auto end = input.size() - substr.size() + 1;
+  for (std::size_t i = 0; i < end; i++) {
+    bool match = true;
+    for (std::size_t j = 0; j < substr.size(); j++) {
+      if (ascii_lower(static_cast<unsigned char>(input[i + j])) !=
+          ascii_lower(static_cast<unsigned char>(substr[j]))) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return true;
+    }
+  }
+  return false;
+}
+} // namespace couchbase::core::utils

package/deps/couchbase-cxx-client/core/utils/contains_string.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace couchbase::core::utils
+{
+auto
+contains_string(std::string_view input, std::string_view substr, bool ignore_case = false) -> bool;
+} // namespace couchbase::core::utils