couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/io/streams.hxx

@@ -29,230 +29,247 @@ namespace couchbase::core::io
 
 template<typename Resolver, typename Handler>
 static void
-async_resolve(ip_protocol protocol, Resolver& resolver, const std::string& hostname, const std::string& service, Handler&& handler)
+async_resolve(ip_protocol protocol,
+              Resolver& resolver,
+              const std::string& hostname,
+              const std::string& service,
+              Handler&& handler)
 {
 
-    switch (protocol) {
-        case ip_protocol::force_ipv4:
-            return resolver.async_resolve(asio::ip::tcp::v4(), hostname, service, std::forward<Handler>(handler));
-        case ip_protocol::force_ipv6:
-            return resolver.async_resolve(asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
-        case ip_protocol::any:
-            /* fall-through */
-        default:
-            /* use any protocol */
-            break;
-    }
-    return resolver.async_resolve(hostname, service, std::forward<Handler>(handler));
+  switch (protocol) {
+    case ip_protocol::force_ipv4:
+      return resolver.async_resolve(
+        asio::ip::tcp::v4(), hostname, service, std::forward<Handler>(handler));
+    case ip_protocol::force_ipv6:
+      return resolver.async_resolve(
+        asio::ip::tcp::v6(), hostname, service, std::forward<Handler>(handler));
+    case ip_protocol::any:
+      /* fall-through */
+    default:
+      /* use any protocol */
+      break;
+  }
+  return resolver.async_resolve(hostname, service, std::forward<Handler>(handler));
 }
 
 class stream_impl
 {
-  protected:
-    asio::strand<asio::io_context::executor_type> strand_;
-    bool tls_;
-    std::string id_{};
-    std::atomic_bool open_{ false };
-
-  public:
-    stream_impl(asio::io_context& ctx, bool is_tls)
-      : strand_(asio::make_strand(ctx))
-      , tls_(is_tls)
-      , id_(uuid::to_string(uuid::random()))
-    {
-    }
+protected:
+  asio::strand<asio::io_context::executor_type> strand_;
+  bool tls_;
+  std::string id_{};
+  std::atomic_bool open_{ false };
 
-    virtual ~stream_impl() = default;
+public:
+  stream_impl(asio::io_context& ctx, bool is_tls)
+    : strand_(asio::make_strand(ctx))
+    , tls_(is_tls)
+    , id_(uuid::to_string(uuid::random()))
+  {
+  }
 
-    [[nodiscard]] std::string_view log_prefix() const
-    {
-        return tls_ ? "tls" : "plain";
-    }
+  virtual ~stream_impl() = default;
 
-    [[nodiscard]] const std::string& id() const
-    {
-        return id_;
-    }
+  [[nodiscard]] auto log_prefix() const -> std::string_view
+  {
+    return tls_ ? "tls" : "plain";
+  }
 
-    [[nodiscard]] bool is_open() const
-    {
-        return open_;
-    }
+  [[nodiscard]] auto id() const -> const std::string&
+  {
+    return id_;
+  }
 
-    auto get_executor() const noexcept
-    {
-        return strand_;
-    }
+  [[nodiscard]] auto is_open() const -> bool
+  {
+    return open_;
+  }
+
+  auto get_executor() const noexcept
+  {
+    return strand_;
+  }
 
-    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const = 0;
+  [[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(std::function<void(std::error_code)>&& handler) = 0;
 
-    virtual void reopen() = 0;
+  virtual void reopen() = 0;
 
-    virtual void set_options() = 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;
+  virtual void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                             std::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,
+                           std::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,
+                               std::function<void(std::error_code, std::size_t)>&& handler) = 0;
 };
 
 class plain_stream_impl : public stream_impl
 {
-  private:
-    std::shared_ptr<asio::ip::tcp::socket> stream_;
-
-  public:
-    explicit plain_stream_impl(asio::io_context& ctx)
-      : stream_impl(ctx, false)
-      , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
-    {
+private:
+  std::shared_ptr<asio::ip::tcp::socket> stream_;
+
+public:
+  explicit plain_stream_impl(asio::io_context& ctx)
+    : stream_impl(ctx, false)
+    , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
+  {
+  }
+
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
+  {
+    std::error_code ec;
+    auto res = stream_->local_endpoint(ec);
+    if (ec) {
+      return {};
     }
-
-    [[nodiscard]] asio::ip::tcp::endpoint local_endpoint() const override
-    {
-        std::error_code ec;
-        auto res = stream_->local_endpoint(ec);
-        if (ec) {
-            return {};
-        }
-        return res;
-    }
-
-    void close(std::function<void(std::error_code)>&& handler) override
-    {
-        open_ = false;
-        return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-            asio::error_code ec{};
-            stream->shutdown(asio::socket_base::shutdown_both, ec);
-            stream->close(ec);
-            h(ec);
-        });
-    }
-
-    void reopen() override
-    {
-        return close([this](std::error_code) {
-            id_ = uuid::to_string(uuid::random());
-            stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
-        });
-    }
-
-    void set_options() override
-    {
-        if (!open_ || !stream_) {
-            return;
-        }
-        std::error_code ec{};
-        stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
-        stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
-    }
-
-    void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                       std::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();
-            h(ec);
-        });
-    }
-
-    void async_write(std::vector<asio::const_buffer>& buffers, std::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
-    {
-        return stream_->async_read_some(buffer, std::move(handler));
+    return res;
+  }
+
+  void close(std::function<void(std::error_code)>&& handler) override
+  {
+    open_ = false;
+    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
+      asio::error_code ec{};
+      stream->shutdown(asio::socket_base::shutdown_both, ec);
+      stream->close(ec);
+      h(ec);
+    });
+  }
+
+  void reopen() override
+  {
+    return close([this](std::error_code) {
+      id_ = uuid::to_string(uuid::random());
+      stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
+    });
+  }
+
+  void set_options() override
+  {
+    if (!open_ || !stream_) {
+      return;
     }
+    std::error_code ec{};
+    stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
+    stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
+  }
+
+  void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                     std::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();
+      h(ec);
+    });
+  }
+
+  void async_write(std::vector<asio::const_buffer>& buffers,
+                   std::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
+  {
+    return stream_->async_read_some(buffer, std::move(handler));
+  }
 };
 
 class tls_stream_impl : public stream_impl
 {
-  private:
-    std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
-    asio::ssl::context& tls_;
-
-  public:
-    tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
-      : stream_impl(ctx, true)
-      , stream_(std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_), tls))
-      , tls_(tls)
-    {
+private:
+  std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
+  asio::ssl::context& tls_;
+
+public:
+  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
+    : stream_impl(ctx, true)
+    , stream_(
+        std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
+                                                                   tls))
+    , tls_(tls)
+  {
+  }
+
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
+  {
+    std::error_code ec;
+    auto res = stream_->lowest_layer().local_endpoint(ec);
+    if (ec) {
+      return {};
     }
-
-    [[nodiscard]] asio::ip::tcp::endpoint local_endpoint() const override
-    {
-        std::error_code ec;
-        auto res = stream_->lowest_layer().local_endpoint(ec);
-        if (ec) {
-            return {};
-        }
-        return res;
-    }
-
-    void close(std::function<void(std::error_code)>&& handler) override
-    {
-        open_ = false;
-        return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-            asio::error_code ec{};
-            stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
-            stream->lowest_layer().close(ec);
-            h(ec);
-        });
-    }
-
-    void reopen() override
-    {
-        return close([this](std::error_code) {
-            id_ = uuid::to_string(uuid::random());
-            stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_), tls_);
-        });
+    return res;
+  }
+
+  void close(std::function<void(std::error_code)>&& handler) override
+  {
+    open_ = false;
+    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
+      asio::error_code ec{};
+      stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
+      stream->lowest_layer().close(ec);
+      h(ec);
+    });
+  }
+
+  void reopen() override
+  {
+    return close([this](std::error_code) {
+      id_ = uuid::to_string(uuid::random());
+      stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
+        asio::ip::tcp::socket(strand_), tls_);
+    });
+  }
+
+  void set_options() override
+  {
+    if (!open_ || !stream_) {
+      return;
     }
-
-    void set_options() override
-    {
-        if (!open_ || !stream_) {
-            return;
+    std::error_code ec{};
+    stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
+    stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
+  }
+
+  void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
+                     std::function<void(std::error_code)>&& handler) override
+  {
+    return stream_->lowest_layer().async_connect(
+      endpoint, [this, handler](std::error_code ec_connect) mutable {
+        if (ec_connect == asio::error::operation_aborted) {
+          return;
         }
-        std::error_code ec{};
-        stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
-        stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
-    }
-
-    void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                       std::function<void(std::error_code)>&& handler) override
-    {
-        return stream_->lowest_layer().async_connect(endpoint, [this, handler](std::error_code ec_connect) mutable {
-            if (ec_connect == asio::error::operation_aborted) {
-                return;
-            }
-            if (ec_connect) {
-                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);
-            });
-        });
-    }
-
-    void async_write(std::vector<asio::const_buffer>& buffers, std::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
-    {
-        return stream_->async_read_some(buffer, std::move(handler));
-    }
+        if (ec_connect) {
+          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);
+                                 });
+      });
+  }
+
+  void async_write(std::vector<asio::const_buffer>& buffers,
+                   std::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
+  {
+    return stream_->async_read_some(buffer, std::move(handler));
+  }
 };
 
 } // namespace couchbase::core::io

