RubyGems - couchbase - Versions diffs - 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19 - Mend

couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

Files changed (1318) hide show

data/ext/third_party/json/include/tao/json/jaxn/internal/integer.hpp DELETED

@@ -1,255 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-#ifndef TAO_JSON_JAXN_INTERNAL_INTEGER_HPP
-#define TAO_JSON_JAXN_INTERNAL_INTEGER_HPP
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <string_view>
-#include <type_traits>
-#include "../../external/pegtl.hpp"
-#include "../../external/pegtl/contrib/integer.hpp"
-#include "../../internal/parse_util.hpp"
-namespace tao::json::jaxn::internal::integer
-{
-   struct unsigned_rule
-      : pegtl::if_then_else< pegtl::one< '0' >, pegtl::if_then_else< pegtl::one< 'x' >, pegtl::plus< pegtl::xdigit >, pegtl::not_at< pegtl::digit > >, pegtl::plus< pegtl::digit > >
-   {
-      // Unsigned hex or dec integer, no leading zeros for dec.
-   };
-   struct signed_rule
-      : pegtl::seq< pegtl::opt< pegtl::one< '-', '+' > >, unsigned_rule >
-   {
-      // Signed hex or dec integer, no leading zeros for dec.
-   };
-   [[nodiscard]] constexpr bool is_hex_digit( const char c ) noexcept
-   {
-      // We don't use std::isxdigit() because it might
-      // return true for other values on MS platforms?
-      return ( ( '0' <= c ) && ( c <= '9' ) ) || ( ( 'a' <= c ) && ( c <= 'f' ) ) || ( ( 'A' <= c ) && ( c <= 'F' ) );
-   }
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool accumulate_hex_digit( Integer& result, const char xdigit ) noexcept
-   {
-      // Assumes that xdigit is an xdigit as per is_hex_digit(); returns false on overflow.
-      static_assert( std::is_integral_v< Integer > );
-      constexpr Integer cutoff = Maximum / 16;
-      constexpr Integer cutlim = Maximum % 16;
-      const Integer c = json::internal::hex_char_to_integer< Integer >( xdigit );
-      if( ( result > cutoff ) || ( ( result == cutoff ) && ( c > cutlim ) ) ) {
-         return false;
-      }
-      result *= 16;
-      result += c;
-      return true;
-   }
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool accumulate_hex_digits( Integer& result, const std::string_view input ) noexcept
-   {
-      // Assumes input is a non-empty sequence of hex-digits; returns false on overflow.
-      for( const auto c : input ) {
-         if( !accumulate_hex_digit< Integer, Maximum >( result, c ) ) {
-            return false;
-         }
-      }
-      return true;
-   }
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool convert_hex_positive( Integer& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-      static_assert( std::is_integral_v< Integer > );
-      return accumulate_hex_digits< Integer, Maximum >( result, input );
-   }
-   template< typename Signed >
-   [[nodiscard]] constexpr bool convert_hex_negative( Signed& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-      static_assert( std::is_signed_v< Signed > );
-      using Unsigned = std::make_unsigned_t< Signed >;
-      constexpr Unsigned maximum = static_cast< Unsigned >( ( std::numeric_limits< Signed >::max )() ) + 1;
-      Unsigned temporary = 0;
-      if( accumulate_hex_digits< Unsigned, maximum >( temporary, input ) ) {
-         result = static_cast< Signed >( ~temporary ) + 1;
-         return true;
-      }
-      return false;
-   }
-   template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
-   [[nodiscard]] constexpr bool convert_hex_unsigned( Unsigned& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-      static_assert( std::is_unsigned_v< Unsigned > );
-      return accumulate_hex_digits< Unsigned, Maximum >( result, input );
-   }
-   template< typename Signed >
-   [[nodiscard]] constexpr bool convert_hex_signed( Signed& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is an optional sign followed by a "0x" and a non-empty sequence of hex-digits; returns false on overflow.
-      static_assert( std::is_signed_v< Signed > );
-      if( input[ 0 ] == '-' ) {
-         return convert_hex_negative< Signed >( result, std::string_view( input.data() + 3, input.size() - 3 ) );
-      }
-      const auto offset = unsigned( input[ 0 ] == '+' ) + 2;  // The "0x" prefix has length 2.
-      return convert_hex_positive< Signed >( result, std::string_view( input.data() + offset, input.size() - offset ) );
-   }
-   using unsigned_dec_action = pegtl::unsigned_action;
-   struct unsigned_hex_action
-   {
-      // Assumes that 'in' contains a non-empty sequence of ASCII hex-digits with "0x" prefix.
-      template< typename Input >
-      static auto apply( const Input& in, std::uint64_t& st )
-      {
-         auto sv = in.string_view();
-         sv.remove_prefix( 2 );
-         if( !convert_hex_unsigned( st, sv ) ) {
-            throw pegtl::parse_error( "unsigned hex integer overflow", in );
-         }
-      }
-   };
-   template< typename Rule >
-   struct unsigned_action_action
-      : pegtl::nothing< Rule >
-   {};
-   template<>
-   struct unsigned_action_action< pegtl::plus< pegtl::digit > >
-      : unsigned_dec_action
-   {};
-   template<>
-   struct unsigned_action_action< pegtl::plus< pegtl::xdigit > >
-   {
-      template< typename Input, typename Unsigned >
-      static void apply( const Input& in, Unsigned& st )
-      {
-         if( !convert_hex_unsigned( st, in.string_view() ) ) {
-            throw pegtl::parse_error( "unsigned hex integer overflow", in );
-         }
-      }
-   };
-   struct unsigned_rule_with_action
-   {
-      using rule_t = unsigned_rule_with_action;
-      using subs_t = pegtl::empty_list;
-      template< pegtl::apply_mode,
-                pegtl::rewind_mode,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input >
-      [[nodiscard]] static auto match( Input& in, std::uint64_t& st )
-      {
-         return pegtl::parse< unsigned_rule, unsigned_action_action >( in, st );  // Throws on overflow.
-      }
-   };
-   using signed_dec_action = pegtl::signed_action;
-   struct signed_hex_action
-   {
-      // Assumes that 'in' contains a non-empty sequence of ASCII hex-digits,
-      // with optional leading sign before the "0x" prefix; when there is a
-      // sign, in.size() must be >= 4.
-      template< typename Input >
-      static auto apply( const Input& in, std::int64_t& st )
-      {
-         if( !convert_hex_signed( st, in.string_view() ) ) {
-            throw pegtl::parse_error( "signed hex integer overflow", in );
-         }
-      }
-   };
-   template< typename Rule >
-   struct signed_action_action
-      : pegtl::nothing< Rule >
-   {};
-   template<>
-   struct signed_action_action< pegtl::one< '-', '+' > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, bool& negative, Signed& /*unused*/ )
-      {
-         negative = ( in.peek_char() == '-' );  // TODO: Optimise with custom rule to prevent building marker and action_input for single char?
-      }
-   };
-   template<>
-   struct signed_action_action< pegtl::plus< pegtl::digit > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, const bool negative, Signed& st )
-      {
-         if( !( negative ? pegtl::internal::convert_negative< Signed >( st, in.string_view() ) : pegtl::internal::convert_positive< Signed >( st, in.string_view() ) ) ) {
-            throw pegtl::parse_error( "signed dec integer overflow", in );
-         }
-      }
-   };
-   template<>
-   struct signed_action_action< pegtl::plus< pegtl::xdigit > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, const bool negative, Signed& st )
-      {
-         if( !( negative ? convert_hex_negative< Signed >( st, in.string_view() ) : convert_hex_positive< Signed >( st, in.string_view() ) ) ) {
-            throw pegtl::parse_error( "signed hex integer overflow", in );
-         }
-      }
-   };
-   struct signed_rule_with_action
-   {
-      using rule_t = signed_rule_with_action;
-      using subs_t = pegtl::empty_list;
-      template< pegtl::apply_mode,
-                pegtl::rewind_mode,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input >
-      [[nodiscard]] static auto match( Input& in, std::int64_t& st )
-      {
-         bool negative = false;                                                         // Superfluous initialisation.
-         return pegtl::parse< signed_rule, signed_action_action >( in, negative, st );  // Throws on overflow.
-      }
-   };
-}  // namespace tao::json::jaxn::internal::integer
-#endif

