couchbase 4.4.1 → 4.4.2

package/deps/couchbase-cxx-client/core/io/http_session.cxx

@@ -243,7 +243,10 @@ http_session::endpoint() -> const asio::ip::tcp::endpoint&
 void
 http_session::connect(utils::movable_function<void()>&& callback)
 {
-  connect_callback_ = std::move(callback);
+  {
+    const std::scoped_lock lock(connect_callback_mutex_);
+    connect_callback_ = std::move(callback);
+  }
   initiate_connect();
 }
 
@@ -276,9 +279,7 @@ http_session::initiate_connect()
       if (ec == asio::error::operation_aborted || self->stopped_) {
         return;
       }
-      if (auto callback = std::move(self->connect_callback_); callback) {
-        callback();
-      }
+      self->invoke_connect_callback();
     });
     return;
   }
@@ -309,6 +310,19 @@ http_session::cancel_current_response(std::error_code ec)
   }
 }
 
+void
+http_session::invoke_connect_callback()
+{
+  utils::movable_function<void()> cb;
+  {
+    const std::scoped_lock lock(connect_callback_mutex_);
+    cb = std::move(connect_callback_);
+  }
+  if (cb) {
+    cb();
+  }
+}
+
 void
 http_session::stop()
 {
@@ -319,12 +333,10 @@ http_session::stop()
   state_ = diag::endpoint_state::disconnecting;
   stream_->close([](std::error_code) {
   });
+  invoke_connect_callback();
   connect_deadline_timer_.cancel();
   idle_timer_.cancel();
   retry_backoff_.cancel();
-  if (connect_callback_) {
-    connect_callback_ = nullptr;
-  }
 
   cancel_current_response(errc::common::request_canceled);
 
@@ -387,6 +399,8 @@ http_session::write_and_stream(
   utils::movable_function<void()> stream_end_handler)
 {
   if (stopped_) {
+    resp_handler(errc::common::request_canceled, {});
+    stream_end_handler();
     return;
   }
   {
@@ -627,9 +641,7 @@ http_session::on_connect(const std::error_code& ec,
       info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
     }
     connect_deadline_timer_.cancel();
-    if (auto callback = std::move(connect_callback_); callback) {
-      callback();
-    }
+    invoke_connect_callback();
     flush();
   }
 }

package/deps/couchbase-cxx-client/core/io/http_session.hxx

@@ -177,6 +177,7 @@ private:
   void write(const std::string_view& buf);
   void flush();
   void cancel_current_response(std::error_code ec);
+  void invoke_connect_callback();
 
   service_type type_{};
   std::string client_id_;
@@ -199,6 +200,7 @@ private:
   std::atomic_bool reading_{ false };
 
   utils::movable_function<void()> connect_callback_{};
+  std::mutex connect_callback_mutex_{};
   std::function<void()> on_stop_handler_{ nullptr };
 
   response_context current_response_{};

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -283,13 +283,16 @@ public:
       }
     }
 
-    std::scoped_lock lock(sessions_mutex_);
+    const std::scoped_lock lock(sessions_mutex_);
     idle_sessions_[type].remove_if([](const auto& s) {
       return !s;
     });
     busy_sessions_[type].remove_if([](const auto& s) {
       return !s;
     });
+    pending_sessions_[type].remove_if([](const auto& s) {
+      return !s;
+    });
     std::shared_ptr<http_session> session{};
     while (!idle_sessions_[type].empty()) {
       if (preferred_node.empty()) {
@@ -337,6 +340,8 @@ public:
     }
     if (session->is_connected()) {
       busy_sessions_[type].push_back(session);
+    } else {
+      pending_sessions_[type].push_back(session);
     }
     return { {}, session };
   }
@@ -370,6 +375,9 @@ public:
       busy_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
         return !s || s->id() == id;
       });
+      pending_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
+        return !s || s->id() == id;
+      });
     }
   }
 
@@ -378,8 +386,15 @@ public:
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     drain_deferred_queue(errc::common::request_canceled);
 #endif
