couchbase 4.1.1 → 4.1.3

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

@@ -19,7 +19,7 @@
 #include <random>
 #include <string>
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions.hxx>
 #include <spdlog/spdlog.h>
 
@@ -133,8 +133,8 @@ class GameServer
 
     void player_hits_monster(const string&,
                              int damage_,
-                             const couchbase::document_id& player_id,
-                             const couchbase::document_id& monster_id,
+                             const core::document_id& player_id,
+                             const core::document_id& monster_id,
                              atomic<bool>& exists)
     {
         try {
@@ -191,16 +191,16 @@ int
 main(int, const char*[])
 {
     const int NUM_THREADS = 4;
-    couchbase::logger::set_log_levels(couchbase::logger::level::trace);
+    core::logger::set_log_levels(core::logger::level::trace);
     atomic<bool> monster_exists = true;
     string bucket_name = "default";
-    couchbase::cluster_credentials auth{};
+    core::cluster_credentials auth{};
     asio::io_context io;
-    auto cluster = couchbase::cluster::create(io);
-    if (!couchbase::logger::is_initialized()) {
-        couchbase::logger::create_console_logger();
+    auto cluster = core::cluster::create(io);
+    if (!core::logger::is_initialized()) {
+        core::logger::create_console_logger();
     }
-    couchbase::logger::set_log_levels(couchbase::logger::level::trace);
+    core::logger::set_log_levels(core::logger::level::trace);
 
     std::list<std::thread> io_threads;
     for (int i = 0; i < 2 * NUM_THREADS; i++) {
@@ -211,14 +211,14 @@ main(int, const char*[])
     std::mt19937 random_number_engine; // pseudorandom number generator
     auto rand = std::bind(hit_distribution, random_number_engine);
 
-    auto connstr = couchbase::utils::parse_connection_string("couchbase://127.0.0.1");
+    auto connstr = core::utils::parse_connection_string("couchbase://127.0.0.1");
     auth.username = "Administrator";
     auth.password = "password";
     // first, open it.
     {
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        cluster->open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
+        cluster->open(core::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
         auto rc = f.get();
         if (rc) {
             cout << "ERROR opening cluster: " << rc.message() << endl;
@@ -237,33 +237,33 @@ main(int, const char*[])
         }
     }
 
-    couchbase::document_id player_id = { "default", "_default", "_default", "player_data" };
+    core::document_id player_id = { "default", "_default", "_default", "player_data" };
     Player player_data{ 14248, 23832, "player", 141, true, "Jane", make_uuid() };
 
-    couchbase::document_id monster_id = { "default", "_default", "_default", "a_grue" };
+    core::document_id monster_id = { "default", "_default", "_default", "a_grue" };
     Monster monster_data{ 91, 40000, 0.19239324085462631, "monster", "Grue", make_uuid() };
 
     // upsert a player document
     {
-        couchbase::operations::upsert_request req{ player_id };
+        core::operations::upsert_request req{ player_id };
         nlohmann::json j;
         to_json(j, player_data);
-        req.value = 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); });
+        req.value = core::utils::to_binary(j.dump());
+        auto barrier = std::make_shared<std::promise<core::operations::upsert_response>>();
+        cluster->execute(req, [barrier](core::operations::upsert_response resp) { barrier->set_value(resp); });
         auto f = barrier->get_future();
         auto resp = f.get();
-        cout << "Upserted sample player document: " << player_id.key() << "with cas:" << resp.cas.value << endl;
+        cout << "Upserted sample player document: " << player_id.key() << "with cas:" << resp.cas.value() << endl;
     }
     // upsert a monster document
     {
-        couchbase::operations::upsert_request req{ monster_id };
+        core::operations::upsert_request req{ monster_id };
         nlohmann::json j;
         to_json(j, monster_data);
-        req.value = j.dump();
-        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        req.value = core::utils::to_binary(j.dump());
+        auto barrier = std::make_shared<std::promise<core::operations::upsert_response>>();
         auto f = barrier->get_future();
-        cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp); });
+        cluster->execute(req, [barrier](core::operations::upsert_response resp) { barrier->set_value(resp); });
         auto resp = f.get();
         cout << "Upserted sample monster document: " << monster_id.key() << endl;
     }

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

@@ -19,12 +19,14 @@
 #include <optional>
 #include <string>
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations/document_query.hxx>
+#include <core/operations/document_query.hxx>
 #include <couchbase/transactions/exceptions.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 
