couchbase 4.4.1-dev.2 → 4.4.2

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

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
 #include "core/protocol/hello_feature.hxx"
 #include "core/response_handler.hxx"
 #include "core/utils/movable_function.hxx"
@@ -46,6 +48,13 @@ namespace couchbase::core
 struct origin;
 class config_listener;
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+namespace columnar
+{
+class background_bootstrap_listener;
+} // namespace columnar
+#endif
+
 namespace topology
 {
 struct configuration;
@@ -59,6 +68,7 @@ struct endpoint_diag_info;
 
 namespace impl
 {
+struct bootstrap_error;
 class bootstrap_state_listener;
 } // namespace impl
 
@@ -79,14 +89,14 @@ public:
   mcbp_session(mcbp_session&& other) = default;
   auto operator=(mcbp_session&& other) -> mcbp_session& = default;
 
-  mcbp_session(std::string client_id,
+  mcbp_session(const std::string& client_id,
                asio::io_context& ctx,
                couchbase::core::origin origin,
                std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                std::optional<std::string> bucket_name = {},
                std::vector<protocol::hello_feature> known_features = {});
 
-  mcbp_session(std::string client_id,
+  mcbp_session(const std::string& client_id,
                asio::io_context& ctx,
                asio::ssl::context& tls,
                couchbase::core::origin origin,
@@ -111,9 +121,11 @@ public:
   [[nodiscard]] auto bootstrap_hostname() const -> const std::string&;
   [[nodiscard]] auto bootstrap_port() const -> const std::string&;
   [[nodiscard]] auto bootstrap_port_number() const -> std::uint16_t;
+  [[nodiscard]] auto last_bootstrap_error() && -> std::optional<impl::bootstrap_error>;
+  [[nodiscard]] auto last_bootstrap_error() const& -> const std::optional<impl::bootstrap_error>&;
   void write_and_flush(std::vector<std::byte>&& buffer);
-  void write_and_subscribe(std::shared_ptr<mcbp::queue_request>,
-                           std::shared_ptr<response_handler> handler);
+  void write_and_subscribe(const std::shared_ptr<mcbp::queue_request>&,
+                           const std::shared_ptr<response_handler>& handler);
   void write_and_subscribe(std::uint32_t opaque,
                            std::vector<std::byte>&& data,
                            command_handler&& handler);
@@ -126,13 +138,17 @@ public:
   [[nodiscard]] auto config() const -> std::optional<topology::configuration>;
   [[nodiscard]] auto diag_info() const -> diag::endpoint_diag_info;
   void on_configuration_update(std::shared_ptr<config_listener> handler);
-  void ping(std::shared_ptr<diag::ping_reporter> handler,
+  void ping(const std::shared_ptr<diag::ping_reporter>& handler,
             std::optional<std::chrono::milliseconds> = {}) const;
   [[nodiscard]] auto supports_gcccp() const -> bool;
   [[nodiscard]] auto decode_error_code(std::uint16_t code)
     -> std::optional<key_value_error_map_info>;
   void handle_not_my_vbucket(const io::mcbp_message& msg) const;
   void update_collection_uid(const std::string& path, std::uint32_t uid);
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void add_background_bootstrap_listener(
+    std::shared_ptr<columnar::background_bootstrap_listener> listener);
+#endif
 
 private:
   std::shared_ptr<mcbp_session_impl> impl_{ nullptr };

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/utils/movable_function.hxx"
 #include "ip_protocol.hxx"
 
 #include <asio.hpp>
@@ -44,7 +45,7 @@ async_resolve(ip_protocol protocol,
       return resolver.async_resolve(
         asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
     case ip_protocol::any:
-      /* fall-through */
+      [[fallthrough]];
     default:
       /* use any protocol */
       break;
@@ -92,20 +93,22 @@ public:
 
   [[nodiscard]] virtual auto local_endpoint() const -> asio::ip::tcp::endpoint = 0;
 
-  virtual void close(std::function<void(std::error_code)>&& handler) = 0;
+  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
 
   virtual void reopen() = 0;
 
   virtual void set_options() = 0;
 
   virtual void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                             std::function<void(std::error_code)>&& handler) = 0;
+                             utils::movable_function<void(std::error_code)>&& handler) = 0;
 
-  virtual void async_write(std::vector<asio::const_buffer>& buffers,
-                           std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+  virtual void async_write(
+    std::vector<asio::const_buffer>& buffers,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) = 0;
 
-  virtual void async_read_some(asio::mutable_buffer buffer,
-                               std::function<void(std::error_code, std::size_t)>&& handler) = 0;
+  virtual void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) = 0;
 };
 
 class plain_stream_impl : public stream_impl
@@ -130,7 +133,7 @@ public:
     return res;
   }
 
-  void close(std::function<void(std::error_code)>&& handler) override
+  void close(utils::movable_function<void(std::error_code)>&& handler) override
   {
     open_ = false;
     return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
@@ -160,7 +163,7 @@ public:
   }
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     std::function<void(std::error_code)>&& handler) override
+                     utils::movable_function<void(std::error_code)>&& handler) override
   {
     return stream_->async_connect(endpoint, [this, h = std::move(handler)](std::error_code ec) {
       open_ = stream_->is_open();
@@ -169,13 +172,14 @@ public:
   }
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   std::function<void(std::error_code, std::size_t)>&& handler) override
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return asio::async_write(*stream_, buffers, std::move(handler));
   }
 
-  void async_read_some(asio::mutable_buffer buffer,
-                       std::function<void(std::error_code, std::size_t)>&& handler) override
+  void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return stream_->async_read_some(buffer, std::move(handler));
   }