data/ext/couchbase/core/json_string.hxx

@@ -24,64 +24,64 @@
 namespace couchbase::core
 {
 struct json_string {
-    json_string() = default;
+  json_string() = default;
 
-    json_string(std::string&& value)
-      : value_(std::move(value))
-    {
-    }
+  json_string(std::string&& value)
+    : value_(std::move(value))
+  {
+  }
 
-    json_string& operator=(std::string&& value)
-    {
-        value_ = std::move(value);
-        return *this;
-    }
+  json_string& operator=(std::string&& value)
+  {
+    value_ = std::move(value);
+    return *this;
+  }
 
-    json_string(const std::vector<std::byte>& value)
-      : value_(value)
-    {
-    }
+  json_string(const std::vector<std::byte>& value)
+    : value_(value)
+  {
+  }
 
-    json_string(std::vector<std::byte>&& value)
-      : value_(std::move(value))
-    {
-    }
+  json_string(std::vector<std::byte>&& value)
+    : value_(std::move(value))
+  {
+  }
 
-    json_string& operator=(std::vector<std::byte>&& value)
-    {
-        value_ = std::move(value);
-        return *this;
-    }
+  json_string& operator=(std::vector<std::byte>&& value)
+  {
+    value_ = std::move(value);
+    return *this;
+  }
 
-    [[nodiscard]] auto is_string() const -> bool
-    {
-        return std::holds_alternative<std::string>(value_);
-    }
+  [[nodiscard]] auto is_string() const -> bool
+  {
+    return std::holds_alternative<std::string>(value_);
+  }
 
-    [[nodiscard]] auto is_binary() const -> bool
-    {
-        return std::holds_alternative<std::vector<std::byte>>(value_);
-    }
+  [[nodiscard]] auto is_binary() const -> bool
+  {
+    return std::holds_alternative<std::vector<std::byte>>(value_);
+  }
 
-    [[nodiscard]] const std::string& str() const
-    {
-        if (is_string()) {
-            return std::get<std::string>(value_);
-        }
-        static std::string empty_string{};
-        return empty_string;
+  [[nodiscard]] const std::string& str() const
+  {
+    if (is_string()) {
+      return std::get<std::string>(value_);
     }
+    static std::string empty_string{};
+    return empty_string;
+  }
 
-    [[nodiscard]] const std::vector<std::byte>& bytes() const
-    {
-        if (is_binary()) {
-            return std::get<std::vector<std::byte>>(value_);
-        }
-        static std::vector<std::byte> empty_bytes{};
-        return empty_bytes;
+  [[nodiscard]] const std::vector<std::byte>& bytes() const
+  {
+    if (is_binary()) {
+      return std::get<std::vector<std::byte>>(value_);
     }
+    static std::vector<std::byte> empty_bytes{};
+    return empty_bytes;
+  }
 
-  private:
-    std::variant<std::nullptr_t, std::string, std::vector<std::byte>> value_{ nullptr };
+private:
+  std::variant<std::nullptr_t, std::string, std::vector<std::byte>> value_{ nullptr };
 };
 } // namespace couchbase::core

data/ext/couchbase/core/key_value_config.cxx

@@ -23,13 +23,13 @@ namespace couchbase::core
 auto
 key_value_config::to_string() const -> std::string
 {
-    return fmt::format(
-      R"(#<key_value_config:{} connect_timeout={}, reconnect_wait_backoff={}, pool_size={}, max_queue_size={}, connection_buffer_size={}>)",
-      static_cast<const void*>(this),
-      connect_timeout,
-      reconnect_wait_backoff,
-      pool_size,
-      max_queue_size,
-      connection_buffer_size);
+  return fmt::format(
+    R"(#<key_value_config:{} connect_timeout={}, reconnect_wait_backoff={}, pool_size={}, max_queue_size={}, connection_buffer_size={}>)",
+    static_cast<const void*>(this),
+    connect_timeout,
+    reconnect_wait_backoff,
+    pool_size,
+    max_queue_size,
+    connection_buffer_size);
 }
 } // namespace couchbase::core

data/ext/couchbase/core/key_value_config.hxx

@@ -23,18 +23,19 @@
 namespace couchbase::core
 {
 struct key_value_config {
-    static constexpr std::chrono::milliseconds default_connect_timeout{ std::chrono::seconds{ 7 } };
-    static constexpr std::chrono::milliseconds default_reconnect_wait_backoff{ std::chrono::seconds{ 5 } };
-    static constexpr std::size_t default_pool_size{ 1 };
-    static constexpr std::size_t default_max_queue_size{ 2048 };
-    static constexpr std::size_t default_connection_buffer_size{ 0 };
+  static constexpr std::chrono::milliseconds default_connect_timeout{ std::chrono::seconds{ 7 } };
+  static constexpr std::chrono::milliseconds default_reconnect_wait_backoff{ std::chrono::seconds{
+    5 } };
+  static constexpr std::size_t default_pool_size{ 1 };
+  static constexpr std::size_t default_max_queue_size{ 2048 };
+  static constexpr std::size_t default_connection_buffer_size{ 0 };
 
-    std::chrono::milliseconds connect_timeout{ default_connect_timeout };
-    std::chrono::milliseconds reconnect_wait_backoff{ default_reconnect_wait_backoff };
-    std::size_t pool_size{ default_pool_size };
-    std::size_t max_queue_size{ default_max_queue_size };
-    std::size_t connection_buffer_size{ default_connection_buffer_size };
+  std::chrono::milliseconds connect_timeout{ default_connect_timeout };
+  std::chrono::milliseconds reconnect_wait_backoff{ default_reconnect_wait_backoff };
+  std::size_t pool_size{ default_pool_size };
+  std::size_t max_queue_size{ default_max_queue_size };
+  std::size_t connection_buffer_size{ default_connection_buffer_size };
 
-    [[nodiscard]] auto to_string() const -> std::string;
+  [[nodiscard]] auto to_string() const -> std::string;
 };
 } // namespace couchbase::core