couchbase 3.0.0 → 3.0.1

data/ext/third_party/json/include/tao/json/external/pegtl/read_input.hpp

@@ -4,6 +4,7 @@
 #ifndef TAO_JSON_PEGTL_READ_INPUT_HPP
 #define TAO_JSON_PEGTL_READ_INPUT_HPP
 
+#include <filesystem>
 #include <string>
 
 #include "config.hpp"
@@ -12,50 +13,29 @@
 #include "tracking_mode.hpp"
 
 #include "internal/file_reader.hpp"
+#include "internal/path_to_string.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
-   namespace internal
-   {
-      struct filename_holder
-      {
-         const std::string filename;
-
-         template< typename T >
-         explicit filename_holder( T&& in_filename )
-            : filename( std::forward< T >( in_filename ) )
-         {
-         }
-
-         filename_holder( const filename_holder& ) = delete;
-         filename_holder( filename_holder&& ) = delete;
-
-         ~filename_holder() = default;
-
-         void operator=( const filename_holder& ) = delete;
-         void operator=( filename_holder&& ) = delete;
-      };
-
-   }  // namespace internal
-
    template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
    struct read_input
-      : private internal::filename_holder,
-        public string_input< P, Eol, const char* >
+      : string_input< P, Eol >
    {
-      template< typename T >
-      explicit read_input( T&& in_filename )
-         : internal::filename_holder( std::forward< T >( in_filename ) ),
-           string_input< P, Eol, const char* >( internal::file_reader( filename.c_str() ).read(), filename.c_str() )
-      {
-      }
+      read_input( const std::filesystem::path& path, const std::string& source )
+         : string_input< P, Eol >( internal::file_reader( path ).read(), source )
+      {}
+
+      explicit read_input( const std::filesystem::path& path )
+         : read_input( path, internal::path_to_string( path ) )
+      {}
+
+      read_input( FILE* file, const std::filesystem::path& path, const std::string& source )
+         : string_input< P, Eol >( internal::file_reader( file, path ).read(), source )
+      {}
 
-      template< typename T >
-      read_input( FILE* in_file, T&& in_filename )
-         : internal::filename_holder( std::forward< T >( in_filename ) ),
-           string_input< P, Eol, const char* >( internal::file_reader( in_file, filename.c_str() ).read(), filename.c_str() )
-      {
-      }
+      read_input( FILE* file, const std::filesystem::path& path )
+         : read_input( file, path, internal::path_to_string( path ) )
+      {}
 
       read_input( const read_input& ) = delete;
       read_input( read_input&& ) = delete;
@@ -67,7 +47,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    };
 
    template< typename... Ts >
-   explicit read_input( Ts&&... )->read_input<>;
+   explicit read_input( Ts&&... ) -> read_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

data/ext/third_party/json/include/tao/json/external/pegtl/rules.hpp

@@ -12,9 +12,9 @@
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
    // clang-format off
+   template< template< typename... > class Action, typename... Rules > struct action : internal::action< Action, Rules... > {};
    template< typename... Actions > struct apply : internal::apply< Actions... > {};
    template< typename... Actions > struct apply0 : internal::apply0< Actions... > {};
-   template< template< typename... > class Action, typename... Rules > struct action : internal::action< Action, Rules... > {};
    template< typename... Rules > struct at : internal::at< Rules... > {};
    struct bof : internal::bof {};
    struct bol : internal::bol {};
@@ -24,7 +24,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    struct discard : internal::discard {};
    template< typename... Rules > struct enable : internal::enable< Rules... > {};
    struct eof : internal::eof {};
-   struct failure : internal::trivial< false > {};
+   struct eolf : internal::eolf {};
+   struct failure : internal::failure {};
    template< typename Rule, typename... Actions > struct if_apply : internal::if_apply< Rule, Actions... > {};
    template< typename Cond, typename... Thens > struct if_must : internal::if_must< false, Cond, Thens... > {};
    template< typename Cond, typename Then, typename Else > struct if_must_else : internal::if_must_else< Cond, Then, Else > {};
@@ -35,7 +36,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    template< typename Rule, typename Sep > struct list_must< Rule, Sep, void > : internal::list_must< Rule, Sep > {};
    template< typename Rule, typename Sep, typename Pad = void > struct list_tail : internal::list_tail_pad< Rule, Sep, Pad > {};
    template< typename Rule, typename Sep > struct list_tail< Rule, Sep, void > : internal::list_tail< Rule, Sep > {};
