couchbase 3.0.3-universal-darwin-20

data/ext/third_party/json/include/tao/json/internal/hexdump.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_INTERNAL_HEXDUMP_HPP
+#define TAO_JSON_INTERNAL_HEXDUMP_HPP
+
+#include <sstream>
+
+namespace tao::json::internal
+{
+   template< typename T >
+   void hexdump( std::ostream& os, const T& v )
+   {
+      static const char h[] = "0123456789ABCDEF";
+      for( const auto b : v ) {
+         os.put( h[ static_cast< unsigned char >( b ) >> 4 ] );
+         os.put( h[ static_cast< unsigned char >( b ) & 0xF ] );
+      }
+   }
+
+   template< typename T >
+   [[nodiscard]] std::string hexdump( const T& v )
+   {
+      std::ostringstream os;
+      internal::hexdump( os, v );
+      return os.str();
+   }
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/internal/identity.hpp

@@ -0,0 +1,22 @@
+// 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_INTERNAL_IDENTITY_HPP
+#define TAO_JSON_INTERNAL_IDENTITY_HPP
+
+#include <type_traits>
+
+namespace tao::internal
+{
+   template< typename T >
+   struct identity
+   {
+      using type = T;
+   };
+
+   template< typename T >
+   using identity_t = typename identity< T >::type;
+
+}  // namespace tao::internal
+
+#endif

data/ext/third_party/json/include/tao/json/internal/number_state.hpp

@@ -0,0 +1,80 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_NUMBER_STATE_HPP
+#define TAO_JSON_INTERNAL_NUMBER_STATE_HPP
+
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <stdexcept>
+
+#include "../external/double.hpp"
+
+namespace tao::json::internal
+{
+   static const std::size_t max_mantissa_digits = 772;
+
+   template< bool NEG >
+   struct number_state
+   {
+      using exponent10_t = std::int32_t;
+      using msize_t = std::uint16_t;
+
+      number_state() = default;
+
+      number_state( const number_state& ) = delete;
+      number_state( number_state&& ) = delete;
+
+      ~number_state() = default;
+
+      void operator=( const number_state& ) = delete;
+      void operator=( number_state&& ) = delete;
+
+      exponent10_t exponent10 = 0;
+      msize_t msize = 0;  // Excluding sign.
+      bool isfp = false;
+      bool eneg = false;
+      bool drop = false;
+      char mantissa[ max_mantissa_digits + 1 ];
+
+      template< typename Consumer >
+      void success( Consumer& consumer )
+      {
+         if( !isfp && msize <= 20 ) {
+            mantissa[ msize ] = 0;
+            char* p;
+            errno = 0;
+            const std::uint64_t ull = std::strtoull( mantissa, &p, 10 );
+            if( ( errno != ERANGE ) && ( p == mantissa + msize ) ) {
+               if constexpr( NEG ) {
+                  if( ull < 9223372036854775808ULL ) {
+                     consumer.number( -static_cast< std::int64_t >( ull ) );
+                     return;
+                  }
+                  if( ull == 9223372036854775808ULL ) {
+                     consumer.number( static_cast< std::int64_t >( -9223372036854775807LL - 1 ) );
+                     return;
+                  }
+               }
+               else {
+                  consumer.number( ull );
+                  return;
+               }
+            }
+         }
+         if( drop ) {
+            mantissa[ msize++ ] = '1';
+            --exponent10;
+         }
+         const auto d = double_conversion::Strtod( double_conversion::Vector< const char >( mantissa, msize ), exponent10 );
+         if( !std::isfinite( d ) ) {
+            throw std::runtime_error( "invalid double value" );
+         }
+         consumer.number( NEG ? -d : d );
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/internal/number_traits.hpp

@@ -0,0 +1,267 @@
+// 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_INTERNAL_NUMBER_TRAITS_HPP
+#define TAO_JSON_INTERNAL_NUMBER_TRAITS_HPP
+
+#include <cstdint>
+#include <stdexcept>
+
+#include "../forward.hpp"
+#include "../message_extension.hpp"
+#include "../type.hpp"
+
+#include "format.hpp"
+
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4702 )
+#endif
+
+namespace tao::json::internal
+{
+   template< typename T >
+   struct number_trait
+   {
+      template< template< typename... > class Traits >
+      [[nodiscard]] static T as( const basic_value< Traits >& v )
+      {
+         switch( v.type() ) {
+            case type::SIGNED:
+               return static_cast< T >( v.get_signed() );
+            case type::UNSIGNED:
+               return static_cast< T >( v.get_unsigned() );
+            case type::DOUBLE:
+               return static_cast< T >( v.get_double() );
+            default:
+               throw std::logic_error( internal::format( "invalid json type '", v.type(), "' for conversion to number", json::message_extension( v ) ) );
+         }
+      }
+   };
+
+   template< typename T >
+   struct signed_trait
+      : number_trait< T >
+   {
+      template< template< typename... > class, typename Parts >
+      [[nodiscard]] static T consume( Parts& parser )
+      {
+         return static_cast< T >( parser.number_signed() );
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T i )
+      {
+         c.number( std::int64_t( i ) );
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T i ) noexcept
+      {
+         v.set_signed( i );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() == rhs;
+            case type::UNSIGNED:
+               return ( rhs >= 0 ) && ( p.get_unsigned() == static_cast< std::uint64_t >( rhs ) );
+            case type::DOUBLE:
+               return p.get_double() == rhs;
+            default:
+               return false;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() < rhs;
+            case type::UNSIGNED:
+               return ( rhs >= 0 ) && ( p.get_unsigned() < static_cast< std::uint64_t >( rhs ) );
+            case type::DOUBLE:
+               return p.get_double() < rhs;
+            default:
+               return p.type() < type::SIGNED;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() > rhs;
+            case type::UNSIGNED:
+               return ( rhs < 0 ) || ( p.get_unsigned() > static_cast< std::uint64_t >( rhs ) );
+            case type::DOUBLE:
+               return p.get_double() > rhs;
+            default:
+               return p.type() > type::SIGNED;
+         }
+      }
+   };
+
+   template< typename T >
+   struct unsigned_trait
+      : number_trait< T >
+   {
+      template< template< typename... > class, typename Parts >
+      [[nodiscard]] static T consume( Parts& parser )
+      {
+         return static_cast< T >( parser.number_unsigned() );
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T i )
+      {
+         c.number( std::uint64_t( i ) );
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T i ) noexcept
+      {
+         v.set_unsigned( i );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED: {
+               const auto v = p.get_signed();
+               return ( v >= 0 ) && ( static_cast< std::uint64_t >( v ) == rhs );
+            }
+            case type::UNSIGNED:
+               return p.get_unsigned() == rhs;
+            case type::DOUBLE:
+               return p.get_double() == rhs;
+            default:
+               return false;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED: {
+               const auto v = p.get_signed();
+               return ( v < 0 ) || ( static_cast< std::uint64_t >( v ) < rhs );
+            }
+            case type::UNSIGNED:
+               return p.get_unsigned() < rhs;
+            case type::DOUBLE:
+               return p.get_double() < rhs;
+            default:
+               return p.type() < type::UNSIGNED;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED: {
+               const auto v = p.get_signed();
+               return ( v >= 0 ) && ( static_cast< std::uint64_t >( v ) > rhs );
+            }
+            case type::UNSIGNED:
+               return p.get_unsigned() > rhs;
+            case type::DOUBLE:
+               return p.get_double() > rhs;
+            default:
+               return p.type() > type::UNSIGNED;
+         }
+      }
+   };
+
+   template< typename T >
+   struct float_trait
+      : number_trait< T >
+   {
+      template< template< typename... > class, typename Parts >
+      [[nodiscard]] static T consume( Parts& parser )
+      {
+         return static_cast< T >( parser.number_double() );
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T f )
+      {
+         c.number( double( f ) );
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T f ) noexcept
+      {
+         v.set_double( f );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() == rhs;
+            case type::UNSIGNED:
+               return p.get_unsigned() == rhs;
+            case type::DOUBLE:
+               return p.get_double() == rhs;  // TODO: Is it ok for overall semantics that NaN != NaN?
+            default:
+               return false;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() < rhs;
+            case type::UNSIGNED:
+               return p.get_unsigned() < rhs;
+            case type::DOUBLE:
+               return p.get_double() < rhs;
+            default:
+               return p.type() < type::DOUBLE;
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         switch( p.type() ) {
+            case type::SIGNED:
+               return p.get_signed() > rhs;
+            case type::UNSIGNED:
+               return p.get_unsigned() > rhs;
+            case type::DOUBLE:
+               return p.get_double() > rhs;
+            default:
+               return p.type() > type::DOUBLE;
+         }
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+#endif

data/ext/third_party/json/include/tao/json/internal/pair.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_PAIR_HPP
+#define TAO_JSON_INTERNAL_PAIR_HPP
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "../forward.hpp"
+
+namespace tao::json::internal
+{
+   template< template< typename... > class Traits >
+   struct pair
+   {
+      mutable std::string key;
+      mutable basic_value< Traits > value;
+
+      template< typename U >
+      pair( U&& v )  // NOLINT(bugprone-forwarding-reference-overload)
+         : key( Traits< std::decay_t< U > >::template default_key< Traits >::as_string() ),
+           value( std::forward< U >( v ) )
+      {}
+
+      template< typename U >
+      pair( U&& k, basic_value< Traits >&& v )
+         : key( std::forward< U >( k ) ),
+           value( std::move( v ) )
+      {}
+
+      template< typename U >
+      pair( U&& k, const basic_value< Traits >& v )
+         : key( std::forward< U >( k ) ),
+           value( v )
+      {}
+   };
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/internal/parse_util.hpp

@@ -0,0 +1,112 @@
+// 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_INTERNAL_PARSE_UTIL_HPP
+#define TAO_JSON_INTERNAL_PARSE_UTIL_HPP
+
+#include <cassert>
+
+#include "../external/pegtl/parse_error.hpp"
+#include "../utf8.hpp"
+
+#include "endian.hpp"
+#include "format.hpp"
+
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4702 )
+#endif
+
+namespace tao::json::internal
+{
+   template< typename Input >
+   void throw_on_empty( Input& in )
+   {
+      if( in.empty() ) {
+         throw pegtl::parse_error( format( "unexpected end of input" ), in );
+      }
+   }
+
+   template< typename Input >
+   void throw_on_empty( Input& in, const std::size_t required )
+   {
+      const auto available = in.size( required );
+      if( available < required ) {
+         throw pegtl::parse_error( format( "unexpected end of input -- required ", required, " available ", available ), in );
+      }
+   }
+
+   template< typename Input >
+   [[nodiscard]] std::uint8_t peek_uint8( Input& in )
+   {
+      throw_on_empty( in );
+      return in.peek_uint8();
+   }
+
+   template< typename Input >
+   [[nodiscard]] char peek_char( Input& in )
+   {
+      throw_on_empty( in );
+      return in.peek_char();
+   }
+
+   template< typename Input >
+   [[nodiscard]] char read_char_unsafe( Input& in )
+   {
+      const auto r = in.peek_char();
+      in.bump_in_this_line( 1 );
+      return r;
+   }
+
+   template< typename Input >
+   [[nodiscard]] char read_char( Input& in )
+   {
+      throw_on_empty( in );
+      return read_char_unsafe( in );
+   }
+
+   template< utf8_mode U, typename Result, typename Input >
+   [[nodiscard]] Result read_string( Input& in, const std::size_t size )
+   {
+      using value_t = typename Result::value_type;
+      json::internal::throw_on_empty( in, size );
+      const auto* pointer = reinterpret_cast< const value_t* >( in.current() );
+      const Result result( pointer, size );
+      json::internal::consume_utf8_throws< U >( in, size );
+      return result;
+   }
+
+   template< typename Result, typename Number = Result, typename Input >
+   [[nodiscard]] Result read_big_endian_number( Input& in, const std::size_t extra = 0 )
+   {
+      throw_on_empty( in, extra + sizeof( Number ) );
+      const auto result = static_cast< Result >( be_to_h< Number >( in.current() + extra ) );
+      in.bump_in_this_line( extra + sizeof( Number ) );
+      return result;
+   }
+
+   template< typename Integer >
+   [[nodiscard]] Integer hex_char_to_integer( const char c ) noexcept
+   {
+      if( ( '0' <= c ) && ( c <= '9' ) ) {
+         return static_cast< Integer >( c - '0' );
+      }
+      if( ( 'a' <= c ) && ( c <= 'f' ) ) {
+         return static_cast< Integer >( c - 'a' + 10 );
+      }
+      if( ( 'A' <= c ) && ( c <= 'F' ) ) {
+         return static_cast< Integer >( c - 'A' + 10 );
+      }
+      // LCOV_EXCL_START
+      assert( false );
+      return 0;
+      // LCOV_EXCL_STOP
+   }
+
+}  // namespace tao::json::internal
+
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+#endif