couchbase 3.5.1 → 3.5.2

data/ext/couchbase/couchbase/increment_options.hxx

@@ -19,8 +19,8 @@
 
 #include <couchbase/common_durability_options.hxx>
 #include <couchbase/counter_result.hxx>
+#include <couchbase/error.hxx>
 #include <couchbase/expiry.hxx>
-#include <couchbase/key_value_error_context.hxx>
 
 #include <chrono>
 #include <functional>
@@ -36,101 +36,104 @@ namespace couchbase
  * @committed
  */
 struct increment_options : public common_durability_options<increment_options> {
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    struct built : public common_durability_options<increment_options>::built {
-        const std::uint32_t expiry;
-        const std::uint64_t delta;
-        const std::optional<std::uint64_t> initial_value;
-    };
+  /**
+   * Immutable value object representing consistent options.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  struct built : public common_durability_options<increment_options>::built {
+    const std::uint32_t expiry;
+    const std::uint64_t delta;
+    const std::optional<std::uint64_t> initial_value;
+  };
 
-    /**
-     * Validates options and returns them as an immutable value.
-     *
-     * @return consistent options as an immutable value
-     *
-     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto build() const -> built
-    {
-        auto base = build_common_durability_options();
-        return { base, expiry_, delta_, initial_value_ };
-    }
+  /**
+   * Validates options and returns them as an immutable value.
+   *
+   * @return consistent options as an immutable value
+   *
+   * @exception std::system_error with code errc::common::invalid_argument if the options are not
+   * valid
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto build() const -> built
+  {
+    auto base = build_common_durability_options();
+    return { base, expiry_, delta_, initial_value_ };
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * The duration must be less than 50 years. For expiry further in the future, use
-     * {@link #expiry(std::chrono::system_clock::time_point)}.
-     *
-     * @param duration the duration after which the document will expire (zero duration means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::seconds duration) -> increment_options&
-    {
-        expiry_ = core::impl::expiry_relative(duration);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * The duration must be less than 50 years. For expiry further in the future, use
+   * {@link #expiry(std::chrono::system_clock::time_point)}.
+   *
+   * @param duration the duration after which the document will expire (zero duration means never
+   * expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::seconds duration) -> increment_options&
+  {
+    expiry_ = core::impl::expiry_relative(duration);
+    return self();
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * @param time_point the point in time when the document will expire (epoch second zero means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::system_clock::time_point time_point) -> increment_options&
-    {
-        expiry_ = core::impl::expiry_absolute(time_point);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * @param time_point the point in time when the document will expire (epoch second zero means
+   * never expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::system_clock::time_point time_point) -> increment_options&
+  {
+    expiry_ = core::impl::expiry_absolute(time_point);
+    return self();
+  }
 
-    /**
-     * The amount of which the document value should be incremented.
-     *
-     * @param delta the amount to increment.
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto delta(std::uint64_t delta) -> increment_options&
-    {
-        delta_ = delta;
-        return self();
-    }
+  /**
+   * The amount of which the document value should be incremented.
+   *
+   * @param delta the amount to increment.
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto delta(std::uint64_t delta) -> increment_options&
+  {
+    delta_ = delta;
+    return self();
+  }
 
-    /**
-     * The initial value that should be used if the document has not been created yet.
-     *
-     * @param value the initial value to use.
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto initial(std::uint64_t value) -> increment_options&
-    {
-        initial_value_ = value;
-        return self();
-    }
+  /**
+   * The initial value that should be used if the document has not been created yet.
+   *
+   * @param value the initial value to use.
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto initial(std::uint64_t value) -> increment_options&
+  {
+    initial_value_ = value;
+    return self();
+  }
 
-  private:
-    std::uint32_t expiry_{ 0 };
-    std::uint64_t delta_{ 1 };
-    std::optional<std::uint64_t> initial_value_{};
+private:
+  std::uint32_t expiry_{ 0 };
+  std::uint64_t delta_{ 1 };
+  std::optional<std::uint64_t> initial_value_{};
 };
 
 /**
@@ -139,5 +142,5 @@ struct increment_options : public common_durability_options<increment_options> {
  * @since 1.0.0
  * @uncommitted
  */
-using increment_handler = std::function<void(couchbase::key_value_error_context, counter_result)>;
+using increment_handler = std::function<void(error, counter_result)>;
 } // namespace couchbase

data/ext/couchbase/couchbase/insert_options.hxx

@@ -19,8 +19,8 @@
 
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/common_durability_options.hxx>
+#include <couchbase/error.hxx>
 #include <couchbase/expiry.hxx>
-#include <couchbase/key_value_error_context.hxx>
 #include <couchbase/mutation_result.hxx>
 
 #include <chrono>
