couchbase 4.0.0 → 4.1.2

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2017-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BASIC_VALUE_HPP
@@ -293,12 +293,17 @@ namespace tao::json
          return std::get< double >( m_variant );
       }
 
-      [[nodiscard]] std::string& get_string()
+      [[nodiscard]] std::string& get_string() &
       {
          return std::get< std::string >( m_variant );
       }
 
-      [[nodiscard]] const std::string& get_string() const
+      [[nodiscard]] std::string&& get_string() &&
+      {
+         return std::get< std::string >( std::move( m_variant ) );
+      }
+
+      [[nodiscard]] const std::string& get_string() const&
       {
          return std::get< std::string >( m_variant );
       }
@@ -313,12 +318,17 @@ namespace tao::json
          return is_string() ? get_string() : get_string_view();
       }
 
-      [[nodiscard]] binary& get_binary()
+      [[nodiscard]] binary& get_binary() &
       {
          return std::get< binary >( m_variant );
       }
 
-      [[nodiscard]] const binary& get_binary() const
+      [[nodiscard]] binary&& get_binary() &&
+      {
+         return std::get< binary >( std::move( m_variant ) );
+      }
+
+      [[nodiscard]] const binary& get_binary() const&
       {
          return std::get< binary >( m_variant );
       }
@@ -333,22 +343,32 @@ namespace tao::json
          return is_binary() ? get_binary() : get_binary_view();
       }
 
-      [[nodiscard]] array_t& get_array()
+      [[nodiscard]] array_t& get_array() &
       {
          return std::get< array_t >( m_variant );
       }
 
-      [[nodiscard]] const array_t& get_array() const
+      [[nodiscard]] array_t&& get_array() &&
+      {
+         return std::get< array_t >( std::move( m_variant ) );
+      }
+
+      [[nodiscard]] const array_t& get_array() const&
       {
          return std::get< array_t >( m_variant );
       }
 
-      [[nodiscard]] object_t& get_object()
+      [[nodiscard]] object_t& get_object() &
       {
          return std::get< object_t >( m_variant );
       }
 
-      [[nodiscard]] const object_t& get_object() const
+      [[nodiscard]] object_t&& get_object() &&
+      {
+         return std::get< object_t >( std::move( m_variant ) );
+      }
+
+      [[nodiscard]] const object_t& get_object() const&
       {
          return std::get< object_t >( m_variant );
       }
@@ -537,7 +557,7 @@ namespace tao::json
       }
 
       template< typename T >
