couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/include/tao/json/events/set_value.hpp

@@ -0,0 +1,142 @@
+// Copyright (c) 2016-2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_EVENTS_SET_VALUE_HPP
+#define TAO_JSON_EVENTS_SET_VALUE_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "../binary_view.hpp"
+#include "../forward.hpp"
+#include "../type.hpp"
+
+namespace tao::json::events
+{
+   // Events consumer to build a JSON Value.
+
+   template< template< typename... > class Traits >
+   struct set_basic_value
+   {
+      std::vector< basic_value< Traits > > stack_;
+      std::vector< std::string > keys_;
+      basic_value< Traits >& value_;
+
+      set_basic_value( basic_value< Traits >& v ) noexcept
+         : value_( v )
+      {}
+
+      void null() noexcept
+      {
+         value_.set_null();
+      }
+
+      void boolean( const bool v ) noexcept
+      {
+         value_.set_boolean( v );
+      }
+
+      void number( const std::int64_t v ) noexcept
+      {
+         value_.set_signed( v );
+      }
+
+      void number( const std::uint64_t v ) noexcept
+      {
+         value_.set_unsigned( v );
+      }
+
+      void number( const double v ) noexcept
+      {
+         value_.set_double( v );
+      }
+
+      void string( const std::string_view v )
+      {
+         value_.emplace_string( v );
+      }
+
+      void string( const char* v )
+      {
+         value_.emplace_string( v );
+      }
+
+      void string( std::string&& v )
+      {
+         value_.emplace_string( std::move( v ) );
+      }
+
+      void binary( const tao::binary_view v )
+      {
+         value_.emplace_binary( v.begin(), v.end() );
+      }
+
+      void binary( std::vector< std::byte >&& v )
+      {
+         value_.emplace_binary( std::move( v ) );
+      }
+
+      void begin_array()
+      {
+         stack_.emplace_back( empty_array );
+      }
+
+      void begin_array( const std::size_t size )
+      {
+         begin_array();
+         stack_.back().get_array().reserve( size );
+      }
+
+      void element()
+      {
+         stack_.back().emplace_back( std::move( value_ ) );
+      }
+
+      void end_array( const std::size_t /*unused*/ = 0 )
+      {
+         value_ = std::move( stack_.back() );
+         stack_.pop_back();
+      }
+
+      void begin_object( const std::size_t /*unused*/ = 0 )
+      {
+         stack_.emplace_back( empty_object );
+      }
+
+      void key( const std::string_view v )
+      {
+         keys_.emplace_back( v );
+      }
+
+      void key( const char* v )
+      {
+         keys_.emplace_back( v );
+      }
+
+      void key( std::string&& v )
+      {
+         keys_.emplace_back( std::move( v ) );
+      }
+
+      void member()
+      {
+         stack_.back().try_emplace( std::move( keys_.back() ), std::move( value_ ) );
+         keys_.pop_back();
+      }
+
+      void end_object( const std::size_t /*unused*/ = 0 )
+      {
+         value_ = std::move( stack_.back() );
+         stack_.pop_back();
+      }
+   };
+
+   using set_value = set_basic_value< traits >;
+
+}  // namespace tao::json::events
+
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/include/tao/json/events/to_value.hpp

@@ -4,14 +4,8 @@
 #ifndef TAO_JSON_EVENTS_TO_VALUE_HPP
 #define TAO_JSON_EVENTS_TO_VALUE_HPP
 
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
+#include "set_value.hpp"
 
-#include "../binary_view.hpp"
 #include "../value.hpp"
 
 namespace tao::json::events
@@ -20,114 +14,13 @@ namespace tao::json::events
 
    template< template< typename... > class Traits >
    struct to_basic_value