-   template< typename M, typename S > struct minus : internal::rematch< M, internal::not_at< S, internal::eof > > {};
+   template< typename M, typename S > struct minus : internal::minus< M, S > {};
    template< typename... Rules > struct must : internal::must< Rules... > {};
    template< typename... Rules > struct not_at : internal::not_at< Rules... > {};
    template< typename... Rules > struct opt : internal::opt< Rules... > {};
@@ -56,9 +57,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    template< typename Rule, typename... Rules > struct star : internal::star< Rule, Rules... > {};
    template< typename Cond, typename... Rules > struct star_must : internal::star_must< Cond, Rules... > {};
    template< typename State, typename... Rules > struct state : internal::state< State, Rules... > {};
-   struct success : internal::trivial< true > {};
+   struct success : internal::success {};
    template< typename... Rules > struct try_catch : internal::try_catch_type< parse_error, Rules... > {};
-   template< typename Exception, typename... Rules > struct try_catch_type : internal::try_catch_type< Exception, Rules... > {};
+   template< typename Exception, typename... Rules > struct try_catch_type : internal::seq< internal::try_catch_type< Exception, Rules... > > {};
    template< typename Cond, typename... Rules > struct until : internal::until< Cond, Rules... > {};
    // clang-format on
 

data/ext/third_party/json/include/tao/json/external/pegtl/string_input.hpp

@@ -23,8 +23,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          template< typename T >
          explicit string_holder( T&& in_data )
             : data( std::forward< T >( in_data ) )
-         {
-         }
+         {}
 
          string_holder( const string_holder& ) = delete;
          string_holder( string_holder&& ) = delete;
@@ -46,8 +45,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       explicit string_input( V&& in_data, T&& in_source, Ts&&... ts )
          : internal::string_holder( std::forward< V >( in_data ) ),
            memory_input< P, Eol, Source >( data.data(), data.size(), std::forward< T >( in_source ), std::forward< Ts >( ts )... )
-      {
-      }
+      {}
 
       string_input( const string_input& ) = delete;
       string_input( string_input&& ) = delete;
@@ -59,7 +57,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    };
 
    template< typename... Ts >
-   explicit string_input( Ts&&... )->string_input<>;
+   explicit string_input( Ts&&... ) -> string_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

data/ext/third_party/json/include/tao/json/external/pegtl/type_list.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_TYPE_LIST_HPP
+#define TAO_JSON_PEGTL_TYPE_LIST_HPP
+
+#include <cstddef>
+
+#include "config.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   template< typename... Ts >
+   struct type_list
+   {
+      static constexpr std::size_t size = sizeof...( Ts );
+   };
+
+   using empty_list = type_list<>;
+
+   template< typename... >
+   struct type_list_concat;
+
+   template<>
+   struct type_list_concat<>
+   {
+      using type = empty_list;
+   };
+
+   template< typename... Ts >
+   struct type_list_concat< type_list< Ts... > >
+   {
+      using type = type_list< Ts... >;
+   };
+
+   template< typename... T0s, typename... T1s, typename... Ts >
+   struct type_list_concat< type_list< T0s... >, type_list< T1s... >, Ts... >
+      : type_list_concat< type_list< T0s..., T1s... >, Ts... >
+   {};
+
+   template< typename... Ts >
+   using type_list_concat_t = typename type_list_concat< Ts... >::type;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/visit.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_VISIT_HPP
+#define TAO_JSON_PEGTL_VISIT_HPP
+
+#include <type_traits>
+
+#include "config.hpp"
+#include "type_list.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< typename Type, typename... Types >
+      inline constexpr bool contains = ( std::is_same_v< Type, Types > || ... );
+
+      template< typename Rules, typename Todo, typename Done >
+      struct filter
+      {
+         using type = Todo;
+      };
+
+      template< typename Rule, typename... Rules, typename... Todo, typename... Done >
+      struct filter< type_list< Rule, Rules... >, type_list< Todo... >, type_list< Done... > >
+         : filter< type_list< Rules... >, std::conditional_t< contains< Rule, Todo..., Done... >, type_list< Todo... >, type_list< Rule, Todo... > >, type_list< Done... > >
+      {};
+
+      template< typename Rules, typename Todo, typename Done >
+      using filter_t = typename filter< Rules, Todo, Done >::type;
+
+      template< template< typename... > class Func, typename Done, typename... Rules >
+      struct visitor
+      {
+         template< typename... Args >
+         static void visit( Args&&... args )
+         {
+            ( Func< Rules >::visit( args... ), ... );
+            using NextDone = type_list_concat_t< type_list< Rules... >, Done >;
+            using NextSubs = type_list_concat_t< typename Rules::subs_t... >;
+            using NextTodo = filter_t< NextSubs, empty_list, NextDone >;
+            if constexpr( !std::is_same_v< NextTodo, empty_list > ) {
+               visit_next< NextDone >( NextTodo(), args... );
+            }
+         }
+
+      private:
+         template< typename NextDone, typename... NextTodo, typename... Args >
+         static void visit_next( type_list< NextTodo... > /*unused*/, Args&&... args )
+         {
+            visitor< Func, NextDone, NextTodo... >::visit( args... );
+         }
+      };
+
+   }  // namespace internal
+
+   template< typename Rule, template< typename... > class Func, typename... Args >
+   void visit( Args&&... args )
+   {
+      internal::visitor< Func, empty_list, Rule >::visit( args... );
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_FROM_FILE_HPP
 #define TAO_JSON_FROM_FILE_HPP
 
-#include <string>
+#include <filesystem>
 #include <utility>
 
 #include "events/from_file.hpp"
@@ -14,17 +14,17 @@
 namespace tao::json
 {
    template< template< typename... > class Traits, template< typename... > class... Transformers >
-   [[nodiscard]] basic_value< Traits > basic_from_file( const std::string& filename )
+   [[nodiscard]] basic_value< Traits > basic_from_file( const std::filesystem::path& path )
    {
       events::transformer< events::to_basic_value< Traits >, Transformers... > consumer;
-      events::from_file( consumer, filename );
+      events::from_file( consumer, path );
       return std::move( consumer.value );
    }
 
    template< template< typename... > class... Transformers >
-   [[nodiscard]] value from_file( const std::string& filename )
+   [[nodiscard]] value from_file( const std::filesystem::path& path )
    {
-      return basic_from_file< traits, Transformers... >( filename );
+      return basic_from_file< traits, Transformers... >( path );
    }
 
 }  // namespace tao::json

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

@@ -21,7 +21,7 @@ namespace tao::json::internal
    {};
 
    template<>
-   struct action< rules::null >
+   struct action< rules::kw_null >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -31,7 +31,7 @@ namespace tao::json::internal
    };
 
    template<>