@@ -39,67 +39,70 @@ namespace couchbase
  * @committed
  */
 struct insert_options : public common_durability_options<insert_options> {
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    struct built : public common_durability_options<insert_options>::built {
-        const std::uint32_t expiry;
-    };
+  /**
+   * Immutable value object representing consistent options.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  struct built : public common_durability_options<insert_options>::built {
+    const std::uint32_t expiry;
+  };
 
-    /**
-     * Validates options and returns them as an immutable value.
-     *
-     * @return consistent options as an immutable value
-     *
-     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto build() const -> built
-    {
-        auto base = build_common_durability_options();
-        return { base, expiry_ };
-    }
+  /**
+   * Validates options and returns them as an immutable value.
+   *
+   * @return consistent options as an immutable value
+   *
+   * @exception std::system_error with code errc::common::invalid_argument if the options are not
+   * valid
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto build() const -> built
+  {
+    auto base = build_common_durability_options();
+    return { base, expiry_ };
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * The duration must be less than 50 years. For expiry further in the future, use
-     * {@link #expiry(std::chrono::system_clock::time_point)}.
-     *
-     * @param duration the duration after which the document will expire (zero duration means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::seconds duration) -> insert_options&
-    {
-        expiry_ = core::impl::expiry_relative(duration);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * The duration must be less than 50 years. For expiry further in the future, use
+   * {@link #expiry(std::chrono::system_clock::time_point)}.
+   *
+   * @param duration the duration after which the document will expire (zero duration means never
+   * expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::seconds duration) -> insert_options&
+  {
+    expiry_ = core::impl::expiry_relative(duration);
+    return self();
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * @param time_point the point in time when the document will expire (epoch second zero means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::system_clock::time_point time_point) -> insert_options&
-    {
-        expiry_ = core::impl::expiry_absolute(time_point);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * @param time_point the point in time when the document will expire (epoch second zero means
+   * never expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::system_clock::time_point time_point) -> insert_options&
+  {
+    expiry_ = core::impl::expiry_absolute(time_point);
+    return self();
+  }
 
-  private:
-    std::uint32_t expiry_{ 0 };
+private:
+  std::uint32_t expiry_{ 0 };
 };
 
 /**
@@ -108,5 +111,5 @@ struct insert_options : public common_durability_options<insert_options> {
  * @since 1.0.0
  * @uncommitted
  */
-using insert_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
+using insert_handler = std::function<void(error, mutation_result)>;
 } // namespace couchbase

data/ext/couchbase/couchbase/ip_protocol.hxx

@@ -20,8 +20,8 @@
 namespace couchbase
 {
 enum class ip_protocol {
-    any,
-    force_ipv4,
-    force_ipv6,
+  any,
+  force_ipv4,
+  force_ipv6,
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/logger.hxx

@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace couchbase::logger
+{
+enum class log_level {
+  trace,
+  debug,
+  info,
+  warn,
+  error,
+  critical,
+  off,
+};
+
+void
+set_level(log_level level);
+
+void
+initialize_console_logger();
+
+void
+initialize_file_logger(std::string_view filename);
+
+void
+initialize_protocol_logger(std::string_view filename);
+
+void
+flush_all_loggers();
+
+void
+shutdown_all_loggers();
+} // namespace couchbase::logger

data/ext/couchbase/couchbase/lookup_in_all_replicas_options.hxx

@@ -19,18 +19,15 @@
 
 #include <couchbase/subdoc/fwd/command_bundle.hxx>
 
-#include <core/impl/subdoc/command.hxx>
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/common_options.hxx>
+#include <couchbase/error.hxx>
 #include <couchbase/expiry.hxx>
 #include <couchbase/lookup_in_replica_result.hxx>
+#include <couchbase/read_preference.hxx>
 #include <couchbase/store_semantics.hxx>
-#include <couchbase/subdocument_error_context.hxx>
 
-#include <chrono>
 #include <functional>
-#include <memory>
-#include <optional>
 #include <vector>
 
 namespace couchbase
@@ -42,29 +39,54 @@ namespace couchbase
  * @committed
  */
 struct lookup_in_all_replicas_options : common_options<lookup_in_all_replicas_options> {
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    struct built : public common_options<lookup_in_all_replicas_options>::built {
+  /**
+   * Immutable value object representing consistent options.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  struct built : public common_options<lookup_in_all_replicas_options>::built {
+    couchbase::read_preference read_preference;
+  };
+
+  /**
+   * Choose how the replica nodes will be selected. By default it has no
+   * preference and will select any available replica, but it is possible to
+   * prioritize or restrict to only nodes in local server group.
+   *
+   * @param preference
+   * @return this options builder for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto read_preference(read_preference preference) -> lookup_in_all_replicas_options&
+  {
+    read_preference_ = preference;
+    return self();
+  }
+
+  /**
+   * Validates options and returns them as an immutable value.
+   *
+   * @return consistent options as an immutable value
+   *
+   * @exception std::system_error with code errc::common::invalid_argument if the options are not
+   * valid
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto build() const -> built
+  {
+    return {
+      build_common_options(),
+      read_preference_,
     };
+  }
 
-    /**
-     * Validates options and returns them as an immutable value.
-     *
-     * @return consistent options as an immutable value
-     *
-     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto build() const -> built
-    {
-        return { build_common_options() };
-    }
+private:
+  couchbase::read_preference read_preference_{ read_preference::no_preference };
 };
 
 /**
@@ -81,29 +103,18 @@ using lookup_in_all_replicas_result = std::vector<lookup_in_replica_result>;
  * @since 1.0.0
  * @uncommitted
  */
-using lookup_in_all_replicas_handler = std::function<void(couchbase::subdocument_error_context, lookup_in_all_replicas_result)>;
+using lookup_in_all_replicas_handler = std::function<void(error, lookup_in_all_replicas_result)>;
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
 namespace core
 {
 class cluster;
-namespace impl
-{
 
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_lookup_in_all_replicas_operation(std::shared_ptr<couchbase::core::cluster> core,
-                                          const std::string& bucket_name,
-                                          const std::string& scope_name,
-                                          const std::string& collection_name,
-                                          std::string document_key,
-                                          const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                                          lookup_in_all_replicas_options::built options,
-                                          lookup_in_all_replicas_handler&& handler);
+namespace impl::subdoc
+{
+struct command;
+} // namespace impl::subdoc
 #endif
-} // namespace impl
+
 } // namespace core
 } // namespace couchbase