+      : set_basic_value< Traits >
    {
-      std::vector< basic_value< Traits > > stack_;
-      std::vector< std::string > keys_;
       basic_value< Traits > value;
 
-      void null()
-      {
-         value.set_null();
-      }
-
-      void boolean( const bool v )
-      {
-         value.set_boolean( v );
-      }
-
-      void number( const std::int64_t v )
-      {
-         value.set_signed( v );
-      }
-
-      void number( const std::uint64_t v )
-      {
-         value.set_unsigned( v );
-      }
-
-      void number( const double v )
-      {
-         value.set_double( v );
-      }
-
-      void string( const std::string_view v )
-      {
-         value.emplace_string( v );
-      }
-
-      void string( const char* v )
-      {
-         value.emplace_string( v );
-      }
-
-      void string( std::string&& v )
-      {
-         value.emplace_string( std::move( v ) );
-      }
-
-      void binary( const tao::binary_view v )
-      {
-         value.emplace_binary( v.begin(), v.end() );
-      }
-
-      void binary( std::vector< std::byte >&& v )
-      {
-         value.emplace_binary( std::move( v ) );
-      }
-
-      void begin_array()
-      {
-         stack_.emplace_back( empty_array );
-      }
-
-      void begin_array( const std::size_t size )
-      {
-         begin_array();
-         stack_.back().get_array().reserve( size );
-      }
-
-      void element()
-      {
-         stack_.back().emplace_back( std::move( value ) );
-      }
-
-      void end_array( const std::size_t /*unused*/ = 0 )
-      {
-         value = std::move( stack_.back() );
-         stack_.pop_back();
-      }
-
-      void begin_object( const std::size_t /*unused*/ = 0 )
-      {
-         stack_.emplace_back( empty_object );
-      }
-
-      void key( const std::string_view v )
-      {
-         keys_.emplace_back( v );
-      }
-
-      void key( const char* v )
-      {
-         keys_.emplace_back( v );
-      }
-
-      void key( std::string&& v )
-      {
-         keys_.emplace_back( std::move( v ) );
-      }
-
-      void member()
-      {
-         stack_.back().try_emplace( std::move( keys_.back() ), std::move( value ) );
-         keys_.pop_back();
-      }
-
-      void end_object( const std::size_t /*unused*/ = 0 )
-      {
-         value = std::move( stack_.back() );
-         stack_.pop_back();
-      }
+      to_basic_value() noexcept
+         : set_basic_value< Traits >( value )
+      {}
    };
 
    using to_value = to_basic_value< traits >;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/include/tao/json/events/virtualize.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_EVENTS_VIRTUALIZE_HPP
+#define TAO_JSON_EVENTS_VIRTUALIZE_HPP
+
+#include <type_traits>
+
+#include "virtual_base.hpp"
+#include "virtual_ref.hpp"
+
+namespace tao::json::events
+{
+   template< typename Consumer >
+   [[nodiscard]] decltype( auto ) virtualize( Consumer& c ) noexcept
+   {
+      if constexpr( std::is_base_of_v< virtual_base, Consumer > ) {
+         return c;
+      }
+      else {
+         return events::virtual_ref( c );
+      }
+   }
+
+}  // namespace tao::json::events
+
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/include/tao/json/events.hpp

@@ -5,6 +5,7 @@
 #define TAO_JSON_EVENTS_HPP
 
 // Events producers
+#include "events/capture.hpp"
 #include "events/from_file.hpp"
 #include "events/from_input.hpp"
 #include "events/from_stream.hpp"
@@ -13,6 +14,7 @@
 #include "events/produce.hpp"
 
 // Events consumers
+#include "events/set_value.hpp"
 #include "events/to_pretty_stream.hpp"
 #include "events/to_stream.hpp"
 #include "events/to_string.hpp"
@@ -40,6 +42,7 @@
 #include "events/virtual_base.hpp"
 #include "events/virtual_ref.hpp"
 #include "events/virtual_wrap.hpp"
+#include "events/virtualize.hpp"
 
 // Events other
 #include "events/debug.hpp"

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/include/tao/json/traits.hpp