@@ -207,7 +211,7 @@ public:
     return res;
   }
 
-  void close(std::function<void(std::error_code)>&& handler) override
+  void close(utils::movable_function<void(std::error_code)>&& handler) override
   {
     open_ = false;
     return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
@@ -238,10 +242,10 @@ public:
   }
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     std::function<void(std::error_code)>&& handler) override
+                     utils::movable_function<void(std::error_code)>&& handler) override
   {
     return stream_->lowest_layer().async_connect(
-      endpoint, [this, handler](std::error_code ec_connect) mutable {
+      endpoint, [this, handler = std::move(handler)](std::error_code ec_connect) mutable {
         if (ec_connect == asio::error::operation_aborted) {
           return;
         }
@@ -249,24 +253,26 @@ public:
           return handler(ec_connect);
         }
         open_ = stream_->lowest_layer().is_open();
-        stream_->async_handshake(asio::ssl::stream_base::client,
-                                 [handler](std::error_code ec_handshake) mutable {
-                                   if (ec_handshake == asio::error::operation_aborted) {
-                                     return;
-                                   }
-                                   return handler(ec_handshake);
-                                 });
+        stream_->async_handshake(
+          asio::ssl::stream_base::client,
+          [handler = std::move(handler)](std::error_code ec_handshake) mutable {
+            if (ec_handshake == asio::error::operation_aborted) {
+              return;
+            }
+            return handler(ec_handshake);
+          });
       });
   }
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   std::function<void(std::error_code, std::size_t)>&& handler) override
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return asio::async_write(*stream_, buffers, std::move(handler));
   }
 