-    std::scoped_lock lock(sessions_mutex_);
-    for (auto& [type, sessions] : idle_sessions_) {
+    std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions, idle_sessions,
+      pending_sessions;
+    {
+      const std::scoped_lock lock(sessions_mutex_);
+      busy_sessions = std::move(busy_sessions_);
+      idle_sessions = std::move(idle_sessions_);
+      pending_sessions = std::move(pending_sessions_);
+    }
+    for (auto& [type, sessions] : idle_sessions) {
       for (auto& s : sessions) {
         if (s) {
           s->reset_idle();
@@ -387,7 +402,20 @@ public:
         }
       }
     }
-    busy_sessions_.clear();
+    for (auto& [type, sessions] : busy_sessions) {
+      for (auto& s : sessions) {
+        if (s) {
+          s->stop();
+        }
+      }
+    }
+    for (auto& [type, sessions] : pending_sessions) {
+      for (auto& s : sessions) {
+        if (s) {
+          s->stop();
+        }
+      }
+    }
   }
 
   template<typename Request, typename Handler>
@@ -471,7 +499,7 @@ public:
   {
     session->connect([self = shared_from_this(),
                       session,
-                      preferred_node = std::move(preferred_node),
+                      preferred_node,
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
                       dispatch_deadline,
 #endif
@@ -480,13 +508,20 @@ public:
       if (!session->is_connected()) {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
         auto now = std::chrono::steady_clock::now();
+        if (session->is_stopped()) {
+          // Session was forced to stop (e.g. due to cluster being closed or cancellation)
+          cb(errc::common::request_canceled, {});
+          return;
+        }
         if (dispatch_deadline < now || deadline < now) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #else
         if (deadline < std::chrono::steady_clock::now()) {
           session->stop();
+          return cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #endif
@@ -504,12 +539,16 @@ public:
           self->create_session(session->type(), session->credentials(), hostname, port);
         if (new_session->is_connected()) {
           {
-            std::scoped_lock inner_lock(self->sessions_mutex_);
+            const std::scoped_lock inner_lock(self->sessions_mutex_);
             self->busy_sessions_[new_session->type()].push_back(new_session);
           }
           cb({}, new_session);
         } else {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+          {
+            const std::scoped_lock inner_lock(self->sessions_mutex_);
+            self->pending_sessions_[new_session->type()].push_back(new_session);
+          }
           self->connect_then_send_pending_op(
             new_session, preferred_node, dispatch_deadline, deadline, cb);
 #else
@@ -521,17 +560,23 @@ public:
         auto now = std::chrono::steady_clock::now();
         if (dispatch_deadline < now || deadline < now) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #else
         if (deadline < std::chrono::steady_clock::now()) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #endif
         {
-          std::scoped_lock inner_lock(self->sessions_mutex_);
+          const std::scoped_lock inner_lock(self->sessions_mutex_);
           self->busy_sessions_[session->type()].push_back(session);
+          self->pending_sessions_[session->type()].remove_if(
+            [id = session->id()](const auto& s) -> bool {
+              return !s || s->id() == id;
+            });
         }
         cb({}, session);
       }
@@ -844,6 +889,7 @@ private:
   mutable std::mutex config_mutex_{};
   std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};
   std::map<service_type, std::list<std::shared_ptr<http_session>>> idle_sessions_{};
+  std::map<service_type, std::list<std::shared_ptr<http_session>>> pending_sessions_{};
   std::size_t next_index_{ 0 };
   std::mutex next_index_mutex_{};
   std::mutex sessions_mutex_{};

package/deps/couchbase-cxx-client/core/io/http_streaming_response.cxx

@@ -16,6 +16,7 @@
  */
 
 #include "http_streaming_response.hxx"
+
 #include "core/utils/movable_function.hxx"
 #include "http_session.hxx"
 

package/deps/couchbase-cxx-client/core/logger/custom_rotating_file_sink.cxx

@@ -28,7 +28,9 @@
 #include <memory>
 #include <spdlog/details/file_helper.h>
 
-static auto
+namespace
+{
+auto
 find_first_logfile_id(const std::string& basename) -> unsigned long
 {
   unsigned long id = 0;
@@ -46,7 +48,7 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
     index = file.rfind('.');
     if (index != std::string::npos) {
       try {
-        unsigned long value = std::stoul(file.substr(index + 1));
+        const unsigned long value = std::stoul(file.substr(index + 1));
         if (value > id) {
           id = value;
         }
@@ -60,19 +62,20 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
 
   return id;
 }
+} // namespace
 
 template<class Mutex>
 custom_rotating_file_sink<Mutex>::custom_rotating_file_sink(const spdlog::filename_t& base_filename,
                                                             std::size_t max_size,
                                                             const std::string& log_pattern)
-  : base_filename_(base_filename)
-  , max_size_(max_size)
-  , next_file_id_(find_first_logfile_id(base_filename))
+  : base_filename_{ base_filename }
+  , max_size_{ max_size }
+  , file_helper_{ open_file() }
+  , current_size_{ file_helper_->size() } // expensive. called only once
+  , formatter{ std::make_unique<spdlog::pattern_formatter>(log_pattern,
+                                                           spdlog::pattern_time_type::local) }
+  , next_file_id_{ find_first_logfile_id(base_filename) }
 {
-  formatter =
-    std::make_unique<spdlog::pattern_formatter>(log_pattern, spdlog::pattern_time_type::local);
-  file_helper_ = open_file();
-  current_size_ = file_helper_->size(); // expensive. called only once
   add_hook(opening_log_file_);
 }
 

package/deps/couchbase-cxx-client/core/logger/custom_rotating_file_sink.hxx

@@ -65,8 +65,8 @@ private:
 
   const spdlog::filename_t base_filename_;
   const std::size_t max_size_;
-  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::details::file_helper> file_helper_;
+  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::pattern_formatter> formatter;
   unsigned long next_file_id_;
 

package/deps/couchbase-cxx-client/core/logger/logger.cxx

@@ -34,15 +34,17 @@
 #include <string_view>
 #include <utility>
 
-static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
-static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
+namespace
+{
+const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
+const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
 
 /**
  * Custom log pattern which the loggers will use.
  * This pattern is duplicated for some test cases. If you need to update it,
  * please also update in all relevant places.
  */
-static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
+const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
 
 /**
  * Instances of spdlog (async) file logger.
@@ -52,12 +54,10 @@ static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t]
  * messages and send them to the sinks, which do the actual writing (to file,
  * to stream etc.) or further processing.
  */
-static std::shared_ptr<spdlog::logger> file_logger{};
-static std::mutex file_logger_mutex;
-static std::atomic_int file_logger_version{ 0 };
+std::shared_ptr<spdlog::logger> file_logger{};
+std::mutex file_logger_mutex;
+std::atomic_int file_logger_version{ 0 };
 
-namespace
-{
 auto
 get_file_logger() -> std::shared_ptr<spdlog::logger>
 {
@@ -81,12 +81,12 @@ update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
   spdlog::register_logger(new_logger);
   ++file_logger_version;
 }
-} // namespace
 
 /**
  * Instance of the protocol logger.
  */
-static std::shared_ptr<spdlog::logger> protocol_logger{};
+std::shared_ptr<spdlog::logger> protocol_logger{};
+} // namespace
 
 namespace couchbase::core::logger
 {

package/deps/couchbase-cxx-client/core/meta/version.cxx

@@ -72,16 +72,15 @@ sdk_build_info() -> std::map<std::string, std::string>
   info["cxx"] = COUCHBASE_CXX_CLIENT_CXX_COMPILER;
   info["cmake_version"] = CMAKE_VERSION;
   info["cmake_build_type"] = CMAKE_BUILD_TYPE;
-  info["compile_definitions"] = COUCHBASE_CXX_CLIENT_COMPILE_DEFINITIONS;
-  info["compile_features"] = COUCHBASE_CXX_CLIENT_COMPILE_FEATURES;
-  info["compile_flags"] = COUCHBASE_CXX_CLIENT_COMPILE_FLAGS;
-  info["compile_options"] = COUCHBASE_CXX_CLIENT_COMPILE_OPTIONS;
-  info["link_depends"] = COUCHBASE_CXX_CLIENT_LINK_DEPENDS;
-  info["link_flags"] = COUCHBASE_CXX_CLIENT_LINK_FLAGS;
-  info["link_libraries"] = COUCHBASE_CXX_CLIENT_LINK_LIBRARIES;
-  info["link_options"] = COUCHBASE_CXX_CLIENT_LINK_OPTIONS;
+  info["static_target"] =
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET)
+    "true"
+#else
+    "false"
+#endif
+    ;
   info["static_stdlib"] =
-#if defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET) && defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
     "true"
 #else
     "false"
@@ -250,15 +249,17 @@ parse_git_describe_output(const std::string& git_describe_output) -> std::string
   return "";
 }
 
-const std::string&
-build_revision_short()
+auto
+build_revision_short() -> const std::string&
 {
   static const std::string revision{ COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT };
   return revision;
 }
 
-static std::string
-revision_with_prefix(std::string_view prefix)
+namespace
+{
+auto
+revision_with_prefix(std::string_view prefix) -> std::string
 {
   const auto& revision = build_revision_short();
   if (revision.empty() || revision == "unknown") {
@@ -266,6 +267,7 @@ revision_with_prefix(std::string_view prefix)
   }
   return fmt::format("{}{}", prefix, revision);
 }
+} // namespace
 
 auto
 build_date() -> const std::string&

package/deps/couchbase-cxx-client/core/metrics/logging_meter.cxx

@@ -205,7 +205,7 @@ logging_meter::get_value_recorder(const std::string& name,
                                   const std::map<std::string, std::string>& tags)
   -> std::shared_ptr<couchbase::metrics::value_recorder>
 {
-  static std::shared_ptr<noop_value_recorder> noop_recorder{
+  static const std::shared_ptr<noop_value_recorder> noop_recorder{
     std::make_shared<noop_value_recorder>()
   };
 
@@ -214,18 +214,18 @@ logging_meter::get_value_recorder(const std::string& name,
   }
 
   static const std::string service_tag = "db.couchbase.service";
-  auto service = tags.find(service_tag);
+  const auto service = tags.find(service_tag);
   if (service == tags.end()) {
     return noop_recorder;
   }
 
   static const std::string operation_tag = "db.operation";
-  auto operation = tags.find(operation_tag);
+  const auto operation = tags.find(operation_tag);
   if (operation == tags.end()) {
     return noop_recorder;
   }
 
-  std::scoped_lock lock(recorders_mutex_);
+  const std::scoped_lock lock(recorders_mutex_);
   auto& service_recorders = recorders_[service->second];
 
   auto recorder = service_recorders.find(operation->second);

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

@@ -16,11 +16,15 @@
  */
 
 #include "document_lookup_in.hxx"
+
 #include "core/impl/subdoc/path_flags.hxx"
 #include "core/protocol/hello_feature.hxx"
+#include "core/utils/json.hxx"
 
 #include <couchbase/error_codes.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::operations
 {
 auto

package/deps/couchbase-cxx-client/core/operations/document_lookup_in.hxx

@@ -27,6 +27,7 @@
 #include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
+#include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/lookup_in_result.hxx>
 
 namespace couchbase::core::operations

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -25,8 +25,8 @@
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
 
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
 
 #include <functional>
 #include <memory>

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -24,9 +24,10 @@
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
-#include "couchbase/read_preference.hxx"
+
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/read_preference.hxx>
 
 #include <functional>
 #include <memory>

package/deps/couchbase-cxx-client/core/platform/CMakeLists.txt

@@ -2,22 +2,3 @@ add_library(couchbase_backtrace OBJECT backtrace.c)
 target_include_directories(couchbase_backtrace PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
 target_link_libraries(couchbase_backtrace PRIVATE ${PLATFORM_LIBRARIES})
 set_target_properties(couchbase_backtrace PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-add_library(
-  couchbase_platform STATIC
-  dirutils.cc
-  random.cc
-  string_hex.cc
-  uuid.cc
-  base64.cc
-  terminate_handler.cc)
-set_target_properties(couchbase_platform PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_include_directories(couchbase_platform PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
-target_link_libraries(
-  couchbase_platform
-  PRIVATE project_options
-          project_warnings
-          couchbase_backtrace
-          fmt::fmt
-          spdlog::spdlog
-          Microsoft.GSL::GSL)

package/deps/couchbase-cxx-client/core/platform/base64.cc

@@ -34,14 +34,16 @@
 #include <string_view>
 #include <vector>
 
+namespace
+{
 /**
  * An array of the legal characters used for direct lookup
  */
-static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-                                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-                                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-                                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                          'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                          'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                          '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
 
 /**
  * A method to map the code back to the value
@@ -49,8 +51,8 @@ static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J
  * @param code the code to map
  * @return the byte value for the code character
  */
-static std::uint32_t
-code2val(const char code)
+auto
+code2val(const char code) -> std::uint32_t
 {
   if (code >= 'A' && code <= 'Z') {
     return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('A');
@@ -70,6 +72,8 @@ code2val(const char code)
   throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
 }
 
+// TODO(CXXCBC-549): clang-tidy-19 reports subscript with non-const index
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
 /**
  * Encode up to 3 characters to 4 output character.
  *
@@ -77,7 +81,7 @@ code2val(const char code)
  * @param d pointer to the output stream
  * @param num the number of characters from s to encode
  */
-static void
+void
 encode_rest(const std::byte* s, std::string& result, size_t num)
 {
   std::uint32_t val = 0;
@@ -109,7 +113,7 @@ encode_rest(const std::byte* s, std::string& result, size_t num)
  * @param s pointer to the input stream
  * @param d pointer to the output stream
  */
-static void
+void
 encode_triplet(const std::byte* s, std::string& str)
 {
   auto val = (static_cast<std::uint32_t>(*s) << 16U) |      //
@@ -120,6 +124,7 @@ encode_triplet(const std::byte* s, std::string& str)
   str.push_back(codemap[(val >> 6U) & 63]);
   str.push_back(codemap[val & 63]);
 }
+// NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
 
 /**
  * decode 4 input characters to up to two output bytes
@@ -128,8 +133,8 @@ encode_triplet(const std::byte* s, std::string& str)
  * @param d destination
  * @return the number of characters inserted
  */
-static int
-decode_quad(const char* s, std::vector<std::byte>& d)
+auto
+decode_quad(const char* s, std::vector<std::byte>& d) -> int
 {
   std::uint32_t value = code2val(s[0]) << 18U;
   value |= code2val(s[1]) << 12U;
@@ -157,11 +162,12 @@ decode_quad(const char* s, std::vector<std::byte>& d)
 
   return ret;
 }
+} // namespace
 
 namespace couchbase::core::base64
 {
-std::string
-encode(gsl::span<const std::byte> blob, bool pretty_print)
+auto
+encode(gsl::span<const std::byte> blob, bool pretty_print) -> std::string
 {
   // base64 encodes up to 3 input characters to 4 output
   // characters in the alphabet above.
@@ -204,8 +210,8 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   return result;
 }
 
-std::vector<std::byte>
-decode(std::string_view blob)
+auto
+decode(std::string_view blob) -> std::vector<std::byte>
 {
   std::vector<std::byte> destination;
 
@@ -241,15 +247,15 @@ decode(std::string_view blob)
   return destination;
 }
 
-std::string
-decode_to_string(std::string_view blob)
+auto
+decode_to_string(std::string_view blob) -> std::string
 {
   auto decoded = decode(blob);
   return { reinterpret_cast<const char*>(decoded.data()), decoded.size() };
 }
 
-std::string
-encode(std::string_view blob, bool pretty_print)
+auto
+encode(std::string_view blob, bool pretty_print) -> std::string
 {
   return encode(gsl::as_bytes(gsl::span{ blob.data(), blob.size() }), pretty_print);
 }