@@ -826,7 +826,7 @@ namespace tao::json
    {
       static void assign( basic_value< Traits >& v, const std::map< std::string, basic_value< Traits >, std::less<> >& o )
       {
-         v.set_object( std::move( o ) );
+         v.set_object( o );
       }
 
       static void assign( basic_value< Traits >& v, std::map< std::string, basic_value< Traits >, std::less<> >&& o ) noexcept

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/src/test/json/opaque_pointer.cpp

@@ -3,6 +3,7 @@
 
 #include "test.hpp"
 
+#include <tao/json/events/capture.hpp>
 #include <tao/json/events/produce.hpp>
 #include <tao/json/from_string.hpp>
 #include <tao/json/produce.hpp>
@@ -13,101 +14,6 @@
 
 namespace tao::json
 {
-   namespace events
-   {
-      template< template< typename... > class Traits, typename Consumer >
-      struct array_t
-      {
-         Consumer* c_;
-
-         explicit array_t( Consumer& c ) noexcept( noexcept( c_->begin_array() ) )
-            : c_( &c )
-         {
-            c_->begin_array();
-         }
-
-         array_t( const array_t& ) = delete;
-
-         array_t( array_t&& r ) noexcept
-            : c_( r.c_ )
-         {
-            r.c_ = nullptr;
-         }
-
-         ~array_t()
-         {
-            if( c_ ) {
-               c_->end_array();
-            }
-         }
-
-         void operator=( const array_t& ) = delete;
-         void operator=( array_t&& ) = delete;
-
-         template< typename T >
-         array_t& push_back( T&& v )
-         {
-            assert( c_ );
-            produce< Traits >( *c_, std::forward< T >( v ) );
-            c_->element();
-            return *this;
-         }
-      };
-
-      template< template< typename... > class Traits, typename Consumer >
-      struct object_t
-      {
-         Consumer* c_;
-
-         explicit object_t( Consumer& c ) noexcept( noexcept( c_->begin_object() ) )
-            : c_( &c )
-         {
-            c_->begin_object();
-         }
-
-         object_t( const object_t& ) = delete;
-
-         object_t( object_t&& r ) noexcept
-            : c_( r.c_ )
-         {
-            r.c_ = nullptr;
-         }
-
-         ~object_t()
-         {
-            if( c_ ) {
-               c_->end_object();
-            }
-         }
-
-         void operator=( const object_t& ) = delete;
-         void operator=( object_t&& ) = delete;
-
-         template< typename T >
-         object_t& insert( const std::string& k, T&& v )
-         {
-            assert( c_ );
-            c_->key( k );
-            produce< Traits >( *c_, std::forward< T >( v ) );
-            c_->member();
-            return *this;
-         }
-      };
-
-      template< template< typename... > class Traits, typename Consumer >
-      [[nodiscard]] array_t< Traits, Consumer > array_consumer( Consumer& c ) noexcept( noexcept( array_t< Traits, Consumer >( c ) ) )
-      {
-         return array_t< Traits, Consumer >( c );
-      }
-
-      template< template< typename... > class Traits, typename Consumer >
-      [[nodiscard]] object_t< Traits, Consumer > object_consumer( Consumer& c ) noexcept( noexcept( object_t< Traits, Consumer >( c ) ) )
-      {
-         return object_t< Traits, Consumer >( c );
-      }
-
-   }  // namespace events
-
    struct point
    {
       double x = 1.0;
@@ -120,7 +26,7 @@ namespace tao::json
       template< template< typename... > class Traits, typename Consumer >
       static void produce( Consumer& consumer, const point& data )
       {
-         auto a = events::array_consumer< Traits >( consumer );
+         auto a = events::array< Traits >( consumer );
          a.push_back( data.x );
          a.push_back( data.y );
       }
@@ -140,7 +46,7 @@ namespace tao::json
       template< template< typename... > class Traits, typename Consumer >
       static void produce( Consumer& consumer, const employee& data )
       {
-         auto o = events::object_consumer< Traits >( consumer );
+         auto o = events::object< Traits >( consumer );
          o.insert( "name", data.name );
          if( !data.position.empty() ) {
             o.insert( "position", data.position );

package/deps/couchbase-transactions-cxx/examples/game_server.cxx

@@ -248,7 +248,7 @@ main(int, const char*[])
         couchbase::operations::upsert_request req{ player_id };
         nlohmann::json j;
         to_json(j, player_data);
-        req.value = j.dump();
+        req.value = couchbase::utils::to_binary(j.dump());
         auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
         cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp); });
         auto f = barrier->get_future();
@@ -260,7 +260,7 @@ main(int, const char*[])
         couchbase::operations::upsert_request req{ monster_id };
         nlohmann::json j;
         to_json(j, monster_data);
-        req.value = j.dump();
+        req.value = couchbase::utils::to_binary(j.dump());
         auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
         auto f = barrier->get_future();
         cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp); });

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/per_transaction_config.hxx

@@ -72,6 +72,18 @@ class per_transaction_config
     {
         return expiration_time_;
     }
+
+    per_transaction_config& custom_metadata_collection(const transaction_keyspace& keyspace)
+    {
+        custom_metadata_collection_.emplace(keyspace);
+        return *this;
+    }
+
+    std::optional<transaction_keyspace> custom_metadata_collection()
+    {
+        return custom_metadata_collection_;
+    }
+
     transaction_config apply(const transaction_config& conf) const
     {
         transaction_config retval = conf;
@@ -87,6 +99,9 @@ class per_transaction_config
         if (expiration_time_) {
             retval.expiration_time(*expiration_time_);
         }
+        if (custom_metadata_collection_) {
+            retval.custom_metadata_collection(*custom_metadata_collection_);
+        }
         return retval;
     }
 
@@ -95,6 +110,7 @@ class per_transaction_config
     std::optional<couchbase::query_scan_consistency> scan_consistency_;
     std::optional<milliseconds> kv_timeout_;
     std::optional<nanoseconds> expiration_time_;
