couchbase 3.0.3-universal-darwin-20

data/ext/third_party/json/include/tao/json/binary.hpp

@@ -0,0 +1,103 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINARY_HPP
+#define TAO_JSON_BINARY_HPP
+
+#include <cstddef>
+#include <vector>
+
+#include "internal/dependent_false.hpp"
+
+namespace tao
+{
+   using binary = std::vector< std::byte >;
+
+}  // namespace tao
+
+namespace tao::json
+{
+   namespace internal
+   {
+      [[nodiscard]] constexpr char unhex_char( const char c ) noexcept
+      {
+         return static_cast< char >( ( c < 'A' ) ? ( c - '0' ) : ( ( c < 'a' ) ? ( c - 'A' + 10 ) : ( c - 'a' + 10 ) ) );
+      }
+
+      template< typename V, V... >
+      struct vlist;
+
+      template< typename T, typename L, char... Cs >
+      struct unhex_helper;
+
+      template< typename T, typename V, V... Vs >
+      struct unhex_helper< T, vlist< V, Vs... > >
+      {
+         [[nodiscard]] static constexpr T unhex()
+         {
+            return T{ Vs... };
+         }
+      };
+
+      template< typename T, typename V, V... Vs, char C >
+      struct unhex_helper< T, vlist< V, Vs... >, C >
+         : unhex_helper< T, vlist< V > >
+      {
+         static_assert( internal::dependent_false< T >, "digits must occur in pairs" );
+      };
+
+      template< typename T, typename V, V... Vs, char C1, char... Cs >
+      struct unhex_helper< T, vlist< V, Vs... >, '\'', C1, Cs... >
+         : unhex_helper< T, vlist< V, Vs... >, C1, Cs... >
+      {
+      };
+
+      template< typename T, typename V, V... Vs, char C0, char... Cs >
+      struct unhex_helper< T, vlist< V, Vs... >, C0, '\'', Cs... >
+         : unhex_helper< T, vlist< V > >
+      {
+         static_assert( internal::dependent_false< T >, "digit separator only allowed between pairs of digits" );
+      };
+
+      template< typename T, typename V, V... Vs, char C0, char C1, char... Cs >
+      struct unhex_helper< T, vlist< V, Vs... >, C0, C1, Cs... >
+         : unhex_helper< T, vlist< V, Vs..., V( ( unhex_char( C0 ) << 4 ) + unhex_char( C1 ) ) >, Cs... >
+      {
+      };
+
+      template< typename T, typename V, char C >
+      [[nodiscard]] constexpr T unhex()
+      {
+         static_assert( internal::dependent_false< T >, "not a hex literal" );
+         return T{};
+      }
+
+      template< typename T, typename V, char C0, char C1, char... Cs >
+      [[nodiscard]] constexpr T unhex()
+      {
+         static_assert( C0 == '0', "not a hex literal" );
+         static_assert( C1 == 'x' || C1 == 'X', "not a hex literal" );
+         return unhex_helper< T, vlist< V >, Cs... >::unhex();
+      }
+
+      template< typename T, char... Cs >
+      [[nodiscard]] constexpr T unhex()
+      {
+         return unhex< T, typename T::value_type, Cs... >();
+      }
+
+   }  // namespace internal
+
+   inline namespace literals
+   {
+      template< char... Cs >
+      [[nodiscard]] std::vector< std::byte > operator"" _binary()
+      {
+         return internal::unhex< std::vector< std::byte >, Cs... >();
+      }
+
+   }  // namespace literals
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/binary_view.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINARY_VIEW_HPP
+#define TAO_JSON_BINARY_VIEW_HPP
+
+#include "span.hpp"
+
+#include <algorithm>
+
+namespace tao
+{
+   using binary_view = span< const std::byte >;
+
+   namespace internal
+   {
+      [[nodiscard]] inline bool binary_equal( const binary_view lhs, const binary_view rhs ) noexcept
+      {
+         return std::equal( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+      }
+
+      [[nodiscard]] inline bool binary_less( const binary_view lhs, const binary_view rhs ) noexcept
+      {
+         return std::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+      }
+
+   }  // namespace internal
+
+}  // namespace tao
+
+#endif

data/ext/third_party/json/include/tao/json/binding.hpp

@@ -0,0 +1,71 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINDING_HPP
+#define TAO_JSON_BINDING_HPP
+
+#include "binding/constant.hpp"
+#include "binding/element.hpp"
+#include "binding/factory.hpp"
+#include "binding/for_nothing_value.hpp"
+#include "binding/for_unknown_key.hpp"
+#include "binding/inherit.hpp"
+#include "binding/member.hpp"
+#include "binding/versions.hpp"
+
+#include "binding/internal/array.hpp"
+#include "binding/internal/inherit.hpp"
+#include "binding/internal/object.hpp"
+
+namespace tao::json::binding
+{
+   namespace internal
+   {
+      template< typename... As >
+      struct make_array
+      {
+         using list = json::internal::type_list_concat_t< internal::inherit_elements< As >... >;
+         using type = internal::array< list >;
+      };
+
+   }  // namespace internal
+
+   template< typename... As >
+   using array = typename internal::make_array< As... >::type;
+
+   template< for_unknown_key E, for_nothing_value N, typename... As >
+   using basic_object = internal::basic_object< E, N, json::internal::type_list_concat_t< internal::inherit_members< As >... > >;
+
+   template< typename... As >
+   using object = basic_object< for_unknown_key::fail, for_nothing_value::encode, As... >;
+
+}  // namespace tao::json::binding
+
+#define TAO_JSON_BIND_ELEMENT( ... ) tao::json::binding::element< __VA_ARGS__ >
+
+#define TAO_JSON_BIND_ELEMENT_BOOL( VaLue ) tao::json::binding::element_b< VaLue >
+#define TAO_JSON_BIND_ELEMENT_SIGNED( VaLue ) tao::json::binding::element_i< VaLue >
+#define TAO_JSON_BIND_ELEMENT_UNSIGNED( VaLue ) tao::json::binding::element_u< VaLue >
+#define TAO_JSON_BIND_ELEMENT_STRING( VaLue ) tao::json::binding::element_s< TAO_JSON_STRING_T( VaLue ) >
+
+#define TAO_JSON_BIND_REQUIRED( KeY, ... ) tao::json::binding::member< tao::json::binding::member_kind::required, TAO_JSON_STRING_T( KeY ), __VA_ARGS__ >
+#define TAO_JSON_BIND_OPTIONAL( KeY, ... ) tao::json::binding::member< tao::json::binding::member_kind::optional, TAO_JSON_STRING_T( KeY ), __VA_ARGS__ >
+
+#define TAO_JSON_BIND_REQUIRED_BOOL( KeY, VaLue ) tao::json::binding::member_b< tao::json::binding::member_kind::required, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_REQUIRED_SIGNED( KeY, VaLue ) tao::json::binding::member_i< tao::json::binding::member_kind::required, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_REQUIRED_UNSIGNED( KeY, VaLue ) tao::json::binding::member_u< tao::json::binding::member_kind::required, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_REQUIRED_STRING( KeY, VaLue ) tao::json::binding::member_s< tao::json::binding::member_kind::required, TAO_JSON_STRING_T( KeY ), TAO_JSON_STRING_T( VaLue ) >
+
+#define TAO_JSON_BIND_OPTIONAL_BOOL( KeY, VaLue ) tao::json::binding::member_b< tao::json::binding::member_kind::optional, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_OPTIONAL_SIGNED( KeY, VaLue ) tao::json::binding::member_i< tao::json::binding::member_kind::optional, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_OPTIONAL_UNSIGNED( KeY, VaLue ) tao::json::binding::member_u< tao::json::binding::member_kind::optional, TAO_JSON_STRING_T( KeY ), VaLue >
+#define TAO_JSON_BIND_OPTIONAL_STRING( KeY, VaLue ) tao::json::binding::member_s< tao::json::binding::member_kind::optional, TAO_JSON_STRING_T( KeY ), TAO_JSON_STRING_T( VaLue ) >
+
+#define TAO_JSON_BIND_REQUIRED1( ... ) tao::json::binding::member< tao::json::binding::member_kind::required, tao::json::binding::internal::use_default_key, __VA_ARGS__ >
+#define TAO_JSON_BIND_OPTIONAL1( ... ) tao::json::binding::member< tao::json::binding::member_kind::optional, tao::json::binding::internal::use_default_key, __VA_ARGS__ >
+
+#define TAO_JSON_FACTORY_BIND( KeY, ... ) tao::json::binding::internal::factory_temp< TAO_JSON_STRING_T( KeY ), __VA_ARGS__ >
+
+#define TAO_JSON_FACTORY_BIND1( ... ) tao::json::binding::internal::factory_temp< tao::json::binding::internal::use_default_key, __VA_ARGS__ >
+
+#endif

data/ext/third_party/json/include/tao/json/binding/constant.hpp

@@ -0,0 +1,232 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINDING_CONSTANT_HPP
+#define TAO_JSON_BINDING_CONSTANT_HPP
+
+#include <cstdint>
+#include <string>
+
+#include "../external/pegtl/internal/pegtl_string.hpp"
+#include "../internal/escape.hpp"
+#include "../internal/format.hpp"
+#include "../internal/string_t.hpp"
+#include "../message_extension.hpp"
+
+#include "element.hpp"
+#include "member_kind.hpp"
+
+#include "internal/type_key.hpp"
+
+namespace tao::json::binding
+{
+   template< bool V >
+   struct element_b
+   {
+      using value_t = bool;
+
+      template< typename C >
+      [[nodiscard]] static bool read( const C& /*unused*/ )
+      {
+         return V;
+      }
+
+      template< template< typename... > class Traits, typename C >
+      static void to( const basic_value< Traits >& v, C& /*unused*/ )
+      {
+         const auto t = v.template as< bool >();
+         if( t != V ) {
+            throw std::runtime_error( json::internal::format( "boolean mismatch, expected '", V, "' parsed '", t, '\'', json::message_extension( v ) ) );
+         }
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer, typename C >
+      static void produce( Consumer& consumer, const C& /*unused*/ )
+      {
+         consumer.boolean( V );
+      }
+
+      template< template< typename... > class Traits = traits, typename Producer, typename C >
+      static void consume( Producer& parser, C& /*unused*/ )
+      {
+         const auto t = parser.boolean();
+         if( t != V ) {
+            parser.throw_parse_error( json::internal::format( "boolean mismatch, expected '", V, "' parsed '", t, '\'' ) );
+         }
+      }
+   };
+
+   template< std::int64_t V >
+   struct element_i
+   {
+      using value_t = std::int64_t;
+
+      template< typename C >
+      [[nodiscard]] static std::int64_t read( const C& /*unused*/ )
+      {
+         return V;
+      }
+
+      template< template< typename... > class Traits, typename C >
+      static void to( const basic_value< Traits >& v, C& /*unused*/ )
+      {
+         const auto t = v.template as< std::int64_t >();
+         if( t != V ) {
+            throw std::runtime_error( json::internal::format( "signed integer mismatch, expected '", V, "' parsed '", t, '\'', json::message_extension( v ) ) );
+         }
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer, typename C >
+      static void produce( Consumer& consumer, const C& /*unused*/ )
+      {
+         consumer.number( V );
+      }
+
+      template< template< typename... > class Traits = traits, typename Producer, typename C >
+      static void consume( Producer& parser, C& /*unused*/ )
+      {
+         const auto t = parser.number_signed();
+         if( t != V ) {
+            parser.throw_parse_error( json::internal::format( "signed integer mismatch, expected '", V, "' parsed '", t, '\'' ) );
+         }
+      }
+   };
+
+   template< std::uint64_t V >
+   struct element_u
+   {
+      using value_t = std::uint64_t;
+
+      template< typename C >
+      [[nodiscard]] static std::uint64_t read( const C& /*unused*/ )
+      {
+         return V;
+      }
+
+      template< template< typename... > class Traits, typename C >
+      static void to( const basic_value< Traits >& v, C& /*unused*/ )
+      {
+         const auto t = v.template as< std::uint64_t >();
+         if( t != V ) {
+            throw std::runtime_error( json::internal::format( "unsigned integer mismatch, expected '", V, "' parsed '", t, '\'', json::message_extension( v ) ) );
+         }
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer, typename C >
+      static void produce( Consumer& consumer, const C& /*unused*/ )
+      {
+         consumer.number( V );
+      }
+
+      template< template< typename... > class Traits = traits, typename Producer, typename C >
+      static void consume( Producer& parser, C& /*unused*/ )
+      {
+         const auto t = parser.number_unsigned();
+         if( t != V ) {
+            parser.throw_parse_error( json::internal::format( "unsigned integer mismatch, expected '", V, "' parsed '", t, '\'' ) );
+         }
+      }
+   };
+
+   template< typename S >
+   struct element_s;
+
+   template< char... Cs >
+   struct element_s< json::internal::string_t< Cs... > >
+   {
+      using value_t = std::string;  // TODO: Or std::string_view? Something else? Nothing?
+
+      using string = json::internal::string_t< Cs... >;
+
+      template< typename C >
+      [[nodiscard]] static std::string_view read( const C& /*unused*/ )
+      {
+         return string::as_string_view();
+      }
+
+      template< template< typename... > class Traits, typename C >
+      static void to( const basic_value< Traits >& v, C& /*unused*/ )
+      {
+         const auto sc = string::as_string_view();
+         const auto sv = v.template as< std::string_view >();
+         if( sv != sc ) {
+            throw std::runtime_error( json::internal::format( "string mismatch, expected \"", json::internal::escape( sc ), "\" parsed \"", json::internal::escape( sv ), '"', json::message_extension( v ) ) );
+         }
+      }
+
+      template< template< typename... > class Traits = traits, typename Consumer, typename T >
+      static void produce( Consumer& consumer, const T& /*unused*/ )
+      {
+         consumer.string( string::as_string_view() );
+      }
+
+      template< template< typename... > class Traits = traits, typename Producer, typename T >
+      static void consume( Producer& parser, T& /*unused*/ )
+      {
+         const auto sc = string::as_string_view();
+         const auto ss = parser.string();
+         if( ss != sc ) {
+            parser.throw_parse_error( json::internal::format( "string mismatch, expected \"", json::internal::escape( sc ), "\" parsed \"", json::internal::escape( ss ), '"' ) );
+         }
+      }
+   };
+
+   template< member_kind R, typename K, bool B >
+   struct member_b
+      : element_b< B >,
+        internal::type_key< K, void >
+   {
+      static constexpr member_kind kind = R;
+
+      template< template< typename... > class Traits, typename T >
+      [[nodiscard]] static bool is_nothing( const T& /*unused*/ )
+      {
+         return false;
+      }
+   };
+
+   template< member_kind R, typename K, std::int64_t V >
+   struct member_i
+      : element_i< V >,
+        internal::type_key< K, void >
+   {
+      static constexpr member_kind kind = R;
+
+      template< template< typename... > class Traits, typename T >
+      [[nodiscard]] static bool is_nothing( const T& /*unused*/ )
+      {
+         return false;
+      }
+   };
+
+   template< member_kind R, typename K, std::uint64_t V >
+   struct member_u
+      : element_u< V >,
+        internal::type_key< K, void >
+   {
+      static constexpr member_kind kind = R;
+
+      template< template< typename... > class Traits, typename T >
+      [[nodiscard]] static bool is_nothing( const T& /*unused*/ )
+      {
+         return false;
+      }
+   };
+
+   template< member_kind R, typename K, typename S >
+   struct member_s
+      : element_s< S >,
+        internal::type_key< K, void >
+   {
+      static constexpr member_kind kind = R;
+
+      template< template< typename... > class Traits, typename T >
+      [[nodiscard]] static bool is_nothing( const T& /*unused*/ )
+      {
+         return false;
+      }
+   };
+
+}  // namespace tao::json::binding
+
+#endif

data/ext/third_party/json/include/tao/json/binding/element.hpp

@@ -0,0 +1,182 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_BINDING_ELEMENT_HPP
+#define TAO_JSON_BINDING_ELEMENT_HPP
+
+#include <type_traits>
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "../events/produce.hpp"
+
+namespace tao::json::binding
+{
+   namespace internal
+   {
+      template< typename T, T, typename = void >
+      struct element;
+
+      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 internal_t = std::decay_t< decltype( std::declval< C >().*P ) >;
+
+         [[nodiscard]] static const auto& read( const C& v )
+         {
+            return v.*P;
+         }
+
+         template< typename W >
+         static void write( C& v, W&& w )
+         {
+            v.*P = std::forward< W >( w );
+         }
+
+         template< template< typename... > class Traits >
+         static void to( const basic_value< Traits >& v, C& x )
+         {
+            v.to( x.*P );
+         }
+
+         template< template< typename... > class Traits = traits, typename Producer >
+         static void consume( Producer& parser, C& v )
+         {
+            json::consume< Traits >( parser, 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 >
+      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