couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/logger/logger.hxx

@@ -38,8 +38,8 @@ namespace couchbase::core::logger
 {
 struct configuration;
 
-level
-level_from_str(const std::string& str);
+auto
+level_from_str(const std::string& str) -> level;
 
 /**
  * Initialize the logger.
@@ -51,8 +51,8 @@ level_from_str(const std::string& str);
  * @param logger_settings the configuration for the logger
  * @return optional error message if something goes wrong
  */
-std::optional<std::string>
-create_file_logger(const configuration& logger_settings);
+auto
+create_file_logger(const configuration& logger_settings) -> std::optional<std::string>;
 
 /**
  * Protocol logger writes only communication logs with the nodes.
@@ -62,13 +62,14 @@ create_file_logger(const configuration& logger_settings);
  * @param logger_settings
  * @return
  */
-std::optional<std::string>
-create_protocol_logger(const configuration& logger_settings);
+auto
+create_protocol_logger(const configuration& logger_settings) -> std::optional<std::string>;
 
 /**
  * Initialize the logger with the blackhole logger object
  *
- * This method is intended to be used by unit tests which don't need any output (but may call methods who tries to fetch the logger)
+ * This method is intended to be used by unit tests which don't need any output (but may call
+ * methods who tries to fetch the logger)
  *
  * See note about thread safety at the top of the file
  *
@@ -101,8 +102,8 @@ create_console_logger();
  * - create_blackhole_logger()
  * - create_console_logger()
  */
-spdlog::logger*
-get();
+auto
+get() -> spdlog::logger*;
 
 /**
  * Reset the underlying logger object
@@ -113,8 +114,9 @@ void
 reset();
 
 /**
- * Engines that create their own instances of an spdlog::logger should register the logger here to ensure that the verbosity of the logger
- * is updated when memcached receives a request to update verbosity
+ * Engines that create their own instances of an spdlog::logger should register the logger here to
+ * ensure that the verbosity of the logger is updated when memcached receives a request to update
+ * verbosity
  *
  * @param l spdlog::logger instance
  */
@@ -136,8 +138,8 @@ unregister_spdlog_logger(const std::string& n);
  * @param log severity level
  * @return true if all registered loggers have the specified severity level
  */
-bool
-check_log_levels(level lvl);
+auto
+check_log_levels(level lvl) -> bool;
 
 /**
  * Set the log level of all registered spdLoggers
@@ -152,11 +154,11 @@ set_log_levels(level lvl);
  * @param level severity level to check
  * @return true if we should log at this level
  */
-bool
-should_log(level lvl);
+auto
+should_log(level lvl) -> bool;
 
-bool
-should_log_protocol();
+auto
+should_log_protocol() -> bool;
 
 namespace detail
 {
@@ -180,16 +182,25 @@ log_protocol(const char* file, int line, const char* function, std::string_view
  */
 template<typename... Args>
 inline void
-log(const char* file, int line, const char* function, level lvl, fmt::format_string<Args...> msg, Args&&... args)
+log(const char* file,
+    int line,
+    const char* function,
+    level lvl,
+    fmt::format_string<Args...> msg,
+    Args&&... args)
 {
-    detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
+  detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
 }
 
 template<typename... Args>
 inline void
-log_protocol(const char* file, int line, const char* function, fmt::format_string<Args...> msg, Args&&... args)
+log_protocol(const char* file,
+             int line,
+             const char* function,
+             fmt::format_string<Args...> msg,
+             Args&&... args)
 {
-    detail::log_protocol(file, line, function, fmt::format(msg, std::forward<Args>(args)...));
+  detail::log_protocol(file, line, function, fmt::format(msg, std::forward<Args>(args)...));
 }
 
 /**
@@ -208,8 +219,8 @@ shutdown();
 /**
  * @return whether or not the logger has been initialized
  */
-bool
-is_initialized();
+auto
+is_initialized() -> bool;
 
 } // namespace couchbase::core::logger
 
@@ -223,27 +234,57 @@ is_initialized();
  * on log messages which likely will not actually be logged due to their
  * severity value not matching the logger.
  */
-#define COUCHBASE_LOG(file, line, function, severity, ...)                                                                                 \
-    do {                                                                                                                                   \
-        if (couchbase::core::logger::should_log(severity)) {                                                                               \
-            couchbase::core::logger::log(file, line, function, severity, __VA_ARGS__);                                                     \
-        }                                                                                                                                  \
-    } while (false)
-
-#define CB_LOG_TRACE(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, __VA_ARGS__)
-#define CB_LOG_DEBUG(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, __VA_ARGS__)
-#define CB_LOG_INFO(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, __VA_ARGS__)
-#define CB_LOG_WARNING(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, __VA_ARGS__)
-#define CB_LOG_ERROR(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, __VA_ARGS__)
-#define CB_LOG_CRITICAL(...)                                                                                                               \
-    COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, __VA_ARGS__)
-
-#define CB_LOG_PROTOCOL(...)                                                                                                               \
-    do {                                                                                                                                   \
-        if (couchbase::core::logger::should_log_protocol()) {                                                                              \
-            couchbase::core::logger::log_protocol(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, __VA_ARGS__);                             \
-        }                                                                                                                                  \
-    } while (false)
+#define COUCHBASE_LOG(file, line, function, severity, ...)                                         \
+  do {                                                                                             \
+    if (couchbase::core::logger::should_log(severity)) {                                           \
+      couchbase::core::logger::log(file, line, function, severity, __VA_ARGS__);                   \
+    }                                                                                              \
+  } while (false)
+
+#define CB_LOG_TRACE(...)                                                                          \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::trace,                                             \
+                __VA_ARGS__)
+#define CB_LOG_DEBUG(...)                                                                          \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::debug,                                             \
+                __VA_ARGS__)
+#define CB_LOG_INFO(...)                                                                           \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::info,                                              \
+                __VA_ARGS__)
+#define CB_LOG_WARNING(...)                                                                        \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::warn,                                              \
+                __VA_ARGS__)
+#define CB_LOG_ERROR(...)                                                                          \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::err,                                               \
+                __VA_ARGS__)
+#define CB_LOG_CRITICAL(...)                                                                       \
+  COUCHBASE_LOG(__FILE__,                                                                          \
+                __LINE__,                                                                          \
+                COUCHBASE_LOGGER_FUNCTION,                                                         \
+                couchbase::core::logger::level::critical,                                          \
+                __VA_ARGS__)
+
+#define CB_LOG_PROTOCOL(...)                                                                       \
+  do {                                                                                             \
+    if (couchbase::core::logger::should_log_protocol()) {                                          \
+      couchbase::core::logger::log_protocol(                                                       \
+        __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, __VA_ARGS__);                               \
+    }                                                                                              \
+  } while (false)
 
 /**
  * Convenience macros which log with the given level, and message, if the given
@@ -255,17 +296,28 @@ is_initialized();
  *   LOG_INFO_RAW("Starting flusher");
  *   LOG_INFO_RAW(std:string{...});
  */