+    std::optional<transaction_keyspace> custom_metadata_collection_;
 };
 
 } // namespace couchbase::transactions

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_config.hxx

@@ -19,6 +19,7 @@
 #include <couchbase/operations/document_query.hxx>
 #include <couchbase/support.hxx>
 #include <couchbase/transactions/durability_level.hxx>
+#include <couchbase/transactions/transaction_keyspace.hxx>
 #include <memory>
 #include <optional>
 
@@ -205,12 +206,18 @@ namespace transactions
         {
             return cleanup_client_attempts_;
         }
+
+        void custom_metadata_collection(const transaction_keyspace& keyspace)
+        {
+            custom_metadata_collection_ = keyspace;
+        }
+
         void custom_metadata_collection(const std::string& bucket, const std::string& scope, const std::string& collection)
         {
-            custom_metadata_collection_.emplace(bucket, scope, collection, "");
+            custom_metadata_collection_.emplace(bucket, scope, collection);
         }
 
-        CB_NODISCARD std::optional<couchbase::document_id> custom_metadata_collection() const
+        CB_NODISCARD std::optional<transaction_keyspace> custom_metadata_collection() const
         {
             return custom_metadata_collection_;
         }
@@ -218,10 +225,9 @@ namespace transactions
         couchbase::document_id atr_id_from_bucket_and_key(const std::string& bucket, const std::string& key) const
         {
             if (custom_metadata_collection_) {
-                return { custom_metadata_collection_->bucket(),
-                         custom_metadata_collection_->scope(),
-                         custom_metadata_collection_->collection(),
-                         key };
+                return {
+                    custom_metadata_collection_->bucket, custom_metadata_collection_->scope, custom_metadata_collection_->collection, key
+                };
             }
             return { bucket, "_default", "_default", key };
         }
@@ -251,7 +257,7 @@ namespace transactions
         std::unique_ptr<attempt_context_testing_hooks> attempt_context_hooks_;
         std::unique_ptr<cleanup_testing_hooks> cleanup_hooks_;
         couchbase::query_scan_consistency scan_consistency_;
-        std::optional<couchbase::document_id> custom_metadata_collection_;
+        std::optional<transaction_keyspace> custom_metadata_collection_;
     };
 } // namespace transactions
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_keyspace.hxx

@@ -0,0 +1,56 @@
+/*
+ *     Copyright 2021 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/document_id.hxx>
+#include <string>
+
+namespace couchbase::transactions
+{
+/**
+ * @brief  Offline, serializable representation of a bucket, scope, and collection
+ */
+struct transaction_keyspace {
+    std::string bucket;
+    std::string scope{ "_default" };
+    std::string collection{ "_default" };
+
+    transaction_keyspace(const std::string& bucket_name, const std::string& scope_name, const std::string& collection_name)
+      : bucket(bucket_name)
+      , scope(scope_name)
+      , collection(collection_name)
+    {
+        if (scope.empty()) {
+            scope = "_default";
+        }
+        if (collection.empty()) {
+            collection = "_default";
+        }
+    }
+
+    transaction_keyspace(const std::string& bucket_name)
+      : transaction_keyspace{ bucket_name, "_default", "_default" }
+    {
+    }
+
+    transaction_keyspace(const couchbase::document_id& id)
+      : bucket(id.bucket())
+      , scope(id.scope())
+      , collection(id.collection())
+    {
+    }
+};
+} // namespace couchbase::transactions

package/deps/couchbase-transactions-cxx/include/couchbase/transactions.hxx

@@ -58,6 +58,12 @@ namespace transactions
      * @brief set log level for transactions
      */
     void set_transactions_log_level(couchbase::logger::level level);
+
+    /**
+     * @brief create the loggers, using a custom spdlog::sink, if desired.
+     */
+    void create_loggers(couchbase::logger::level level = couchbase::logger::level::off, spdlog::sink_ptr = nullptr);
+
     /**
      * @mainpage
      * A transaction consists of a lambda containing all the operations you wish to perform within a transaction.

package/deps/couchbase-transactions-cxx/src/transactions/atr_cleanup_entry.cxx

@@ -256,7 +256,7 @@ tx::atr_cleanup_entry::commit_docs(std::shared_ptr<spdlog::logger> logger,
                 }
                 if (doc.links().is_deleted()) {
                     couchbase::operations::insert_request req{ doc.id() };
-                    req.value = content;
+                    req.value = couchbase::utils::to_binary(content);
                     auto barrier = std::make_shared<std::promise<result>>();
                     auto f = barrier->get_future();
                     cleanup_->cluster_ref().execute(wrap_durable_request(req, cleanup_->config(), dl),