-  void async_read_some(asio::mutable_buffer buffer,
-                       std::function<void(std::error_code, std::size_t)>&& handler) override
+  void async_read_some(
+    asio::mutable_buffer buffer,
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
   {
     return stream_->async_read_some(buffer, std::move(handler));
   }

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

@@ -12,26 +12,39 @@
 #include "logger.hxx"
 
 #include "configuration.hxx"
+#include "core/logger/level.hxx"
 #include "custom_rotating_file_sink.hxx"
 
-#include <chrono>
-#include <mutex>
 #include <spdlog/async.h>
 #include <spdlog/async_logger.h>
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+#include <spdlog/logger.h>
 #include <spdlog/sinks/dist_sink.h>
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
-static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
-static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+
+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.
@@ -41,19 +54,17 @@ 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>
 {
   thread_local std::shared_ptr<spdlog::logger> logger{ nullptr };
   thread_local int version{ -1 };
   if (version != file_logger_version) {
-    std::scoped_lock lock(file_logger_mutex);
+    const std::scoped_lock lock(file_logger_mutex);
     logger = file_logger;
     version = file_logger_version;
   }
@@ -61,21 +72,21 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
 }
 
 void
-update_file_logger(std::shared_ptr<spdlog::logger> new_logger)
+update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
 {
-  std::scoped_lock lock(file_logger_mutex);
+  const std::scoped_lock lock(file_logger_mutex);
   // delete if already exists
   spdlog::drop(file_logger_name);
   file_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
 {
@@ -184,19 +195,11 @@ is_initialized() -> bool
 }
 
 auto
-create_file_logger_impl(const std::string logger_name, const configuration& logger_settings)
+create_file_logger_impl(const std::string& logger_name, const configuration& logger_settings)
   -> std::pair<std::optional<std::string>, std::shared_ptr<spdlog::logger>>
 {
   std::shared_ptr<spdlog::logger> logger{};
 
-  auto fname = logger_settings.filename;
-  auto buffersz = logger_settings.buffer_size;
-  auto cyclesz = logger_settings.cycle_size;
-
-  if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
-    cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
-  }
-
   try {
     // Initialise the loggers.
     //
@@ -228,7 +231,13 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     auto sink = std::make_shared<spdlog::sinks::dist_sink_mt>();
     sink->set_level(spdlog::level::trace);
 
-    if (!fname.empty()) {
+    if (const auto& fname = logger_settings.filename; !fname.empty()) {
+      auto cyclesz = logger_settings.cycle_size;
+
+      if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
+        cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
+      }
+
       auto fsink = std::make_shared<custom_rotating_file_sink_mt>(fname, cyclesz, log_pattern);
       fsink->set_level(spdlog::level::trace);
       sink->add_sink(fsink);
@@ -256,6 +265,7 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     if (logger_settings.unit_test) {
       logger = std::make_shared<spdlog::logger>(logger_name, sink);
     } else {
+      auto buffersz = logger_settings.buffer_size;
       // Create the default thread pool for async logging
       spdlog::init_thread_pool(buffersz, 1);
 
@@ -366,7 +376,7 @@ create_console_logger()
 }
 
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l)
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l)
 {
   try {
     get_file_logger()->debug("Registering logger {}", l->name());
@@ -392,7 +402,7 @@ check_log_levels(level lvl) -> bool
 {
   auto level = translate_level(lvl);
   bool correct = true;
-  spdlog::apply_all([level, &correct](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level, &correct](const std::shared_ptr<spdlog::logger>& l) {
     if (l->level() != level) {
       correct = false;
     }
@@ -405,7 +415,7 @@ set_log_levels(level lvl)
 {
   auto level = translate_level(lvl);
   // Apply the function to each registered spdlog::logger except protocol logger
-  spdlog::apply_all([level](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level](const std::shared_ptr<spdlog::logger>& l) {
     if (l->name() == protocol_logger_name) {
       l->set_level(spdlog::level::trace);
       return;

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

@@ -121,7 +121,7 @@ reset();
  * @param l spdlog::logger instance
  */
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l);
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l);
 
 /**
  * Engines that create their own instances of an spdlog::logger should unregister

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

@@ -19,6 +19,8 @@
 
 #include "core/utils/json.hxx"
 
+#include <tao/json/value.hpp>
+
 namespace
 {
 auto
@@ -68,12 +70,9 @@ index::is_vector_index() const -> bool
   if (types == nullptr || !types->is_object()) {
     return false;
   }
-  for (const auto& [_, val] : types->get_object()) {
-    const auto* properties = val.find("properties");
-    if (properties != nullptr && has_vector_mapping_properties(*properties)) {
-      return true;
-    }
-  }
-  return false;
+  return std::any_of(types->get_object().begin(), types->get_object().end(), [](const auto& pair) {
+    const auto* properties = pair.second.find("properties");
+    return properties != nullptr && has_vector_mapping_properties(*properties);
+  });
 }
 } // namespace couchbase::core::management::search

package/deps/couchbase-cxx-client/core/mcbp/buffer_writer.cxx

@@ -30,7 +30,7 @@ buffer_writer::buffer_writer(std::size_t size)
 void
 buffer_writer::write(const std::vector<std::byte>& val)
 {
-  if (val.size() == 0 || val.data() == nullptr) {
+  if (val.empty() || val.data() == nullptr) {
     return;
   }
   std::memcpy(store_.data() + offset_, val.data(), val.size());

package/deps/couchbase-cxx-client/core/mcbp/codec.cxx

@@ -24,7 +24,9 @@
 #include "core/logger/logger.hxx"
 #include "core/utils/unsigned_leb128.hxx"
 
+#include <algorithm>
 #include <couchbase/error_codes.hxx>
+#include <cstdint>
 
 namespace couchbase::core::mcbp
 {
@@ -50,7 +52,7 @@ codec::is_feature_enabled(protocol::hello_feature feature) const -> bool
 }
 
 auto
-codec::encode_packet(const couchbase::core::mcbp::packet& packet)
+codec::encode_packet(const couchbase::core::mcbp::packet& packet) const
   -> tl::expected<std::vector<std::byte>, std::error_code>
 {
   auto encoded_key = packet.key_;
@@ -65,7 +67,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::unsupported_operation);
     }
     if (supports_collection_id(packet.command_)) {
-      core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
+      const core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
       encoded_key.reserve(encoded_key.size() + encoded.size());
       encoded_key.insert(encoded_key.begin(), encoded.begin(), encoded.end());
     } else if (packet.command_ == protocol::client_opcode::get_random_key) {
@@ -81,9 +83,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
   }
 
-  std::size_t ext_len = extras.size();
-  std::size_t key_len = encoded_key.size();
-  std::size_t val_len = packet.value_.size();
+  const std::size_t ext_len = extras.size();
+  const std::size_t key_len = encoded_key.size();
+  const std::size_t val_len = packet.value_.size();
   std::size_t frames_len = 0;
 
   if (packet.barrier_frame_) {
@@ -99,7 +101,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.open_tracing_frame_) {
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     frames_len = trace_ctx_len;
     if (trace_ctx_len < 15) {
       frames_len += 1;
@@ -111,7 +113,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.user_impersonation_frame_) {
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     frames_len += user_len;
     if (user_len < 15) {
       frames_len += 1;
@@ -143,7 +145,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
         return tl::unexpected(errc::common::unsupported_operation);
     }
   }
-  std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
+  const std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
   buffer_writer buffer{ packet_len };
   buffer.write_byte(static_cast<std::byte>(packet_magic));
   buffer.write_byte(static_cast<std::byte>(packet.command_));
@@ -209,10 +211,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
 
     if (packet.durability_timeout_frame_) {
-      auto millis = packet.durability_timeout_frame_->timeout.count();
-      if (millis > 65535) {
-        millis = 65535;
-      }
+      std::int64_t millis = packet.durability_timeout_frame_->timeout.count();
+      millis =
+        std::min(millis, static_cast<std::int64_t>(std::numeric_limits<std::uint16_t>::max()));
       buffer.write_frame_header(mcbp::request_sync_durability, 3);
       buffer.write_byte(static_cast<std::byte>(packet.durability_level_frame_->level));
       buffer.write_uint16(static_cast<std::uint16_t>(millis));
@@ -243,7 +244,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::feature_not_available);
     }
 
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     if (trace_ctx_len < 15) {
       buffer.write_frame_header(mcbp::request_open_tracing, trace_ctx_len);
       buffer.write(packet.open_tracing_frame_->trace_context);
@@ -273,7 +274,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::invalid_argument);
     }
 
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     if (user_len < 15) {
       buffer.write_frame_header(mcbp::request_user_impersonation, user_len);
       buffer.write(packet.user_impersonation_frame_->user);
@@ -316,7 +317,8 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> input) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   if (input.empty()) {
     return { {}, {}, errc::network::end_of_stream };
@@ -327,22 +329,22 @@ codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size
   if (input.size() < header_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> header{ input.data(), header_len };
+  const gsl::span<std::byte> header{ input.data(), header_len };
 
   // grab the length of the full body
-  std::uint32_t body_len = big_endian::read_uint32(header, 8);
+  const std::uint32_t body_len = big_endian::read_uint32(header, 8);
   // Read the remaining bytes of the body
   if (input.size() < header_len + body_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> body{ input.data() + header_len, body_len };
+  const gsl::span<std::byte> body{ input.data() + header_len, body_len };
 
   return decode_packet(header, body);
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   packet pkt;
 
@@ -376,7 +378,7 @@ codec::decode_packet(gsl::span<std::byte> header,
   pkt.opaque_ = big_endian::read_uint32(header, 12);
   pkt.cas_ = big_endian::read_uint64(header, 16);
 
-  std::size_t header_len = header.size();
+  const std::size_t header_len = header.size();
   std::size_t body_len = body.size();
   std::size_t ext_len = big_endian::read_uint8(header, 4);
   std::size_t key_len = big_endian::read_uint16(header, 2);
@@ -401,13 +403,13 @@ codec::decode_packet(gsl::span<std::byte> header,
                  body_len);
     return { {}, {}, errc::network::protocol_error };
   }
-  std::size_t value_len = body_len - (frames_len + ext_len + key_len);
+  const std::size_t value_len = body_len - (frames_len + ext_len + key_len);
 
   if (frames_len > 0) {
     std::size_t frame_offset = 0;
 
     while (frame_offset < frames_len) {
-      std::byte frame_header = body[frame_offset];
+      const std::byte frame_header = body[frame_offset];
       ++frame_offset;
 
       auto frame_type = std::to_integer<std::uint8_t>((frame_header & std::byte{ 0xf0 }) >> 4);

package/deps/couchbase-cxx-client/core/mcbp/codec.hxx

@@ -38,11 +38,12 @@ class codec
 public:
   explicit codec(std::set<protocol::hello_feature> enabled_features);
 
-  auto encode_packet(const packet& packet) -> tl::expected<std::vector<std::byte>, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> input)
+  auto encode_packet(const packet& packet) const
+    -> tl::expected<std::vector<std::byte>, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> input) const
+    -> std::tuple<packet, std::size_t, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
     -> std::tuple<packet, std::size_t, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>;
   void enable_feature(protocol::hello_feature feature);
   [[nodiscard]] auto is_feature_enabled(protocol::hello_feature feature) const -> bool;