couchbase 1.3.15 → 3.0.0.alpha.1

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

@@ -0,0 +1,306 @@
+// 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
+         {
+            using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+
+            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
+         {
+            using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+
+            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::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::integer::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::integer::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

@@ -0,0 +1,432 @@
+// 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