-      void set_opaque_ptr( const T* data, const producer_t producer ) noexcept
+      void set_opaque_ptr( const T* data, producer_t* producer ) noexcept
       {
          assert( data );
          assert( producer );

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2017-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINARY_HPP

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2017-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINARY_VIEW_HPP
@@ -7,11 +7,25 @@
 #include "span.hpp"
 
 #include <algorithm>
+#include <cstddef>
 
 namespace tao
 {
    using binary_view = span< const std::byte >;
 
+   template< typename T >
+   [[nodiscard]] binary_view to_binary_view( const T* data, const std::size_t size ) noexcept
+   {
+      static_assert( sizeof( T ) == 1 );
+      return { reinterpret_cast< const std::byte* >( data ), size };
+   }
+
+   template< typename T >
+   [[nodiscard]] binary_view to_binary_view( const T& value ) noexcept
+   {
+      return tao::to_binary_view( std::data( value ), std::size( value ) );
+   }
+
    namespace internal
    {
       [[nodiscard]] inline bool binary_equal( const binary_view lhs, const binary_view rhs ) noexcept

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/constant.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_CONSTANT_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/element.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_ELEMENT_HPP
@@ -11,28 +11,33 @@
 
 #include "../events/produce.hpp"
 
+#include "internal/elementr.hpp"
+
 namespace tao::json::binding
 {
    namespace internal
    {
-      template< typename T, T, typename = void >
-      struct element;
+      template< typename T, T F, typename = void >
+      struct element
+         : elementr< T, F >  // TODO: Do we want to keep the fall-back to elementr?
+      {
+         using class_t = typename elementr< T, F >::read_class_t;
+         using value_t = typename elementr< T, F >::read_value_t;
+      };
 
       template< typename C, typename T, T C::*P >
       struct element< T C::*, P, std::enable_if_t< std::is_member_object_pointer_v< T C::* > > >
       {
          using class_t = C;
-         using value_t = T;
+         using value_t = std::decay_t< T >;
 
-         using internal_t = std::decay_t< decltype( std::declval< C >().*P ) >;
-
-         [[nodiscard]] static const auto& read( const C& v )
+         [[nodiscard]] static const auto& read( const C& v ) noexcept
          {
             return v.*P;
          }
 
          template< typename W >
-         static void write( C& v, W&& w )
+         static void write( C& v, W&& w ) noexcept( std::is_nothrow_assignable_v< value_t, decltype( std::forward< W > ) > )
          {
             v.*P = std::forward< W >( w );
          }
@@ -56,127 +61,11 @@ namespace tao::json::binding
          }
       };
 
-      template< typename C, typename T, T C::*P >
-      struct element< T C::*, P, std::enable_if_t< std::is_member_function_pointer_v< T C::* > > >
-      {
-         using class_t = C;
-         using value_t = T;
-
-         using internal_t = std::decay_t< decltype( ( std::declval< const C >().*P )() ) >;
-
-         [[nodiscard]] static decltype( auto ) read( const C& v )
-         {
-            return ( v.*P )();
-         }
-
-         template< template< typename... > class Traits = traits, typename Consumer >
-         static void produce( Consumer& consumer, const C& v )
-         {
-            events::produce< Traits >( consumer, ( v.*P )() );
-         }
-      };
-
-      template< typename C, typename T, T ( *P )( const C& ) >
-      struct element< T ( * )( const C& ), P >
-      {
-         using class_t = C;
-         using value_t = T;
-
-         [[nodiscard]] static decltype( auto ) read( const C& v )
-         {
-            return P( v );
-         }
-
-         template< template< typename... > class Traits = traits, typename Consumer >
-         static void produce( Consumer& consumer, const C& v )
-         {
-            events::produce< Traits >( consumer, P( v ) );
-         }
-      };
-
-      template< typename CT, CT CP, typename T, T P >
-      struct element2;
-
-      template< typename A, typename CR, CR ( *CP )( const A& ) noexcept, typename R, R ( *P )( A& ) noexcept >
-      struct element2< CR ( * )( const A& ) noexcept, CP, R ( * )( A& ) noexcept, P >
-      {
-         using class_t = A;
-         using value_t = std::decay_t< R >;
-
-         [[nodiscard]] static decltype( auto ) read( const A& v ) noexcept
-         {
-            return CP( v );
-         }
-
-         template< typename W >
-         static void write( A& v, W&& w )
-         {
-            P( v ) = std::forward< W >( w );
-         }
-
-         template< template< typename... > class Traits >
-         static void to( const basic_value< Traits >& v, A& x )
-         {
-            v.to( P( x ) );
-         }
-
-         template< template< typename... > class Traits = traits, typename Producer >
-         static void consume( Producer& parser, A& v )
-         {
-            json::consume< Traits >( parser, P( v ) );
-         }
-
-         template< template< typename... > class Traits = traits, typename Consumer >
-         static void produce( Consumer& consumer, const A& v )
-         {
-            events::produce< Traits >( consumer, CP( v ) );
-         }
-      };
-
-      template< typename A, typename CR, CR ( *CP )( const A& ) noexcept, typename R, void ( *P )( A&, R&& ) noexcept >
-      struct element2< CR ( * )( const A& ) noexcept, CP, void ( * )( A&, R&& ) noexcept, P >
-      {
-         using class_t = A;
-         using value_t = std::decay_t< R >;
-
-         [[nodiscard]] static decltype( auto ) read( const A& v ) noexcept
-         {
-            return CP( v );
-         }
-
-         template< typename W >
-         static void write( A& v, W&& w )
-         {
-            P( v, std::forward< W >( w ) );
-         }
-
-         template< template< typename... > class Traits >
-         static void to( const basic_value< Traits >& v, A& x )
-         {
-            P( x, v.template as< std::decay_t< R > >() );
-         }
-
-         template< template< typename... > class Traits = traits, typename Producer >
-         static void consume( Producer& parser, A& v )
-         {
-            P( v, json::consume< Traits >( parser ) );
-         }
-
-         template< template< typename... > class Traits = traits, typename Consumer >
-         static void produce( Consumer& consumer, const A& v )
-         {
-            events::produce< Traits >( consumer, CP( v ) );
-         }
-      };
-
    }  // namespace internal
 
    template< auto P >
    using element = internal::element< decltype( P ), P >;
 
-   template< auto CP, auto P >
-   using element2 = internal::element2< decltype( CP ), CP, decltype( P ), P >;
-
 }  // namespace tao::json::binding
 
 #endif

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/element2.hpp

@@ -0,0 +1,35 @@
+// Copyright (c) 2021-2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINDING_ELEMENT2_HPP
+#define TAO_JSON_BINDING_ELEMENT2_HPP
+
+#include <type_traits>
+
+#include "internal/elementr.hpp"
+#include "internal/elementw.hpp"
+
+namespace tao::json::binding
+{
+   namespace internal
+   {
+      template< typename GT, GT GET, typename ST, ST SET >
+      struct element2
+         : elementr< GT, GET >,
+           elementw< ST, SET >
+      {
+         static_assert( std::is_same_v< typename elementr< GT, GET >::read_class_t, typename elementw< ST, SET >::write_class_t > );
+         static_assert( std::is_same_v< typename elementr< GT, GET >::read_value_t, typename elementw< ST, SET >::write_value_t > );
+
+         using class_t = typename elementr< GT, GET >::read_class_t;
+         using value_t = typename elementr< GT, GET >::read_value_t;
+      };
+
+   }  // namespace internal
+
+   template< auto GET, auto SET >
+   using element2 = internal::element2< decltype( GET ), GET, decltype( SET ), SET >;
+
+}  // namespace tao::json::binding
+
+#endif

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/factory.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_FACTORY_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/for_nothing_value.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_FOR_NOTHING_VALUE_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/for_unknown_key.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_FOR_UNKNOWN_KEY_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/inherit.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_INHERIT_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/internal/array.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/json/
 
 #ifndef TAO_JSON_BINDING_INTERNAL_ARRAY_HPP

package/deps/couchbase-cxx-client/third_party/json/include/tao/json/binding/internal/elementr.hpp

@@ -0,0 +1,134 @@
+// Copyright (c) 2018-2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINDING_INTERNAL_ELEMENTR_HPP
+#define TAO_JSON_BINDING_INTERNAL_ELEMENTR_HPP
+
+#include <type_traits>
+
+#include "../../forward.hpp"
+
+#include "../../events/produce.hpp"
+
+namespace tao::json::binding::internal
+{
+   template< typename T, T, typename = void >
+   struct elementr;
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+
+   template< bool N, typename C, typename T, T ( *P )( const C& ) noexcept( N ) >
+   struct elementr< T ( * )( const C& ) noexcept( N ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( N )
+      {
+         return P( v );
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, P( v ) );
+      }
+   };
+
+   template< bool N, typename C, typename T, T ( C::*P )() const noexcept( N ) >
+   struct elementr< T ( C::* )() const noexcept( N ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( N )
+      {
+         return ( v.*P )();
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, ( v.*P )() );
+      }
+   };
+
+#else  // TODO: Check MSVC occasionally. Others?
+
+   template< typename C, typename T, T ( *P )( const C& ) noexcept( true ) >
+   struct elementr< T ( * )( const C& ) noexcept( true ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( true )
+      {
+         return P( v );
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, P( v ) );
+      }
+   };
+
+   template< typename C, typename T, T ( *P )( const C& ) noexcept( false ) >
+   struct elementr< T ( * )( const C& ) noexcept( false ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( false )
+      {
+         return P( v );
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, P( v ) );
+      }
+   };
+
+   template< typename C, typename T, T ( C::*P )() const noexcept( true ) >
+   struct elementr< T ( C::* )() const noexcept( true ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( true )
+      {
+         return ( v.*P )();
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, ( v.*P )() );
+      }
+   };
+
+   template< typename C, typename T, T ( C::*P )() const noexcept( false ) >
+   struct elementr< T ( C::* )() const noexcept( false ), P >
+   {
+      using read_class_t = C;
+      using read_value_t = std::decay_t< T >;
+
+      [[nodiscard]] static decltype( auto ) read( const C& v ) noexcept( false )
+      {
+         return ( v.*P )();
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer >
+      static void produce( Consumer& consumer, const C& v )
+      {
+         events::produce< Traits >( consumer, ( v.*P )() );
+      }
+   };
+
+#endif
+
+}  // namespace tao::json::binding::internal
+
+#endif