couchbase 4.2.6 → 4.2.7

package/deps/couchbase-cxx-client/couchbase/lookup_in_replica_result.hxx

@@ -0,0 +1,74 @@
+/* -*- 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/lookup_in_result.hxx>
+
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Represents result of lookup_in_replica operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class lookup_in_replica_result : public lookup_in_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    lookup_in_replica_result() = default;
+
+    /**
+     * Constructs result for lookup_in_replica operation
+     *
+     * @param cas
+     * @param entries list of the fields returned by the server
+     * @param is_deleted
+     * @param is_replica true if document originates from replica node
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    lookup_in_replica_result(couchbase::cas cas, std::vector<entry> entries, bool is_deleted, bool is_replica)
+      : lookup_in_result{ cas, std::move(entries), is_deleted }
+      , is_replica_{ is_replica }
+    {
+    }
+
+    /**
+     * Returns whether this document originates from a replica node
+     *
+     * @return whether document originates from a replica node
+     *
+     * @since 1.0.0
+     */
+    [[nodiscard]] auto is_replica() const -> bool
+    {
+        return is_replica_;
+    }
+
+  private:
+    bool is_replica_{ false };
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/lookup_in_result.hxx

@@ -44,6 +44,7 @@ class lookup_in_result : public result
         codec::binary value;
         std::size_t original_index;
         bool exists;
+        std::error_code ec;
     };
 
     /**
@@ -84,6 +85,11 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.original_index == index) {
+                if (e.ec) {
+                    throw std::system_error(
+                      e.ec, "error getting result for spec at index " + std::to_string(index) + ", path \"" + e.path + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -105,6 +111,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.path == path) {
+                if (e.ec) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -127,6 +137,10 @@ class lookup_in_result : public result
         const auto& macro_string = subdoc::to_string(macro);
         for (const entry& e : entries_) {
             if (e.path == macro_string) {
+                if (e.ec) {
+                    throw std::system_error(e.ec, "error getting result for macro \"" + macro_string + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -147,6 +161,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.original_index == index) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return e.exists;
             }
         }
@@ -167,6 +185,10 @@ class lookup_in_result : public result
         const auto& macro_string = subdoc::to_string(macro);
         for (const entry& e : entries_) {
             if (e.path == macro_string) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for macro \"" + macro_string + "\"");
+                }
+
                 return e.exists;
             }
         }
@@ -186,6 +208,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.path == path) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return e.exists;
             }
         }

package/deps/couchbase-cxx-client/couchbase/mutate_in_options.hxx

@@ -225,8 +225,8 @@ initiate_mutate_in_operation(std::shared_ptr<couchbase::core::cluster> core,
                              std::string collection_name,
                              std::string document_key,
                              const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             mutate_in_options::built options,
-                             mutate_in_handler&& handler);
+                             couchbase::mutate_in_options::built options,
+                             couchbase::mutate_in_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

package/deps/couchbase-cxx-client/couchbase/remove_options.hxx

@@ -115,8 +115,8 @@ initiate_remove_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          remove_options::built options,
-                          remove_handler&& handler);
+                          couchbase::remove_options::built options,
+                          couchbase::remove_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

package/deps/couchbase-cxx-client/couchbase/replace_options.hxx

@@ -175,9 +175,9 @@ initiate_replace_operation(std::shared_ptr<couchbase::core::cluster> core,
                            std::string scope_name,
                            std::string collection_name,
                            std::string document_key,
-                           codec::encoded_value encoded,
-                           replace_options::built options,
-                           replace_handler&& handler);
+                           couchbase::codec::encoded_value encoded,
+                           couchbase::replace_options::built options,
+                           couchbase::replace_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

package/deps/couchbase-cxx-client/couchbase/touch_options.hxx

@@ -86,8 +86,8 @@ initiate_touch_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string collection_name,
                          std::string document_key,
                          std::uint32_t expiry,
-                         touch_options::built options,
-                         touch_handler&& handler);
+                         couchbase::touch_options::built options,
+                         couchbase::touch_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

package/deps/couchbase-cxx-client/couchbase/unlock_options.hxx

@@ -89,8 +89,8 @@ initiate_unlock_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string collection_name,
                           std::string document_key,
                           couchbase::cas cas,
-                          unlock_options::built options,
-                          unlock_handler&& handler);
+                          couchbase::unlock_options::built options,
+                          couchbase::unlock_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

package/deps/couchbase-cxx-client/couchbase/upsert_options.hxx

@@ -149,9 +149,9 @@ initiate_upsert_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          codec::encoded_value encoded,
-                          upsert_options::built options,
-                          upsert_handler&& handler);
+                          couchbase::codec::encoded_value encoded,
+                          couchbase::upsert_options::built options,
+                          couchbase::upsert_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core