+#include <couchbase/cluster.hxx>
+#include <couchbase/subdocument_error_context.hxx>
+
 namespace couchbase
 {
 namespace transactions
@@ -41,7 +43,7 @@ namespace transactions
       public:
         using Callback = std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>;
         using VoidCallback = std::function<void(std::exception_ptr)>;
-        using QueryCallback = std::function<void(std::exception_ptr, std::optional<operations::query_response>)>;
+        using QueryCallback = std::function<void(std::exception_ptr, std::optional<core::operations::query_response>)>;
         virtual ~async_attempt_context() = default;
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -49,7 +51,7 @@ namespace transactions
          * @param id the document's ID
          * @param cb callback function with the result when successful, or a @ref transaction_operation_failed.
          */
-        virtual void get(const couchbase::document_id& id, Callback&& cb) = 0;
+        virtual void get(const core::document_id& id, Callback&& cb) = 0;
 
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -57,7 +59,7 @@ namespace transactions
          * @param id the document's ID
          * @param cb callback function with the result when successful, or a @ref transaction_operation_failed.
          */
-        virtual void get_optional(const couchbase::document_id& id, Callback&& cb) = 0;
+        virtual void get_optional(const core::document_id& id, Callback&& cb) = 0;
 
         /**
          * Mutates the specified document with new content, using the document's last TransactionDocument#cas().
@@ -96,7 +98,7 @@ namespace transactions
          *           successful, or @ref transaction_operation_failed
          */
         template<typename Content>
-        void insert(const couchbase::document_id& id, const Content& content, Callback&& cb)
+        void insert(const core::document_id& id, const Content& content, Callback&& cb)
         {
             return insert_raw(id, default_json_serializer::serialize(content), std::move(cb));
         }
@@ -159,7 +161,7 @@ namespace transactions
 
       protected:
         /** @internal */
-        virtual void insert_raw(const couchbase::document_id& id, const std::string& content, Callback&& cb) = 0;
+        virtual void insert_raw(const core::document_id& id, const std::string& content, Callback&& cb) = 0;
 
         /** @internal */
         virtual void replace_raw(const transaction_get_result& document, const std::string& content, Callback&& cb) = 0;

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

@@ -18,7 +18,7 @@
 #include <optional>
 #include <string>
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 
@@ -49,7 +49,7 @@ namespace transactions
          * @throws transaction_operation_failed which either should not be caught by the lambda, or
          *         rethrown if it is caught.
          */
-        virtual transaction_get_result get(const couchbase::document_id& id) = 0;
+        virtual transaction_get_result get(const core::document_id& id) = 0;
 
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -62,7 +62,7 @@ namespace transactions
          * @throws transaction_operation_failed which either should not be caught by the lambda, or
          *         rethrown if it is caught.
          */
-        virtual std::optional<transaction_get_result> get_optional(const couchbase::document_id& id) = 0;
+        virtual std::optional<transaction_get_result> get_optional(const core::document_id& id) = 0;
 
         /**
          * Mutates the specified document with new content, using the document's last TransactionDocument#cas().
@@ -105,7 +105,7 @@ namespace transactions
          *         rethrown if it is caught.
          */
         template<typename Content>
-        transaction_get_result insert(const couchbase::document_id& id, const Content& content)
+        transaction_get_result insert(const core::document_id& id, const Content& content)
         {
             return insert_raw(id, default_json_serializer::serialize(content));
         }
@@ -131,14 +131,14 @@ namespace transactions
          * @param options options to apply to the query.
          * @returns result of the query.
          */
-        virtual operations::query_response query(const std::string& statement, const transaction_query_options& options) = 0;
+        virtual core::operations::query_response query(const std::string& statement, const transaction_query_options& options) = 0;
         /**
          * Performs a Query, within the current transaction.
          *
          * @param statement query statement to execute.
          * @return result of the query
          */
-        virtual operations::query_response query(const std::string& statement)
+        virtual core::operations::query_response query(const std::string& statement)
         {
             transaction_query_options opts;
             return query(statement, opts);
@@ -170,7 +170,7 @@ namespace transactions
 
       protected:
         /** @internal */
-        virtual transaction_get_result insert_raw(const couchbase::document_id& id, const std::string& content) = 0;
+        virtual transaction_get_result insert_raw(const core::document_id& id, const std::string& content) = 0;
 
         /** @internal */
         virtual transaction_get_result replace_raw(const transaction_get_result& document, const std::string& content) = 0;