-#define COUCHBASE_LOG_RAW(file, line, function, severity, msg)                                                                             \
-    do {                                                                                                                                   \
-        if (couchbase::core::logger::should_log(severity)) {                                                                               \
-            couchbase::core::logger::detail::log(file, line, function, severity, msg);                                                     \
-        }                                                                                                                                  \
-    } while (false)
-
-#define CB_LOG_TRACE_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, msg)
-#define CB_LOG_DEBUG_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, msg)
-#define CB_LOG_INFO_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, msg)
-#define CB_LOG_WARNING_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, msg)
-#define CB_LOG_ERROR_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, msg)
-#define CB_LOG_CRITICAL_RAW(msg)                                                                                                           \
-    COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, msg)
+#define COUCHBASE_LOG_RAW(file, line, function, severity, msg)                                     \
+  do {                                                                                             \
+    if (couchbase::core::logger::should_log(severity)) {                                           \
+      couchbase::core::logger::detail::log(file, line, function, severity, msg);                   \
+    }                                                                                              \
+  } while (false)
+
+#define CB_LOG_TRACE_RAW(msg)                                                                      \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, msg)
+#define CB_LOG_DEBUG_RAW(msg)                                                                      \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, msg)
+#define CB_LOG_INFO_RAW(msg)                                                                       \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, msg)
+#define CB_LOG_WARNING_RAW(msg)                                                                    \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, msg)
+#define CB_LOG_ERROR_RAW(msg)                                                                      \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, msg)
+#define CB_LOG_CRITICAL_RAW(msg)                                                                   \
+  COUCHBASE_LOG_RAW(                                                                               \
+    __FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, msg)

data/ext/couchbase/core/management/analytics_dataset.hxx