-   struct action< rules::true_ >
+   struct action< rules::kw_true >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -41,7 +41,7 @@ namespace tao::json::internal
    };
 
    template<>
-   struct action< rules::false_ >
+   struct action< rules::kw_false >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )

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

@@ -0,0 +1,14 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_INTERNAL_DEPENDENT_FALSE_HPP
+#define TAO_JSON_INTERNAL_DEPENDENT_FALSE_HPP
+
+namespace tao::json::internal
+{
+   template< typename... >
+   inline constexpr bool dependent_false = false;
+
+}  // namespace tao::json::internal
+
+#endif

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

@@ -17,7 +17,7 @@ namespace tao::json::internal
    struct errors
       : pegtl::normal< Rule >
    {
-      static const std::string error_message;
+      static const char* error_message;
 
       template< typename Input, typename... States >
       static void raise( const Input& in, States&&... /*unused*/ )
@@ -59,25 +59,25 @@ namespace tao::json::internal
    };
 
    // clang-format off
-   template<> inline const std::string errors< rules::text >::error_message = "no valid JSON";
+   template<> inline const char* errors< rules::text >::error_message = "no valid JSON";
 
-   template<> inline const std::string errors< rules::end_array >::error_message = "incomplete array, expected ']'";
-   template<> inline const std::string errors< rules::end_object >::error_message = "incomplete object, expected '}'";
-   template<> inline const std::string errors< rules::member >::error_message = "expected member";
-   template<> inline const std::string errors< rules::name_separator >::error_message = "expected ':'";
-   template<> inline const std::string errors< rules::array_element >::error_message = "expected value";
-   template<> inline const std::string errors< rules::value >::error_message = "expected value";
-   template<> inline const std::string errors< rules::sor_value >::error_message = "expected value";
+   template<> inline const char* errors< rules::end_array >::error_message = "incomplete array, expected ']'";
+   template<> inline const char* errors< rules::end_object >::error_message = "incomplete object, expected '}'";
+   template<> inline const char* errors< rules::member >::error_message = "expected member";
+   template<> inline const char* errors< rules::name_separator >::error_message = "expected ':'";
+   template<> inline const char* errors< rules::array_element >::error_message = "expected value";
+   template<> inline const char* errors< rules::value >::error_message = "expected value";
+   template<> inline const char* errors< rules::sor_value >::error_message = "expected value";
 
