couchbase 4.1.1 → 4.1.3

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

@@ -0,0 +1,482 @@
+// 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_CAPTURE_HPP
+#define TAO_JSON_EVENTS_CAPTURE_HPP
+
+#include <initializer_list>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+#include "produce.hpp"
+
+#include "../forward.hpp"
+
+namespace tao::json::events
+{
+   class virtual_base;
+
+   namespace capture
+   {
+      template< template< typename... > class Traits = traits, typename ConsumerBase = virtual_base >
+      class value;
+
+      template< template< typename... > class Traits = traits, typename ConsumerBase = virtual_base >
+      using array = std::initializer_list< value< Traits, ConsumerBase > >;
+
+      template< template< typename... > class Traits, typename ConsumerBase >
+      struct member;
+
+      template< template< typename... > class Traits = traits, typename ConsumerBase = virtual_base >
+      using object = std::initializer_list< member< Traits, ConsumerBase > >;
+
+   }  // namespace capture
+
+   template< template< typename... > class Traits, typename Consumer, typename ConsumerBase >
+   void produce( Consumer& c, const capture::value< Traits, ConsumerBase >& v )
+   {
+      v.produce( c );
+   }
+
+   template< template< typename... > class Traits, typename Consumer, typename ConsumerBase >
+   void produce_elements( Consumer& c, const capture::array< Traits, ConsumerBase >& a )
+   {
+      for( const auto& e : a ) {
+         e.produce( c );
+         c.element();
+      }
+   }
+
+   template< template< typename... > class Traits, typename Consumer, typename ConsumerBase >
+   void produce( Consumer& c, const capture::array< Traits, ConsumerBase >& a )
+   {
+      c.begin_array( a.size() );
+      events::produce_elements( c, a );
+      c.end_array( a.size() );
+   }
+
+   template< template< typename... > class Traits, typename Consumer, typename ConsumerBase >
+   void produce_members( Consumer& c, const capture::object< Traits, ConsumerBase >& o )
+   {
+      for( const auto& m : o ) {
+         c.key( m.key );
+         m.produce( c );
+         c.member();
+      }
+   }
+
+   template< template< typename... > class Traits, typename Consumer, typename ConsumerBase >
+   void produce( Consumer& c, const capture::object< Traits, ConsumerBase >& o )
+   {
+      c.begin_object( o.size() );
+      events::produce_members( c, o );
+      c.end_object( o.size() );
+   }
+
+   namespace capture
+   {
+      union union_t
+      {
+         const void* p;
+         bool b;
+         char c;
+         signed char sc;
+         unsigned char uc;
+         signed short ss;
+         unsigned short us;
+         signed int si;
+         unsigned int ui;
+         signed long sl;
+         unsigned long ul;
+         signed long long sll;
+         unsigned long long ull;
+         float f;
+         double d;
+
+         // clang-format off
+         explicit union_t( const void* v ) noexcept : p( v ) {}
+         explicit union_t( const bool v ) noexcept : b( v ) {}
+         explicit union_t( const char v ) noexcept : c( v ) {}
+         explicit union_t( const signed char v ) noexcept : sc( v ) {}
+         explicit union_t( const unsigned char v ) noexcept : uc( v ) {}
+         explicit union_t( const signed short v ) noexcept : ss( v ) {}
+         explicit union_t( const unsigned short v ) noexcept : us( v ) {}
+         explicit union_t( const signed int v ) noexcept : si( v ) {}
+         explicit union_t( const unsigned int v ) noexcept : ui( v ) {}
+         explicit union_t( const signed long v ) noexcept : sl( v ) {}
+         explicit union_t( const unsigned long v ) noexcept : ul( v ) {}
+         explicit union_t( const signed long long v ) noexcept : sll( v ) {}
+         explicit union_t( const unsigned long long v ) noexcept : ull( v ) {}
+         explicit union_t( const float v ) noexcept : f( v ) {}
+         explicit union_t( const double v ) noexcept : d( v ) {}
+
+         explicit operator bool() const noexcept { return b; }
+         explicit operator char() const noexcept { return c; }
+         explicit operator signed char() const noexcept { return sc; }
+         explicit operator unsigned char() const noexcept { return uc; }
+         explicit operator signed short() const noexcept { return ss; }
+         explicit operator unsigned short() const noexcept { return us; }
+         explicit operator signed int() const noexcept { return si; }
+         explicit operator unsigned int() const noexcept { return ui; }
+         explicit operator signed long() const noexcept { return sl; }
+         explicit operator unsigned long() const noexcept { return ul; }
+         explicit operator signed long long() const noexcept { return sll; }
+         explicit operator unsigned long long() const noexcept { return ull; }
+         explicit operator float() const noexcept { return f; }
+         explicit operator double() const noexcept { return d; }
+         // clang-format on
+      };
+
+      template< typename, typename = void >
+      struct capture_traits
+         : std::false_type
+      {};
+
+      template< typename T >
+      struct capture_traits< T, std::enable_if_t< std::is_pointer_v< std::decay_t< T > > > >
+         : std::true_type
+      {
+         [[nodiscard]] static const void* to_underlying( const T v ) noexcept
+         {
+            return v;
+         }
+
+         [[nodiscard]] static auto from_underlying( const union_t& v ) noexcept
+         {
+            return std::decay_t< T >( v.p );
+         }
+      };
+
+      template< typename T >
+      struct capture_traits< T, std::enable_if_t< std::is_arithmetic_v< T > > >
+         : std::true_type
+      {
+         [[nodiscard]] static T to_underlying( const T v ) noexcept
+         {
+            return v;
+         }
+
+         [[nodiscard]] static T from_underlying( const union_t& v ) noexcept
+         {
+            return static_cast< T >( v );
+         }
+      };
+
+      template< typename T >
+      struct capture_traits< T, std::enable_if_t< std::is_enum_v< T > > >
+         : std::true_type
+      {
+         using underlying_t = std::underlying_type_t< T >;
+
+         [[nodiscard]] static underlying_t to_underlying( const T v ) noexcept
+         {
+            return static_cast< underlying_t >( v );
+         }
+
+         [[nodiscard]] static T from_underlying( const union_t& v ) noexcept
+         {
+            return static_cast< T >( static_cast< underlying_t >( v ) );
+         }
+      };
+
+      namespace internal
+      {
+         template< template< typename... > class Traits, typename Consumer, typename T >
+         void produce_from_underlying( Consumer& c, const union_t& u )
+         {
+            events::produce< Traits >( c, capture_traits< T >::from_underlying( u ) );
+         }
+
+         template< template< typename... > class Traits, typename Consumer, typename T >
+         void produce_from_pointer( Consumer& c, const union_t& u )
+         {
+            events::produce< Traits >( c, *static_cast< const T* >( u.p ) );
+         }
+
+      }  // namespace internal
+
+      template< template< typename... > class Traits, typename ConsumerBase >
+      class value
+      {
+      private:
+         const union_t m_value;
+
+         using producer_t = void( ConsumerBase&, const union_t& );
+         producer_t* const m_producer;
+
+      public:
+         template< typename T, typename = std::enable_if_t< capture_traits< T >::value > >
+         value( const T v ) noexcept
+            : m_value( capture_traits< T >::to_underlying( v ) ),
+              m_producer( &internal::produce_from_underlying< Traits, ConsumerBase, T > )
+         {
+            static_assert( noexcept( capture_traits< T >::to_underlying( v ) ) );
+         }
+
+         template< typename T, typename = std::enable_if_t< !capture_traits< T >::value > >
+         value( const T& v ) noexcept
+            : m_value( &v ),
+              m_producer( &internal::produce_from_pointer< Traits, ConsumerBase, T > )
+         {}
+
+         value( const object< Traits, ConsumerBase >& il ) noexcept
+            : m_value( &il ),
+              m_producer( &internal::produce_from_pointer< Traits, ConsumerBase, object< Traits, ConsumerBase > > )
+         {}
+
+         void produce( ConsumerBase& c ) const
+         {
+            m_producer( c, m_value );
+         }
+      };
+
+      template< template< typename... > class Traits, typename ConsumerBase >
+      struct member
+         : value< Traits, ConsumerBase >
+      {
+         const std::string_view key;
+
+         template< typename T >
+         member( const std::string_view k, T&& v ) noexcept
+            : value< Traits, ConsumerBase >( std::forward< T >( v ) ),
+              key( k )
+         {}
+
+         template< typename T >
+         member( T&& v ) noexcept
+            : member( Traits< std::decay_t< T > >::template default_key< Traits >::as_string_view(), std::forward< T >( v ) )
+         {}
+
+         member( const std::string_view k, const object< Traits, ConsumerBase >& il ) noexcept
+            : value< Traits, ConsumerBase >( il ),
+              key( k )
+         {}
+
+         member( const member& ) = delete;
+         member( member&& ) = delete;
+      };
+
+      template< template< typename... > class Traits, typename Consumer >
+      class assign_t
+      {
+      private:
+         Consumer& m_consumer;
+
+      public:
+         explicit assign_t( Consumer& consumer ) noexcept
+            : m_consumer( consumer )
+         {}
+
+         assign_t& operator=( const value< Traits, Consumer >& v )
+         {
+            produce< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename ConsumerBase >
+         assign_t& operator=( const value< Traits, ConsumerBase >& v )
+         {
+            produce< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename ConsumerBase >
+         assign_t& operator=( const array< Traits, ConsumerBase >& v )
+         {
+            produce< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename ConsumerBase >
+         assign_t& operator=( const object< Traits, ConsumerBase >& v )
+         {
+            produce< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         [[nodiscard]] Consumer& consumer() noexcept
+         {
+            return m_consumer;
+         }
+
+         [[nodiscard]] const Consumer& consumer() const noexcept
+         {
+            return m_consumer;
+         }
+      };
+
+      template< template< typename... > class Traits, typename Consumer >
+      class array_t
+      {
+      private:
+         Consumer& m_consumer;
+
+      public:
+         explicit array_t( Consumer& consumer ) noexcept( noexcept( m_consumer.begin_array() ) )
+            : m_consumer( consumer )
+         {
+            m_consumer.begin_array();
+         }
+
+         array_t( const array_t& ) = delete;
+         array_t( array_t&& ) = delete;
+
+         ~array_t()
+         {
+            m_consumer.end_array();
+         }
+
+         array_t& operator=( const array_t& ) = delete;
+         array_t& operator=( array_t&& ) = delete;
+
+         array_t& operator+=( const array< Traits, Consumer >& v )
+         {
+            produce_elements< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename ConsumerBase >
+         array_t& operator+=( const array< Traits, ConsumerBase >& v )
+         {
+            produce_elements< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename Container >
+         void append( const Container& c )
+         {
+            for( const auto& e : c ) {
+               this->push_back( e );
+            }
+         }
+
+         template< typename V >
+         void push_back( V&& v )
+         {
+            events::produce< Traits >( m_consumer, std::forward< V >( v ) );
+            m_consumer.element();
+         }
+
+         [[nodiscard]] Consumer& consumer() noexcept
+         {
+            return m_consumer;
+         }
+
+         [[nodiscard]] const Consumer& consumer() const noexcept
+         {
+            return m_consumer;
+         }
+      };
+
+      template< template< typename... > class Traits, typename Consumer >
+      class object_t
+      {
+      private:
+         Consumer& m_consumer;
+
+      public:
+         explicit object_t( Consumer& consumer ) noexcept( noexcept( m_consumer.begin_object() ) )
+            : m_consumer( consumer )
+         {
+            m_consumer.begin_object();
+         }
+
+         object_t( const object_t& ) = delete;
+         object_t( object_t&& ) = delete;
+
+         ~object_t()
+         {
+            m_consumer.end_object();
+         }
+
+         object_t& operator=( const object_t& ) = delete;
+         object_t& operator=( object_t&& ) = delete;
+
+         object_t& operator+=( const object< Traits, Consumer >& v )
+         {
+            produce_members< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename ConsumerBase >
+         object_t& operator+=( const object< Traits, ConsumerBase >& v )
+         {
+            produce_members< Traits >( m_consumer, v );
+            return *this;
+         }
+
+         template< typename Container >
+         void append( const Container& c )
+         {
+            for( const auto& [ k, v ] : c ) {
+               this->insert( k, v );
+            }
+         }
+
+         template< typename K, typename V >
+         void insert( K&& k, V&& v )
+         {
+            m_consumer.key( std::forward< K >( k ) );
+            events::produce< Traits >( m_consumer, std::forward< V >( v ) );
+            m_consumer.member();
+         }
+
+         template< typename V >
+         void insert( V&& v )
+         {
+            this->insert( Traits< std::decay_t< V > >::template default_key< Traits >::as_string_view(), std::forward< V >( v ) );
+         }
+
+         [[nodiscard]] Consumer& consumer() noexcept
+         {
+            return m_consumer;
+         }
+
+         [[nodiscard]] const Consumer& consumer() const noexcept
+         {
+            return m_consumer;
+         }
+      };
+
+   }  // namespace capture
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::assign_t< Traits, Consumer > assign( Consumer& c ) noexcept( noexcept( capture::assign_t< Traits, Consumer >( c ) ) )
+   {
+      return capture::assign_t< Traits, Consumer >( c );
+   }
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::assign_t< Traits, Consumer > assign( Consumer&& c ) noexcept( noexcept( assign< Traits >( c ) ) )
+   {
+      return assign< Traits >( c );
+   }
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::array_t< Traits, Consumer > array( Consumer& c ) noexcept( noexcept( capture::array_t< Traits, Consumer >( c ) ) )
+   {
+      return capture::array_t< Traits, Consumer >( c );
+   }
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::array_t< Traits, Consumer > array( Consumer&& c ) noexcept( noexcept( array< Traits >( c ) ) )
+   {
+      return array< Traits >( c );
+   }
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::object_t< Traits, Consumer > object( Consumer& c ) noexcept( noexcept( capture::object_t< Traits, Consumer >( c ) ) )
+   {
+      return capture::object_t< Traits, Consumer >( c );
+   }
+
+   template< template< typename... > class Traits = traits, typename Consumer >
+   [[nodiscard]] capture::object_t< Traits, Consumer > object( Consumer&& c ) noexcept( noexcept( object< Traits >( c ) ) )
+   {
+      return object< Traits >( c );
+   }
+
+}  // namespace tao::json::events
+
+#endif

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

@@ -9,7 +9,7 @@
 #include "../basic_value.hpp"
 #include "../internal/format.hpp"
 
-#include "virtual_ref.hpp"
+#include "virtualize.hpp"
 
 namespace tao::json::events
 {
@@ -89,7 +89,7 @@ namespace tao::json::events
 
          case type::OPAQUE_PTR: {
             const auto& q = v.get_opaque_ptr();
-            virtual_ref ref( consumer );
+            decltype( auto ) ref = events::virtualize( consumer );
             q.producer( ref, q.data );
             return;
          }
@@ -183,7 +183,7 @@ namespace tao::json::events
 
          case type::OPAQUE_PTR: {
             const auto& q = v.get_opaque_ptr();
-            virtual_ref ref( consumer );
+            decltype( auto ) ref = events::virtualize( consumer );
             q.producer( ref, q.data );
             return;
          }

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

@@ -4,12 +4,9 @@
 #ifndef TAO_JSON_EVENTS_PRODUCE_HPP
 #define TAO_JSON_EVENTS_PRODUCE_HPP
 
-#include <initializer_list>
 #include <type_traits>
 #include <utility>
 
-#include "virtual_base.hpp"
-
 #include "../forward.hpp"
 
 namespace tao::json::events
@@ -20,101 +17,12 @@ namespace tao::json::events
       Traits< std::decay_t< T > >::template produce< Traits >( c, std::forward< T >( t ) );
    }
 
-   template< template< typename... > class Traits = traits, typename Consumer = virtual_base >
-   class capture_value;
-
-   template< template< typename... > class Traits = traits, typename Consumer = virtual_base >
-   using capture_array = std::initializer_list< capture_value< Traits, Consumer > >;
-
-   template< template< typename... > class Traits, typename Consumer >
-   struct capture_member;
-
-   template< template< typename... > class Traits = traits, typename Consumer = virtual_base >
-   using capture_object = std::initializer_list< capture_member< Traits, Consumer > >;
-
-   template< template< typename... > class Traits, typename ActualConsumer, typename Consumer >
-   void produce( ActualConsumer& c, const capture_value< Traits, Consumer >& v )
-   {
-      v.produce( c );
-   }
-
-   template< template< typename... > class Traits, typename ActualConsumer, typename Consumer >
-   void produce( ActualConsumer& c, const capture_array< Traits, Consumer >& a )
-   {
-      c.begin_array( a.size() );
-      for( const auto& e : a ) {
-         e.produce( c );
-         c.element();
-      }
-      c.end_array( a.size() );
-   }
-
-   template< template< typename... > class Traits, typename ActualConsumer, typename Consumer >
-   void produce( ActualConsumer& c, const capture_object< Traits, Consumer >& o )
+   template< template< typename... > class Traits = traits, typename Consumer, typename T >
+   void produce( Consumer&& c, T&& t )
    {
-      c.begin_object( o.size() );
-      for( const auto& m : o ) {
-         c.key( m.key );
-         m.produce( c );
-         c.member();
-      }
-      c.end_object( o.size() );
+      produce< Traits >( c, std::forward< T >( t ) );
    }
 
-   template< template< typename... > class Traits, typename Consumer >
-   class capture_value
-   {
-   private:
-      const void* const m_value;
-
-      using producer_t = void( Consumer&, const void* );
-      producer_t* const m_producer;
-
-   public:
-      template< typename T >
-      capture_value( const T& v ) noexcept
-         : m_value( &v ),
-           m_producer( []( Consumer& c, const void* d ) {
-              events::produce< Traits >( c, *static_cast< const T* >( d ) );
-           } )
-      {}
-
-      capture_value( const capture_object< Traits, Consumer >& il ) noexcept
-         : m_value( &il ),
-           m_producer( []( Consumer& c, const void* d ) {
-              events::produce( c, *static_cast< const capture_object< Traits, Consumer >* >( d ) );
-           } )
-      {}
-
-      void produce( Consumer& c ) const
-      {
-         m_producer( c, m_value );
-      }
-   };
-
-   template< template< typename... > class Traits, typename Consumer >
-   struct capture_member
-      : capture_value< Traits, Consumer >
-   {
-      const std::string_view key;
-
-      template< typename T >
-      capture_member( const std::string_view k, const T& v ) noexcept
-         : capture_value< Traits, Consumer >( v ),
-           key( k )
-      {}
-
-      template< typename T >
-      capture_member( const T& v ) noexcept
-         : capture_member( Traits< std::decay_t< T > >::template default_key< Traits >::as_string_view(), v )
-      {}
-
-      capture_member( const std::string_view k, const capture_object< Traits, Consumer >& il ) noexcept
-         : capture_value< Traits, Consumer >( il ),
-           key( k )
-      {}
-   };
-
 }  // namespace tao::json::events
 
 #endif