data/ext/third_party/json/include/tao/json/jaxn/internal/unescape_action.hpp DELETED

@@ -1,28 +0,0 @@
-// 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_JAXN_INTERNAL_UNESCAPE_ACTION_HPP
-#define TAO_JSON_JAXN_INTERNAL_UNESCAPE_ACTION_HPP
-#include "../../external/pegtl/contrib/unescape.hpp"
-#include "../../external/pegtl/nothing.hpp"
-#include "grammar.hpp"
-namespace tao::json::jaxn::internal
-{
-   // clang-format off
-   template< typename Rule > struct unescape_action : pegtl::nothing< Rule > {};
-   template<> struct unescape_action< rules::escaped_char > : pegtl::unescape::unescape_c< rules::escaped_char, '"', '\'', '\\', '/', '\b', '\f', '\n', '\r', '\t', '\v', '\0' > {};
-   template<> struct unescape_action< rules::escaped_unicode > : pegtl::unescape::unescape_j {};
-   template<> struct unescape_action< rules::escaped_unicode_code_point_content > : pegtl::unescape::unescape_u {};
-   template<> struct unescape_action< rules::identifier > : pegtl::unescape::append_all {};  // For parts_parser.
-   template< char D > struct unescape_action< rules::unescaped< D > > : pegtl::unescape::append_all {};
-   template< char D > struct unescape_action< rules::mchars< D > > : pegtl::unescape::append_all {};
-   // clang-format on
-}  // namespace tao::json::jaxn::internal
-#endif