-   template<> inline const std::string errors< rules::edigits >::error_message = "expected at least one exponent digit";
-   template<> inline const std::string errors< rules::fdigits >::error_message = "expected at least one fraction digit";
-   template<> inline const std::string errors< rules::xdigit >::error_message = "incomplete universal character name";
-   template<> inline const std::string errors< rules::escaped >::error_message = "unknown escape sequence";
-   template<> inline const std::string errors< rules::unescaped >::error_message = "invalid unescaped character";
-   template<> inline const std::string errors< rules::string::content >::error_message = "unterminated string";
-   template<> inline const std::string errors< rules::key::content >::error_message = "unterminated key";
+   template<> inline const char* errors< rules::edigits >::error_message = "expected at least one exponent digit";
+   template<> inline const char* errors< rules::fdigits >::error_message = "expected at least one fraction digit";
+   template<> inline const char* errors< rules::xdigit >::error_message = "incomplete universal character name";
+   template<> inline const char* errors< rules::escaped >::error_message = "unknown escape sequence";
+   template<> inline const char* errors< rules::unescaped >::error_message = "invalid unescaped character";
+   template<> inline const char* errors< rules::string::content >::error_message = "unterminated string";
+   template<> inline const char* errors< rules::key::content >::error_message = "unterminated key";
 
-   template<> inline const std::string errors< pegtl::eof >::error_message = "unexpected character after JSON value";
+   template<> inline const char* errors< pegtl::eof >::error_message = "unexpected character after JSON value";
    // clang-format on
 
 }  // namespace tao::json::internal

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

@@ -14,8 +14,6 @@
 #include "../message_extension.hpp"
 #include "../type.hpp"
 
-#include "../external/pegtl/internal/demangle.hpp"
-
 namespace tao::json::internal
 {
    inline void to_stream( std::ostream& os, const bool v )

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

@@ -27,9 +27,9 @@ namespace tao::json::internal
       struct value_separator : padr< one< ',' > > {};
       struct element_separator : padr< one< ',' > > {};
 
-      struct false_ : pegtl::string< 'f', 'a', 'l', 's', 'e' > {};
-      struct null : pegtl::string< 'n', 'u', 'l', 'l' > {};
-      struct true_ : pegtl::string< 't', 'r', 'u', 'e' > {};
+      struct kw_false : pegtl::string< 'f', 'a', 'l', 's', 'e' > {};
+      struct kw_null : pegtl::string< 'n', 'u', 'l', 'l' > {};
+      struct kw_true : pegtl::string< 't', 'r', 'u', 'e' > {};
 
       struct digits : plus< abnf::DIGIT > {};
 
@@ -53,22 +53,21 @@ namespace tao::json::internal
 
       struct unescaped
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = unescaped;
+         using subs_t = pegtl::empty_list;
 
          template< typename Input >
          [[nodiscard]] static bool match( Input& in )
          {
             bool result = false;
-
-            while( const std::size_t s = in.size( 4 ) ) {
-               if( const auto t = pegtl::internal::peek_utf8::peek( in, s ) ) {
-                  if( ( 0x20 <= t.data ) && ( t.data != '\\' ) && ( t.data != '"' ) ) {
-                     in.bump_in_this_line( t.size );
-                     result = true;
-                     continue;
-                  }
+            while( const auto t = pegtl::internal::peek_utf8::peek( in ) ) {
+               if( ( 0x20 <= t.data ) && ( t.data != '\\' ) && ( t.data != '"' ) ) {
+                  in.bump_in_this_line( t.size );
+                  result = true;
+               }
+               else {
+                  break;
                }
-               break;
             }
             return result;
          }
@@ -115,7 +114,8 @@ namespace tao::json::internal
 
       struct sor_value
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::sor, string, number< false >, object, array, false_, true_, null >;
+         using rule_t = sor_value;
+         using subs_t = pegtl::type_list< string, number< false >, object, array, kw_false, kw_true, kw_null >;
 
          template< bool NEG,
                    apply_mode A,
@@ -181,9 +181,9 @@ namespace tao::json::internal
             case '"': return Control< string >::template match< A, M, Action, Control >( in, st... );
             case '{': return Control< object >::template match< A, M, Action, Control >( in, st... );
             case '[': return Control< array >::template match< A, M, Action, Control >( in, st... );
-            case 'n': return Control< null >::template match< A, M, Action, Control >( in, st... );
-            case 't': return Control< true_ >::template match< A, M, Action, Control >( in, st... );
-            case 'f': return Control< false_ >::template match< A, M, Action, Control >( in, st... );
+            case 'n': return Control< kw_null >::template match< A, M, Action, Control >( in, st... );
+            case 't': return Control< kw_true >::template match< A, M, Action, Control >( in, st... );
+            case 'f': return Control< kw_false >::template match< A, M, Action, Control >( in, st... );
 
             case '-':
                in.bump_in_this_line();