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/parts_parser.hpp DELETED

@@ -1,302 +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_PARTS_PARSER_HPP
-#define TAO_JSON_PARTS_PARSER_HPP
-#include "external/pegtl.hpp"
-#include "external/pegtl/contrib/integer.hpp"
-#include "external/pegtl/contrib/json.hpp"
-#include "internal/action.hpp"
-#include "internal/format.hpp"
-#include "internal/grammar.hpp"
-#include "internal/number_state.hpp"
-#include "internal/unescape_action.hpp"
-namespace tao::json
-{
-   namespace internal
-   {
-      namespace rules
-      {
-         struct wss
-            : pegtl::star< ws >
-         {};
-         struct boolean
-         {
-            template< pegtl::apply_mode,
-                      pegtl::rewind_mode,
-                      template< typename... >
-                      class,
-                      template< typename... >
-                      class,
-                      typename Input >
-            [[nodiscard]] static bool match( Input& in, bool& st ) noexcept( noexcept( in.size( 5 ) ) )
-            {
-               const auto s = in.size( 5 );
-               if( s >= 5 ) {
-                  if( std::memcmp( in.current(), "false", 5 ) == 0 ) {
-                     in.bump_in_this_line( 5 );
-                     st = false;
-                     return true;
-                  }
-               }
-               if( s >= 4 ) {
-                  if( std::memcmp( in.current(), "true", 4 ) == 0 ) {
-                     in.bump_in_this_line( 4 );
-                     st = true;
-                     return true;
-                  }
-               }
-               return false;
-            }
-         };
-         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< 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< number_state< NEG > >
-      {
-         template< typename Input, typename Consumer >
-         static void success( const Input& /*unused*/, number_state< NEG >& state, Consumer& consumer )
-         {
-            state.success( consumer );
-         }
-      };
-      struct double_state_and_consumer
-      {
-         void number( const double d )
-         {
-            converted = d;
-         }
-         void number( const std::int64_t i )
-         {
-            converted = double( i );
-         }
-         void number( const std::uint64_t u )
-         {
-            converted = double( u );
-         }
-         double converted = 0.0;  // TODO: Remove superfluous initialisation when we manage to shup up the warnings on all compilers.
-      };
-   }  // 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< internal::rules::wss >( m_input );
-      }
-      [[nodiscard]] bool empty()
-      {
-         return m_input.empty();
-      }
-      [[nodiscard]] bool null()
-      {
-         return pegtl::parse< pegtl::seq< internal::rules::kw_null, internal::rules::wss > >( m_input );
-      }
-      [[nodiscard]] bool boolean()
-      {
-         bool r;
-         pegtl::parse< pegtl::must< internal::rules::boolean, internal::rules::wss > >( m_input, r );
-         return r;
-      }
-      [[nodiscard]] double number_double()
-      {
-         internal::double_state_and_consumer st;
-         pegtl::parse< pegtl::must< internal::rules::double_rule, internal::rules::wss >, internal::double_action >( m_input, st );
-         return st.converted;
-      }
-      [[nodiscard]] std::int64_t number_signed()
-      {
-         std::int64_t st = 0;  // TODO: Remove superfluous initialisation when we manage to shup up the warnings on all compilers.
-         pegtl::parse< pegtl::must< pegtl::signed_rule_with_action, internal::rules::wss > >( m_input, st );
-         return st;
-      }
-      [[nodiscard]] std::uint64_t number_unsigned()
-      {
-         std::uint64_t st = 0;  // TODO: Remove superfluous initialisation when we manage to shup up the warnings on all compilers.
-         pegtl::parse< pegtl::must< pegtl::unsigned_rule_with_action, internal::rules::wss > >( m_input, st );
-         return st;
-      }
-      [[nodiscard]] std::string string()
-      {
-         std::string unescaped;
-         pegtl::parse< pegtl::must< internal::rules::string, internal::rules::wss >, internal::unescape_action >( m_input, unescaped );
-         return unescaped;
-      }
-      [[nodiscard]] std::vector< std::byte > binary()
-      {
-         throw std::runtime_error( "json format does not support binary" );
-      }
-      [[nodiscard]] std::string key()
-      {
-         std::string unescaped;
-         pegtl::parse< pegtl::must< internal::rules::string, internal::rules::wss, pegtl::one< ':' >, internal::rules::wss >, internal::unescape_action >( m_input, unescaped );
-         return unescaped;
-      }
-      template< char C >
-      void parse_single_must()
-      {
-         pegtl::parse< pegtl::must< pegtl::one< C >, internal::rules::wss > >( m_input );
-      }
-      template< char C >
-      [[nodiscard]] bool parse_single_test()
-      {
-         return pegtl::parse< pegtl::seq< pegtl::one< C >, internal::rules::wss > >( m_input );
-      }
-      struct state_t
-      {
-         std::size_t i = 0;
-         static constexpr std::size_t* size = nullptr;
-      };
-      [[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 standard JSON right-padding.
-      }
-      [[nodiscard]] auto mark()
-      {
-         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
-#endif

data/ext/third_party/json/include/tao/json/pointer.hpp DELETED

@@ -1,432 +0,0 @@
-// 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_POINTER_HPP
-#define TAO_JSON_POINTER_HPP
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-#include "type.hpp"
-#include "external/pegtl.hpp"
-#include "internal/format.hpp"
-namespace tao::json
-{
-   namespace internal
-   {
-      template< std::size_t = sizeof( std::size_t ) >
-      struct token_to_index;
-      template<>
-      struct token_to_index< 4 >
-      {
-         [[nodiscard]] static std::size_t convert( const std::string& key ) noexcept
-         {
-            if( !key.empty() && key.size() <= 10 ) {
-               if( key == "0" ) {
-                  return 0;
-               }
-               if( ( key[ 0 ] != '0' ) && ( key.find_first_not_of( "0123456789" ) == std::string::npos ) ) {
-                  if( key.size() < 10 || key < "4294967296" ) {
-                     return static_cast< std::size_t >( std::stoul( key ) );
-                  }
-               }
-            }
-            return std::string::npos;
-         }
-      };
-      template<>
-      struct token_to_index< 8 >
-      {
-         [[nodiscard]] static std::size_t convert( const std::string& key ) noexcept
-         {
-            if( !key.empty() && key.size() <= 20 ) {
-               if( key == "0" ) {
-                  return 0;
-               }
-               if( ( key[ 0 ] != '0' ) && ( key.find_first_not_of( "0123456789" ) == std::string::npos ) ) {
-                  if( key.size() < 20 || key < "18446744073709551616" ) {
-                     return static_cast< std::size_t >( std::stoull( key ) );
-                  }
-               }
-            }
-            return std::string::npos;
-         }
-      };
-   }  // namespace internal
-   // RFC 6901
-   class token
-   {
-   private:
-      std::size_t m_index;
-      std::string m_key;
-   public:
-      explicit token( const std::string& in_key )
-         : m_index( internal::token_to_index<>::convert( in_key ) ),
-           m_key( in_key )
-      {}
-      explicit token( std::string&& in_key ) noexcept
-         : m_index( internal::token_to_index<>::convert( in_key ) ),
-           m_key( std::move( in_key ) )
-      {}
-      explicit token( const std::size_t in_index )
-         : m_index( in_index ),
-           m_key( std::to_string( m_index ) )
-      {}
-      token( const token& ) = default;
-      token( token&& v ) noexcept
-         : m_index( v.m_index ),
-           m_key( std::move( v.m_key ) )
-      {}
-      ~token() = default;
-      token& operator=( const token& ) = default;
-      token& operator=( token&& v ) noexcept
-      {
-         m_index = v.m_index;
-         m_key = std::move( v.m_key );
-         return *this;
-      }
-      [[nodiscard]] bool has_index() const noexcept
-      {
-         return m_index != std::string::npos;
-      }
-      [[nodiscard]] const std::string& key() const noexcept
-      {
-         return m_key;
-      }
-      [[nodiscard]] std::size_t index() const
-      {
-         if( !has_index() ) {
-            throw std::invalid_argument( internal::format( "unable to resolve json pointer with array, token '", m_key, "' is not an index" ) );
-         }
-         return m_index;
-      }
-      [[nodiscard]] friend bool operator==( const token& lhs, const token& rhs ) noexcept
-      {
-         return lhs.m_key == rhs.m_key;
-      }
-      [[nodiscard]] friend bool operator<( const token& lhs, const token& rhs ) noexcept
-      {
-         return lhs.m_key < rhs.m_key;
-      }
-   };
-   namespace internal
-   {
-      // clang-format off
-      struct pointer_zero : pegtl::one< '0' > {};
-      struct pointer_one : pegtl::one< '1' > {};
-      struct pointer_tilde : pegtl::one< '~' > {};
-      struct pointer_escaped : pegtl::sor< pointer_zero, pointer_one > {};
-      struct pointer_slash : pegtl::one< '/' > {};
-      struct pointer_char : pegtl::utf8::not_one< '/' > {};
-      struct pointer_escape : pegtl::if_must< pointer_tilde, pointer_escaped > {};
-      struct pointer_token : pegtl::star< pegtl::sor< pointer_escape, pointer_char > > {};
-      struct pointer_rule : pegtl::until< pegtl::eof, pegtl::must< pointer_slash, pointer_token > > {};
-      struct pointer_grammar : pegtl::must< pointer_rule > {};
-      // clang-format on
-      template< typename Rule >
-      struct pointer_action
-         : pegtl::nothing< Rule >
-      {};
-      template<>
-      struct pointer_action< pointer_zero >
-      {
-         static void apply0( std::vector< token >& /*unused*/, std::string& t )
-         {
-            t += '~';
-         }
-      };
-      template<>
-      struct pointer_action< pointer_one >
-      {
-         static void apply0( std::vector< token >& /*unused*/, std::string& t )
-         {
-            t += '/';
-         }
-      };
-      template<>
-      struct pointer_action< pointer_char >
-      {
-         template< typename Input >
-         static void apply( const Input& in, std::vector< token >& /*unused*/, std::string& t )
-         {
-            t.append( in.begin(), in.size() );
-         }
-      };
-      template<>
-      struct pointer_action< pointer_token >
-      {
-         static void apply0( std::vector< token >& v, std::string& t )
-         {
-            v.emplace_back( std::move( t ) );
-            t.clear();
-         }
-      };
-   }  // namespace internal
-   class pointer
-      : public std::vector< token >
-   {
-   private:
-      void parse( const std::string& v )
-      {
-         std::string t;
-         pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( v, "parse()" );
-         pegtl::parse< internal::pointer_grammar, internal::pointer_action >( in, vector(), t );
-      }
-   public:
-      pointer() = default;
-      pointer( const pointer& ) = default;
-      pointer( pointer&& p ) = default;
-      explicit pointer( const std::string& v )
-      {
-         parse( v );
-      }
-      pointer( const std::initializer_list< token >& l )
-         : std::vector< token >( l )
-      {}
-      ~pointer() = default;
-      pointer& operator=( const pointer& ) = default;
-      pointer& operator=( pointer&& p ) = default;
-      pointer& operator=( const std::string& v )
-      {
-         clear();
-         parse( v );
-         return *this;
-      }
-      pointer& operator=( const std::initializer_list< token >& l )
-      {
-         vector() = l;
-         return *this;
-      }
-      [[nodiscard]] explicit operator bool() const noexcept
-      {
-         return !empty();
-      }
-      void push_back() = delete;
-      void pop_back()
-      {
-         assert( !empty() );
-         vector().pop_back();
-      }
-      [[nodiscard]] bool is_prefix_of( const pointer& other ) const noexcept
-      {
-         if( other.size() >= size() ) {
-            return std::equal( begin(), end(), other.begin() );
-         }
-         return false;
-      }
-      [[nodiscard]] std::vector< token >& vector() noexcept
-      {
-         return static_cast< std::vector< token >& >( *this );
-      }
-      [[nodiscard]] const std::vector< token >& vector() const noexcept
-      {
-         return static_cast< const std::vector< token >& >( *this );
-      }
-   };
-   [[nodiscard]] inline bool operator==( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return lhs.vector() == rhs.vector();
-   }
-   [[nodiscard]] inline bool operator<( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return lhs.vector() < rhs.vector();
-   }
-   [[nodiscard]] inline bool operator!=( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return !( lhs == rhs );
-   }
-   [[nodiscard]] inline bool operator>( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return rhs < lhs;
-   }
-   [[nodiscard]] inline bool operator<=( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return !( rhs < lhs );
-   }
-   [[nodiscard]] inline bool operator>=( const pointer& lhs, const pointer& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-   inline pointer& operator+=( pointer& lhs, const std::string& rhs )
-   {
-      lhs.emplace_back( rhs );
-      return lhs;
-   }
-   inline pointer& operator+=( pointer& lhs, std::string&& rhs )
-   {
-      lhs.emplace_back( std::move( rhs ) );
-      return lhs;
-   }
-   inline pointer& operator+=( pointer& lhs, const std::size_t rhs )
-   {
-      lhs.emplace_back( rhs );
-      return lhs;
-   }
-   [[nodiscard]] inline pointer operator+( const pointer& p, const std::string& v )
-   {
-      pointer nrv( p );
-      nrv += v;
-      return nrv;
-   }
-   [[nodiscard]] inline pointer operator+( const pointer& p, std::string&& v )
-   {
-      pointer nrv( p );
-      nrv += std::move( v );
-      return nrv;
-   }
-   [[nodiscard]] inline pointer operator+( const pointer& p, const std::size_t i )
-   {
-      pointer nrv( p );
-      nrv += i;
-      return nrv;
-   }
-   namespace internal
-   {
-      [[nodiscard]] inline std::string tokens_to_string( std::vector< token >::const_iterator it, const std::vector< token >::const_iterator& end )
-      {
-         std::string result;
-         while( it != end ) {
-            result += '/';
-            for( const char c : it->key() ) {
-               switch( c ) {
-                  case '~':
-                     result += "~0";
-                     break;
-                  case '/':
-                     result += "~1";
-                     break;
-                  default:
-                     result += c;
-               }
-            }
-            ++it;
-         }
-         return result;
-      }
-      [[nodiscard]] inline std::runtime_error invalid_type( const std::vector< token >::const_iterator& begin, const std::vector< token >::const_iterator& end )
-      {
-         return std::runtime_error( internal::format( "unable to resolve JSON Pointer '", tokens_to_string( begin, end ), "' -- value type is neither 'object' nor 'array'" ) );
-      }
-      template< typename T >
-      [[nodiscard]] T& pointer_at( T* v, const std::vector< token >::const_iterator& begin, const std::vector< token >::const_iterator& end )
-      {
-         for( auto it = begin; it != end; ++it ) {
-            switch( v->type() ) {
-               case type::ARRAY:
-                  v = &v->at( it->index() );
-                  break;
-               case type::OBJECT:
-                  v = &v->at( it->key() );
-                  break;
-               default:
-                  throw invalid_type( begin, std::next( it ) );
-            }
-         }
-         return *v;
-      }
-      template< typename T >
-      [[nodiscard]] T* pointer_find( T* v, const std::vector< token >::const_iterator& begin, const std::vector< token >::const_iterator& end )
-      {
-         for( auto it = begin; v && ( it != end ); ++it ) {
-            switch( v->type() ) {
-               case type::ARRAY:
-                  v = v->find( it->index() );
-                  break;
-               case type::OBJECT:
-                  v = v->find( it->key() );
-                  break;
-               default:
-                  throw invalid_type( begin, std::next( it ) );
-            }
-         }
-         return v;
-      }
-   }  // namespace internal
-   [[nodiscard]] inline std::string to_string( const pointer& p )
-   {
-      return internal::tokens_to_string( p.begin(), p.end() );
-   }
-   [[nodiscard]] inline std::string to_string( pointer& p )
-   {
-      return internal::tokens_to_string( p.begin(), p.end() );
-   }
-   [[nodiscard]] inline std::string to_string( pointer&& p )
-   {
-      return internal::tokens_to_string( p.begin(), p.end() );
-   }
-   inline namespace literals
-   {
-      [[nodiscard]] inline pointer operator"" _json_pointer( const char* data, const std::size_t size )
-      {
-         return pointer( { data, size } );
-      }
-   }  // namespace literals
-}  // namespace tao::json
-#endif