@@ -22,9 +22,9 @@
 namespace couchbase::core::management::analytics
 {
 struct dataset {
-    std::string name;
-    std::string dataverse_name;
-    std::string link_name;
-    std::string bucket_name;
+  std::string name;
+  std::string dataverse_name;
+  std::string link_name;
+  std::string bucket_name;
 };
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_index.hxx

@@ -22,9 +22,9 @@
 namespace couchbase::core::management::analytics
 {
 struct index {
-    std::string name;
-    std::string dataverse_name;
-    std::string dataset_name;
-    bool is_primary;
+  std::string name;
+  std::string dataverse_name;
+  std::string dataset_name;
+  bool is_primary;
 };
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_azure_blob_external.cxx

@@ -25,44 +25,46 @@
 
 namespace couchbase::core::management::analytics
 {
-std::error_code
-azure_blob_external_link::validate() const
+auto
+azure_blob_external_link::validate() const -> std::error_code
 {
-    if (dataverse.empty() || link_name.empty()) {
-        return errc::common::invalid_argument;
-    }
-    if (connection_string.has_value() || (account_name.has_value() && (account_key.has_value() || shared_access_signature.has_value()))) {
-        return {};
-    }
+  if (dataverse.empty() || link_name.empty()) {
     return errc::common::invalid_argument;
+  }
+  if (connection_string.has_value() ||
+      (account_name.has_value() &&
+       (account_key.has_value() || shared_access_signature.has_value()))) {
+    return {};
+  }
+  return errc::common::invalid_argument;
 }
 
-std::string
-azure_blob_external_link::encode() const
+auto
+azure_blob_external_link::encode() const -> std::string
 {
-    std::map<std::string, std::string> values{
-        { "type", "azureblob" },
-    };
-    if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
-        values["dataverse"] = dataverse;
-        values["name"] = link_name;
-    }
-    if (connection_string) {
-        values["connectionString"] = connection_string.value();
-    } else if (account_name) {
-        values["accountName"] = account_name.value();
-        if (account_key) {
-            values["accountKey"] = account_key.value();
-        } else if (shared_access_signature) {
-            values["sharedAccessSignature"] = shared_access_signature.value();
-        }
-    }
-    if (blob_endpoint) {
-        values["blobEndpoint"] = blob_endpoint.value();
-    }
-    if (endpoint_suffix) {
-        values["endpointSuffix"] = endpoint_suffix.value();
+  std::map<std::string, std::string> values{
+    { "type", "azureblob" },
+  };
+  if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+    values["dataverse"] = dataverse;
+    values["name"] = link_name;
+  }
+  if (connection_string) {
+    values["connectionString"] = connection_string.value();
+  } else if (account_name) {
+    values["accountName"] = account_name.value();
+    if (account_key) {
+      values["accountKey"] = account_key.value();
+    } else if (shared_access_signature) {
+      values["sharedAccessSignature"] = shared_access_signature.value();
     }
-    return utils::string_codec::v2::form_encode(values);
+  }
+  if (blob_endpoint) {
+    values["blobEndpoint"] = blob_endpoint.value();
+  }
+  if (endpoint_suffix) {
+    values["endpointSuffix"] = endpoint_suffix.value();
+  }
+  return utils::string_codec::v2::form_encode(values);
 }
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_azure_blob_external.hxx

@@ -28,49 +28,50 @@ namespace couchbase::core::management::analytics
  * Only available as of 7.0 Developer Preview.
  */
 struct azure_blob_external_link {
-    /**
-     * The name of this link.
-     */
-    std::string link_name{};
+  /**
+   * The name of this link.
+   */
+  std::string link_name{};
 
-    /**
-     * The dataverse that this link belongs to.
-     */
-    std::string dataverse{};
+  /**
+   * The dataverse that this link belongs to.
+   */
+  std::string dataverse{};
 
-    /**
-     * The connection string can be used as an authentication method, connectionString contains other authentication methods embedded inside
-     * the string. Only a single authentication method can be used. (e.g. "AccountName=myAccountName;AccountKey=myAccountKey").
-     */
-    std::optional<std::string> connection_string{};
+  /**
+   * The connection string can be used as an authentication method, connectionString contains other
+   * authentication methods embedded inside the string. Only a single authentication method can be
+   * used. (e.g. "AccountName=myAccountName;AccountKey=myAccountKey").
+   */
+  std::optional<std::string> connection_string{};
 
-    /**
-     * Azure blob storage account name
-     */
-    std::optional<std::string> account_name{};
+  /**
+   * Azure blob storage account name
+   */
+  std::optional<std::string> account_name{};
 
-    /**
-     * Azure blob storage account key
-     */
-    std::optional<std::string> account_key{};
+  /**
+   * Azure blob storage account key
+   */
+  std::optional<std::string> account_key{};
 
-    /**
-     * Token that can be used for authentication
-     */
-    std::optional<std::string> shared_access_signature{};
+  /**
+   * Token that can be used for authentication
+   */
+  std::optional<std::string> shared_access_signature{};
 
-    /**
-     * Azure blob storage endpoint
-     */
-    std::optional<std::string> blob_endpoint{};
+  /**
+   * Azure blob storage endpoint
+   */
+  std::optional<std::string> blob_endpoint{};
 
-    /**
-     * Azure blob endpoint suffix
-     */
-    std::optional<std::string> endpoint_suffix{};
+  /**
+   * Azure blob endpoint suffix
+   */
+  std::optional<std::string> endpoint_suffix{};
 
-    [[nodiscard]] std::error_code validate() const;
+  [[nodiscard]] auto validate() const -> std::error_code;
 
-    [[nodiscard]] std::string encode() const;
+  [[nodiscard]] auto encode() const -> std::string;
 };
 } // namespace couchbase::core::management::analytics

data/ext/couchbase/core/management/analytics_link_azure_blob_external_json.hxx

@@ -25,28 +25,32 @@ namespace tao::json
 {
 template<>
 struct traits<couchbase::core::management::analytics::azure_blob_external_link> {
-    template<template<typename...> class Traits>
-    static couchbase::core::management::analytics::azure_blob_external_link as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::core::management::analytics::azure_blob_external_link result{};
+  template<template<typename...> class Traits>
+  static auto as(const tao::json::basic_value<Traits>& v)
+    -> couchbase::core::management::analytics::azure_blob_external_link
+  {
+    couchbase::core::management::analytics::azure_blob_external_link result{};
 
-        result.link_name = v.at("name").get_string();
-        if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
-            result.dataverse = dataverse->get_string();
-        } else {
-            result.dataverse = v.at("scope").get_string();
-        }
+    result.link_name = v.at("name").get_string();
+    if (const auto* dataverse = v.find("dataverse"); dataverse != nullptr) {
+      result.dataverse = dataverse->get_string();
+    } else {
+      result.dataverse = v.at("scope").get_string();
+    }
 
-        if (const auto* account_name = v.find("accountName"); account_name != nullptr && account_name->is_string()) {
-            result.account_name.emplace(account_name->get_string());
-        }
-        if (const auto* blob_endpoint = v.find("blobEndpoint"); blob_endpoint != nullptr && blob_endpoint->is_string()) {
-            result.blob_endpoint.emplace(blob_endpoint->get_string());
-        }
-        if (const auto* endpoint_suffix = v.find("endpointSuffix"); endpoint_suffix != nullptr && endpoint_suffix->is_string()) {
-            result.endpoint_suffix.emplace(endpoint_suffix->get_string());
-        }
-        return result;
+    if (const auto* account_name = v.find("accountName");
+        account_name != nullptr && account_name->is_string()) {
+      result.account_name.emplace(account_name->get_string());
+    }
+    if (const auto* blob_endpoint = v.find("blobEndpoint");
+        blob_endpoint != nullptr && blob_endpoint->is_string()) {
+      result.blob_endpoint.emplace(blob_endpoint->get_string());
+    }
+    if (const auto* endpoint_suffix = v.find("endpointSuffix");
+        endpoint_suffix != nullptr && endpoint_suffix->is_string()) {
+      result.endpoint_suffix.emplace(endpoint_suffix->get_string());
     }
+    return result;
+  }
 };
 } // namespace tao::json

