couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/get_result.hxx

@@ -0,0 +1,126 @@
+/* -*- 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 <couchbase/codec/json_transcoder.hxx>
+#include <couchbase/result.hxx>
+
+#include <chrono>
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Represents result of @ref collection#get
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class get_result : public result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    get_result() = default;
+
+    /**
+     * Constructs result for get operation
+     *
+     * @param cas
+     * @param value raw document contents along with flags describing its structure
+     * @param expiry_time optional point in time when the document will expire
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    get_result(couchbase::cas cas, codec::encoded_value value, std::optional<std::chrono::system_clock::time_point> expiry_time)
+      : result{ cas }
+      , value_{ std::move(value) }
+      , expiry_time_{ expiry_time }
+    {
+    }
+
+    /**
+     * Decodes content of the document using given codec.
+     *
+     * @tparam Document custom type that `Transcoder` returns
+     * @tparam Transcoder type that has static function `decode` that takes codec::encoded_value and returns `Document`
+     * @return decoded document content
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Document,
+             typename Transcoder = codec::json_transcoder,
+             std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
+             std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+    [[nodiscard]] auto content_as() const -> Document
+    {
+        return Transcoder::template decode<Document>(value_);
+    }
+
+    /**
+     * Decodes content of the document using given codec.
+     *
+     * @tparam Transcoder type that has static function `decode` that takes codec::encoded_value and returns `Transcoder::value_type`
+     * @return decoded document content
+     *
+     * @par Get flags and value as they are stored in the result
+     *  Here is an example of custom transcoder, that just extracts value and flags as they are stored in the result.
+     * @snippet test_integration_read_replica.cxx smuggling-transcoder
+     *  Usage
+     * @snippet test_integration_read_replica.cxx smuggling-transcoder-usage
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+    [[nodiscard]] auto content_as() const -> typename Transcoder::document_type
+    {
+        return Transcoder::decode(value_);
+    }
+
+    /**
+     * If the document has an expiry, returns the point in time when the loaded
+     * document expires.
+     *
+     * @note This method always returns an empty `std::optional` unless
+     * the {@link collection#get()} request was made using {@link get_options#with_expiry()}
+     * set to true.
+     *
+     * @return expiry time if present
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto expiry_time() const -> const std::optional<std::chrono::system_clock::time_point>&
+    {
+        return expiry_time_;
+    }
+
+  private:
+    codec::encoded_value value_{};
+    std::optional<std::chrono::system_clock::time_point> expiry_time_{};
+};
+
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/increment_options.hxx

@@ -0,0 +1,165 @@
+/* -*- 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 <couchbase/common_durability_options.hxx>
+#include <couchbase/counter_result.hxx>
+#include <couchbase/expiry.hxx>
+#include <couchbase/key_value_error_context.hxx>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <optional>
+
+namespace couchbase
+{
+/**
+ * Options for binary_collection#increment().
+ *
+ * @since 1.0.0
+ * @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;
+    };
+
+    /**
+     * 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_durability_options(), 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.
+     *
+     * @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 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_{};
+};
+
+/**
+ * The signature for the handler of the @ref binary_collection#increment() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using increment_handler = std::function<void(couchbase::key_value_error_context, counter_result)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_increment_operation(std::shared_ptr<couchbase::core::cluster> core,
+                             std::string bucket_name,
+                             std::string scope_name,
+                             std::string collection_name,
+                             std::string document_key,
+                             increment_options::built options,
+                             increment_handler&& handler);
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/insert_options.hxx

@@ -0,0 +1,135 @@
+/* -*- 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 <couchbase/codec/encoded_value.hxx>
+#include <couchbase/common_durability_options.hxx>
+#include <couchbase/expiry.hxx>
+#include <couchbase/key_value_error_context.hxx>
+#include <couchbase/mutation_result.hxx>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Options for @ref collection#insert().
+ *
+ * @since 1.0.0
+ * @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;
+    };
+
+    /**
+     * 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_durability_options(), 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.
+     *
+     * @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 };
+};
+
+/**
+ * The signature for the handler of the @ref collection#insert() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using insert_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_insert_operation(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string scope_name,
+                          std::string collection_name,
+                          std::string document_key,
+                          codec::encoded_value encoded,
+                          insert_options::built options,
+                          insert_handler&& handler);
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/key_value_error_context.hxx

@@ -0,0 +1,224 @@
+/* -*- 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 <couchbase/cas.hxx>
+#include <couchbase/error_context.hxx>
+#include <couchbase/key_value_error_map_info.hxx>
+#include <couchbase/key_value_extended_error_info.hxx>
+#include <couchbase/key_value_status_code.hxx>
+
+#include <cstdint>
+#include <optional>
+
+namespace couchbase
+{
+/**
+ * The error context returned with key/value operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class key_value_error_context : public error_context
+{
+  public:
+    /**
+     * Creates empty error context
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    key_value_error_context() = default;
+
+    /**
+     * Creates and initializes error context with given parameters.
+     *
+     * @param ec
+     * @param last_dispatched_to
+     * @param last_dispatched_from
+     * @param retry_attempts
+     * @param retry_reasons
+     * @param id
+     * @param bucket
+     * @param scope
+     * @param collection
+     * @param opaque
+     * @param status_code
+     * @param cas
+     * @param error_map_info
+     * @param extended_error_info
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    key_value_error_context(std::error_code ec,
+                            std::optional<std::string> last_dispatched_to,
+                            std::optional<std::string> last_dispatched_from,
+                            int retry_attempts,
+                            std::set<retry_reason> retry_reasons,
+                            std::string id,
+                            std::string bucket,
+                            std::string scope,
+                            std::string collection,
+                            std::uint32_t opaque,
+                            std::optional<key_value_status_code> status_code,
+                            couchbase::cas cas,
+                            std::optional<key_value_error_map_info> error_map_info,
+                            std::optional<key_value_extended_error_info> extended_error_info)
+      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      , id_{ std::move(id) }
+      , bucket_{ std::move(bucket) }
+      , scope_{ std::move(scope) }
+      , collection_{ std::move(collection) }
+      , opaque_{ opaque }
+      , status_code_{ status_code }
+      , cas_{ cas }
+      , error_map_info_{ std::move(error_map_info) }
+      , extended_error_info_{ std::move(extended_error_info) }
+    {
+    }
+
+    /**
+     * Returns identifier (key) of the document referenced in the operation.
+     *
+     * @return document identifier
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> const std::string&
+    {
+        return id_;
+    }
+
+    /**
+     * Returns name of the bucket.
+     *
+     * @return name of the bucket.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto bucket() const -> const std::string&
+    {
+        return bucket_;
+    }
+
+    /**
+     * Returns name of the scope of the document.
+     *
+     * @return name of the scope.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto scope() const -> const std::string&
+    {
+        return scope_;
+    }
+
+    /**
+     * Returns name of the collection of the document.
+     *
+     * @return collection name
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto collection() const -> const std::string&
+    {
+        return collection_;
+    }
+
+    /**
+     * Returns opaque number generated by the SDK and repeated by the server.
+     *
+     * @return opaque number
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto opaque() const -> std::uint32_t
+    {
+        return opaque_;
+    }
+
+    /**
+     * Returns status code from the server response.
+     *
+     * @return protocol status code
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto status_code() const -> const std::optional<key_value_status_code>&
+    {
+        return status_code_;
+    }
+
+    /**
+     * Returns CAS value associated with the document on the server.
+     *
+     * @return CAS value
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    [[nodiscard]] auto cas() const -> couchbase::cas
+    {
+        return cas_;
+    }
+
+    /**
+     * Returns entry from error map, if it was mapped.
+     *
+     * @return optional error map info
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto error_map_info() const -> const std::optional<key_value_error_map_info>&
+    {
+        return error_map_info_;
+    }
+
+    /**
+     * Returns extended error info (if it was rendered in the server response).
+     *
+     * @return optional error info
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto extended_error_info() const -> const std::optional<key_value_extended_error_info>&
+    {
+        return extended_error_info_;
+    }
+
+  private:
+    std::string id_{};
+    std::string bucket_{};
+    std::string scope_{};
+    std::string collection_{};
+    std::uint32_t opaque_{};
+    std::optional<key_value_status_code> status_code_{};
+    couchbase::cas cas_{};
+    std::optional<key_value_error_map_info> error_map_info_{};
+    std::optional<key_value_extended_error_info> extended_error_info_{};
+};
+} // namespace couchbase