data/ext/third_party/json/include/tao/json/jaxn/is_identifier.hpp DELETED

@@ -1,27 +0,0 @@
-// 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_JAXN_IS_IDENTIFIER_HPP
-#define TAO_JSON_JAXN_IS_IDENTIFIER_HPP
-#include <cctype>
-#include <string_view>
-namespace tao::json::jaxn
-{
-   [[nodiscard]] inline bool is_identifier( const std::string_view v ) noexcept
-   {
-      if( v.empty() || ( std::isdigit( v[ 0 ] ) != 0 ) ) {
-         return false;
-      }
-      for( const auto c : v ) {
-         if( ( std::isalnum( c ) == 0 ) && ( c != '_' ) ) {
-            return false;
-         }
-      }
-      return true;
-   }
-}  // namespace tao::json::jaxn
-#endif

data/ext/third_party/json/include/tao/json/jaxn/parts_parser.hpp DELETED

@@ -1,261 +0,0 @@
-// 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_JAXN_PARTS_PARSER_HPP
-#define TAO_JSON_JAXN_PARTS_PARSER_HPP
-#include "../parts_parser.hpp"
-#include "internal/action.hpp"
-#include "internal/bunescape_action.hpp"
-#include "internal/grammar.hpp"
-#include "internal/integer.hpp"
-#include "internal/unescape_action.hpp"
-namespace tao::json::jaxn
-{
-   namespace internal
-   {
-      namespace rules
-      {
-         struct double_rule
-         {
-            template< apply_mode A,
-                      rewind_mode M,
-                      template< typename... >
-                      class Action,
-                      template< typename... >
-                      class Control,
-                      typename Input,
-                      typename... States >
-            [[nodiscard]] static bool match_impl( Input& in, States&&... st )
-            {
-               switch( in.peek_char() ) {
-                  case '+':
-                     in.bump_in_this_line();
-                     if( in.empty() || !sor_value::match_number< false, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-                        throw pegtl::parse_error( "incomplete number", in );
-                     }
-                     return true;
-                  case '-':
-                     in.bump_in_this_line();
-                     if( in.empty() || !sor_value::match_number< true, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-                        throw pegtl::parse_error( "incomplete number", in );
-                     }
-                     return true;
-                  default:
-                     return sor_value::match_number< false, A, M, Action, Control >( in, st... );
-               }
-            }
-            template< apply_mode A,
-                      rewind_mode M,
-                      template< typename... >
-                      class Action,
-                      template< typename... >
-                      class Control,
-                      typename Input,
-                      typename... States >
-            [[nodiscard]] static bool match( Input& in, States&&... st )
-            {
-               return in.size( 2 ) && match_impl< A, M, Action, Control >( in, st... );
-            }
-         };
-      }  // namespace rules
-      template< typename Rule >
-      struct double_action
-         : action< Rule >
-      {};
-      template< bool NEG >
-      struct double_action< rules::number< NEG > >
-         : pegtl::change_states< json::internal::number_state< NEG > >
-      {
-         template< typename Input, typename Consumer >
-         static void success( const Input& /*unused*/, json::internal::number_state< NEG >& state, Consumer& consumer )
-         {
-            state.success( consumer );
-         }
-      };
-   }  // namespace internal
-   // TODO: Optimise some of the simpler cases?
-   template< typename Input = pegtl::string_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, std::string > >
-   class basic_parts_parser
-   {
-   public:
-      template< typename... Ts >
-      explicit basic_parts_parser( Ts&&... ts )
-         : m_input( std::forward< Ts >( ts )... )
-      {
-         pegtl::parse< json::internal::rules::wss >( m_input );
-      }
-      [[nodiscard]] bool empty()  // noexcept( noexcept( m_input.empty() ) )
-      {
-         return m_input.empty();
-      }
-      [[nodiscard]] bool null()
-      {
-         return pegtl::parse< pegtl::seq< json::internal::rules::kw_null, json::internal::rules::wss > >( m_input );
-      }
-      [[nodiscard]] bool boolean()
-      {
-         bool r;
-         pegtl::parse< pegtl::must< json::internal::rules::boolean, json::internal::rules::wss > >( m_input, r );
-         return r;
-      }
-      [[nodiscard]] double number_double()
-      {
-         json::internal::double_state_and_consumer st;
-         pegtl::parse< pegtl::must< internal::rules::double_rule, json::internal::rules::wss >, internal::double_action >( m_input, st );
-         return st.converted;
-      }
-      [[nodiscard]] std::int64_t number_signed()
-      {
-         std::int64_t st = 0;
-         pegtl::parse< pegtl::must< internal::integer::signed_rule_with_action, json::internal::rules::wss > >( m_input, st );
-         return st;
-      }
-      [[nodiscard]] std::uint64_t number_unsigned()
-      {
-         std::uint64_t st = 0;
-         pegtl::parse< pegtl::must< internal::integer::unsigned_rule_with_action, json::internal::rules::wss > >( m_input, st );
-         return st;
-      }
-      [[nodiscard]] std::string string()
-      {
-         std::string unescaped;
-         pegtl::parse< pegtl::must< internal::rules::string, json::internal::rules::wss >, internal::unescape_action >( m_input, unescaped );
-         return unescaped;
-      }
-      // TODO: std::string_view string_view() that only works for strings without escape sequences?
-      [[nodiscard]] std::vector< std::byte > binary()
-      {
-         std::vector< std::byte > data;
-         pegtl::parse< pegtl::must< internal::rules::binary, json::internal::rules::wss >, internal::bunescape_action >( m_input, data );
-         return data;
-      }
-      [[nodiscard]] std::string key()
-      {
-         std::string unescaped;
-         pegtl::parse< pegtl::must< internal::rules::mkey, json::internal::rules::wss, pegtl::one< ':' >, json::internal::rules::wss >, internal::unescape_action >( m_input, unescaped );
-         return unescaped;
-      }
-      // TODO: std::string_view key_view() that only works for identifiers (and possibly strings without escape sequences)?
-   protected:
-      template< char C >
-      void parse_single_must()
-      {
-         pegtl::parse< pegtl::must< pegtl::one< C >, json::internal::rules::wss > >( m_input );
-      }
-      template< char C >
-      bool parse_single_test()
-      {
-         return pegtl::parse< pegtl::seq< pegtl::one< C >, json::internal::rules::wss > >( m_input );
-      }
-      struct state_t
-      {
-         std::size_t i = 0;
-         static constexpr std::size_t* size = nullptr;
-      };
-   public:
-      [[nodiscard]] state_t begin_array()
-      {
-         parse_single_must< '[' >();
-         return state_t();
-      }
-      void end_array( state_t& /*unused*/ )
-      {
-         parse_single_must< ']' >();
-      }
-      void element( state_t& p )
-      {
-         if( p.i++ ) {
-            parse_single_must< ',' >();
-         }
-      }
-      [[nodiscard]] bool element_or_end_array( state_t& p )
-      {
-         if( parse_single_test< ']' >() ) {
-            return false;
-         }
-         element( p );
-         return true;
-      }
-      [[nodiscard]] state_t begin_object()
-      {
-         parse_single_must< '{' >();
-         return state_t();
-      }
-      void end_object( state_t& /*unused*/ )
-      {
-         parse_single_must< '}' >();
-      }
-      void member( state_t& p )
-      {
-         if( p.i++ ) {
-            parse_single_must< ',' >();
-         }
-      }
-      [[nodiscard]] bool member_or_end_object( state_t& p )
-      {
-         if( parse_single_test< '}' >() ) {
-            return false;
-         }
-         member( p );
-         return true;
-      }
-      void skip_value()
-      {
-         pegtl::parse< pegtl::must< pegtl::json::value > >( m_input );  // Includes right-padding.
-      }
-      [[nodiscard]] auto mark()  // noexcept( noexcept( m_input.template mark< pegtl::rewind_mode::required >() ) )
-      {
-         return m_input.template mark< pegtl::rewind_mode::required >();
-      }
-      template< typename T >
-      void throw_parse_error( T&& t ) const
-      {
-         throw pegtl::parse_error( std::forward< T >( t ), m_input );
-      }
-   protected:
-      Input m_input;
-   };
-   using parts_parser = basic_parts_parser<>;
-}  // namespace tao::json::jaxn
-#endif