data/ext/couchbase/core/management/analytics_link_couchbase_remote.cxx

@@ -25,81 +25,82 @@
 
 namespace couchbase::core::management::analytics
 {
-std::error_code
-couchbase_remote_link::validate() const
+auto
+couchbase_remote_link::validate() const -> std::error_code
 {
-    if (dataverse.empty() || link_name.empty() || hostname.empty()) {
-        return errc::common::invalid_argument;
-    }
-    switch (encryption.level) {
-        case couchbase_link_encryption_level::none:
-        case couchbase_link_encryption_level::half:
-            if (/* username and password must be provided */ username.has_value() && password.has_value() &&
-                /* and client certificate and key must be empty */
-                (!encryption.client_certificate.has_value() && !encryption.client_key.has_value())) {
+  if (dataverse.empty() || link_name.empty() || hostname.empty()) {
+    return errc::common::invalid_argument;
+  }
+  switch (encryption.level) {
+    case couchbase_link_encryption_level::none:
+    case couchbase_link_encryption_level::half:
+      if (/* username and password must be provided */ username.has_value() &&
+          password.has_value() &&
+          /* and client certificate and key must be empty */
+          (!encryption.client_certificate.has_value() && !encryption.client_key.has_value())) {
 
-                return {};
-            }
-            return errc::common::invalid_argument;
+        return {};
+      }
+      return errc::common::invalid_argument;
 
-        case couchbase_link_encryption_level::full:
-            if (/* certificate must be provided and */ encryption.certificate.has_value() &&
-                (/* either username/password must be set */ (username.has_value() && password.has_value() &&
-                                                             !encryption.client_certificate.has_value() &&
-                                                             !encryption.client_key.has_value()) ||
-                 /* or client certificate/key must be set */ (!username.has_value() && !password.has_value() &&
-                                                              encryption.client_certificate.has_value() &&
-                                                              encryption.client_key.has_value()))) {
-                return {};
-            }
-            return errc::common::invalid_argument;
-    }
-    return {};
+    case couchbase_link_encryption_level::full:
+      if (/* certificate must be provided and */ encryption.certificate.has_value() &&
+          (/* either username/password must be set */ (
+             username.has_value() && password.has_value() &&
+             !encryption.client_certificate.has_value() && !encryption.client_key.has_value()) ||
+           /* or client certificate/key must be set */ (
+             !username.has_value() && !password.has_value() &&
+             encryption.client_certificate.has_value() && encryption.client_key.has_value()))) {
+        return {};
+      }
+      return errc::common::invalid_argument;
+  }
+  return {};
 }
 
-std::string
-couchbase_remote_link::encode() const
+auto
+couchbase_remote_link::encode() const -> std::string
 {
-    std::map<std::string, std::string> values{
-        { "type", "couchbase" },
-        { "hostname", hostname },
-        { "encryption", to_string(encryption.level) },
-    };
-    if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
-        values["dataverse"] = dataverse;
-        values["name"] = link_name;
-    }
-    if (username) {
-        values["username"] = username.value();
-    }
-    if (password) {
-        values["password"] = password.value();
-    }
-    if (encryption.certificate) {
-        values["certificate"] = encryption.certificate.value();
-    }
-    if (encryption.client_certificate) {
-        values["clientCertificate"] = encryption.client_certificate.value();
-    }
-    if (encryption.client_key) {
-        values["clientKey"] = encryption.client_key.value();
-    }
-    return utils::string_codec::v2::form_encode(values);
+  std::map<std::string, std::string> values{
+    { "type", "couchbase" },
+    { "hostname", hostname },
+    { "encryption", to_string(encryption.level) },
+  };
+  if (std::count(dataverse.begin(), dataverse.end(), '/') == 0) {
+    values["dataverse"] = dataverse;
+    values["name"] = link_name;
+  }
+  if (username) {
+    values["username"] = username.value();
+  }
+  if (password) {
+    values["password"] = password.value();
+  }
+  if (encryption.certificate) {
+    values["certificate"] = encryption.certificate.value();
+  }
+  if (encryption.client_certificate) {
+    values["clientCertificate"] = encryption.client_certificate.value();
+  }
+  if (encryption.client_key) {
+    values["clientKey"] = encryption.client_key.value();
+  }
+  return utils::string_codec::v2::form_encode(values);
 }
 
-std::string
-to_string(couchbase_link_encryption_level level)
+auto
+to_string(couchbase_link_encryption_level level) -> std::string
 {
-    switch (level) {
-        case couchbase_link_encryption_level::none:
-            return "none";
+  switch (level) {
+    case couchbase_link_encryption_level::none:
+      return "none";
 
-        case couchbase_link_encryption_level::half:
-            return "half";
+    case couchbase_link_encryption_level::half:
+      return "half";
 
-        case couchbase_link_encryption_level::full:
-            return "full";
-    }
-    return "none";
+    case couchbase_link_encryption_level::full:
+      return "full";
+  }
+  return "none";
 }
 } // namespace couchbase::core::management::analytics