couchbase 3.0.0 → 3.0.1

data/ext/third_party/json/include/tao/json/external/pegtl/internal/minus.hpp

@@ -0,0 +1,21 @@
+// 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_INTERNAL_MINUS_HPP
+#define TAO_JSON_PEGTL_INTERNAL_MINUS_HPP
+
+#include "../config.hpp"
+
+#include "eof.hpp"
+#include "not_at.hpp"
+#include "rematch.hpp"
+#include "seq.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   template< typename M, typename S >
+   using minus = rematch< M, not_at< S, eof > >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/internal/missing_apply.hpp

@@ -12,12 +12,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Control,
              template< typename... >
              class Action,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   void missing_apply( Input& in, States&&... st )
+   void missing_apply( ParseInput& in, States&&... st )
    {
+      // This function only exists for better error messages, which means that it is only called when we know that it won't compile.
+      // LCOV_EXCL_START
       auto m = in.template mark< rewind_mode::required >();
       (void)Control::template apply< Action >( m.iterator(), in, st... );
+      // LCOV_EXCL_STOP
    }
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal

data/ext/third_party/json/include/tao/json/external/pegtl/internal/missing_apply0.hpp

@@ -11,11 +11,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Control,
              template< typename... >
              class Action,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   void missing_apply0( Input& in, States&&... st )
+   void missing_apply0( ParseInput& in, States&&... st )
    {
+      // This function only exists for better error messages, which means that it is only called when we know that it won't compile.
+      // LCOV_EXCL_START
       (void)Control::template apply0< Action >( in, st... );
+      // LCOV_EXCL_STOP
    }
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal

data/ext/third_party/json/include/tao/json/external/pegtl/internal/must.hpp

@@ -6,13 +6,13 @@
 
 #include "../config.hpp"
 
-#include "raise.hpp"
-#include "skip_control.hpp"
+#include "enable_control.hpp"
+#include "seq.hpp"
+#include "success.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -21,22 +21,13 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template< typename... Rules >
    struct must
-   {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
+      : seq< must< Rules >... >
+   {};
 
-      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 ( Control< must< Rules > >::template match< A, M, Action, Control >( in, st... ) && ... );
-      }
-   };
+   template<>
+   struct must<>
+      : success
+   {};
 
    // While in theory the implementation for a single rule could
    // be simplified to must< Rule > = sor< Rule, raise< Rule > >, this
@@ -45,7 +36,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Rule >
    struct must< Rule >
    {
-      using analyze_t = typename Rule::analyze_t;
+      using rule_t = must;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode,
@@ -53,19 +45,19 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-            (void)raise< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... );
+            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
          }
          return true;
       }
    };
 
    template< typename... Rules >
-   inline constexpr bool skip_control< must< Rules... > > = true;
+   inline constexpr bool enable_control< must< Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/internal/not_at.hpp

@@ -6,29 +6,31 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "enable_control.hpp"
+#include "failure.hpp"
+#include "seq.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< typename... Rules >
-   struct not_at;
+   struct not_at
+      : not_at< seq< Rules... > >
+   {};
 
    template<>
    struct not_at<>
-      : trivial< false >
-   {
-   };
+      : failure
+   {};
 
-   template< typename... Rules >
-   struct not_at
+   template< typename Rule >
+   struct not_at< Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::opt, Rules... >;
+      using rule_t = not_at;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode,
                 rewind_mode,
@@ -36,17 +38,17 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          const auto m = in.template mark< rewind_mode::required >();
-         return !( Control< Rules >::template match< apply_mode::nothing, rewind_mode::active, Action, Control >( in, st... ) && ... );
+         return !Control< Rule >::template match< apply_mode::nothing, rewind_mode::active, Action, Control >( in, st... );
       }
    };
 
    template< typename... Rules >
-   inline constexpr bool skip_control< not_at< Rules... > > = true;
+   inline constexpr bool enable_control< not_at< Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/internal/one.hpp

@@ -8,36 +8,47 @@
 
 #include "../config.hpp"
 
+#include "any.hpp"
 #include "bump_help.hpp"
+#include "enable_control.hpp"
+#include "failure.hpp"
 #include "result_on_found.hpp"
-#include "skip_control.hpp"
 
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< result_on_found R, typename Peek, typename Peek::data_t... Cs >
    struct one
    {
-      using analyze_t = analysis::generic< analysis::rule_type::any >;
+      using rule_t = one;
+      using subs_t = empty_list;
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.size( Peek::max_input_size ) ) )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( Peek::peek( in ) ) )
       {
-         if( const std::size_t s = in.size( Peek::max_input_size ); s >= Peek::min_input_size ) {
-            if( const auto t = Peek::peek( in, s ) ) {
-               if( ( ( t.data == Cs ) || ... ) == bool( R ) ) {
-                  bump_help< R, Input, typename Peek::data_t, Cs... >( in, t.size );
-                  return true;
-               }
+         if( const auto t = Peek::peek( in ) ) {
+            if( ( ( t.data == Cs ) || ... ) == bool( R ) ) {
+               bump_help< R, ParseInput, typename Peek::data_t, Cs... >( in, t.size );
+               return true;
             }
          }
          return false;
       }
    };
 
+   template< typename Peek >
+   struct one< result_on_found::success, Peek >
+      : failure
+   {};
+
+   template< typename Peek >
+   struct one< result_on_found::failure, Peek >
+      : any< Peek >
+   {};
+
    template< result_on_found R, typename Peek, typename Peek::data_t... Cs >
-   inline constexpr bool skip_control< one< R, Peek, Cs... > > = true;
+   inline constexpr bool enable_control< one< R, Peek, Cs... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/internal/opt.hpp

@@ -8,31 +8,31 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "success.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< typename... Rules >
-   struct opt;
+   struct opt
+      : opt< seq< Rules... > >
+   {};
 
    template<>
    struct opt<>
-      : trivial< true >
-   {
-   };
+      : success
+   {};
 
-   template< typename... Rules >
-   struct opt
+   template< typename Rule >
+   struct opt< Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::opt, Rules... >;
+      using rule_t = opt;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode,
@@ -40,17 +40,17 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
-         (void)duseltronik< seq< Rules... >, A, rewind_mode::required, Action, Control >::match( in, st... );
+         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
          return true;
       }
    };
 
    template< typename... Rules >
-   inline constexpr bool skip_control< opt< Rules... > > = true;
+   inline constexpr bool enable_control< opt< Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/internal/path_to_string.hpp

@@ -0,0 +1,26 @@
+// 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_INTERNAL_PATH_TO_STRING_HPP
+#define TAO_JSON_PEGTL_INTERNAL_PATH_TO_STRING_HPP
+
+#include <filesystem>
+#include <string>
+
+#include "../config.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   [[nodiscard]] inline std::string path_to_string( const std::filesystem::path& path )
+   {
+#if defined( __cpp_char8_t )
+      const auto s = path.u8string();
+      return { reinterpret_cast< const char* >( s.data() ), s.size() };
+#else
+      return path.u8string();
+#endif
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/internal/peek_char.hpp

@@ -17,12 +17,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       using data_t = char;
       using pair_t = input_pair< char >;
 
-      static constexpr std::size_t min_input_size = 1;
-      static constexpr std::size_t max_input_size = 1;
-
-      template< typename Input >
-      [[nodiscard]] static pair_t peek( const Input& in, const std::size_t /*unused*/ = 1 ) noexcept
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.empty() ) )
       {
+         if( in.empty() ) {
+            return { 0, 0 };
+         }
          return { in.peek_char(), 1 };
       }
    };

data/ext/third_party/json/include/tao/json/external/pegtl/internal/peek_utf8.hpp

@@ -15,26 +15,25 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       using data_t = char32_t;
       using pair_t = input_pair< char32_t >;
 
-      static constexpr std::size_t min_input_size = 1;
-      static constexpr std::size_t max_input_size = 4;
-
-      template< typename Input >
-      [[nodiscard]] static pair_t peek( const Input& in, const std::size_t s ) noexcept
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.empty() ) )
       {
-         char32_t c0 = in.peek_uint8();
-
+         if( in.empty() ) {
+            return { 0, 0 };
+         }
+         const char32_t c0 = in.peek_uint8();
          if( ( c0 & 0x80 ) == 0 ) {
             return { c0, 1 };
          }
-         return peek_impl( in, c0, s );
+         return peek_impl( in, c0 );
       }
 
    private:
-      template< typename Input >
-      [[nodiscard]] static pair_t peek_impl( const Input& in, char32_t c0, const std::size_t s ) noexcept
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek_impl( ParseInput& in, char32_t c0 ) noexcept( noexcept( in.size( 4 ) ) )
       {
          if( ( c0 & 0xE0 ) == 0xC0 ) {
-            if( s >= 2 ) {
+            if( in.size( 2 ) >= 2 ) {
                const char32_t c1 = in.peek_uint8( 1 );
                if( ( c1 & 0xC0 ) == 0x80 ) {
                   c0 &= 0x1F;
@@ -47,7 +46,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
             }
          }
          else if( ( c0 & 0xF0 ) == 0xE0 ) {
-            if( s >= 3 ) {
+            if( in.size( 3 ) >= 3 ) {
                const char32_t c1 = in.peek_uint8( 1 );
                const char32_t c2 = in.peek_uint8( 2 );
                if( ( ( c1 & 0xC0 ) == 0x80 ) && ( ( c2 & 0xC0 ) == 0x80 ) ) {
@@ -63,7 +62,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
             }
          }
          else if( ( c0 & 0xF8 ) == 0xF0 ) {
-            if( s >= 4 ) {
+            if( in.size( 4 ) >= 4 ) {
                const char32_t c1 = in.peek_uint8( 1 );
                const char32_t c2 = in.peek_uint8( 2 );
                const char32_t c3 = in.peek_uint8( 3 );

data/ext/third_party/json/include/tao/json/external/pegtl/internal/plus.hpp

@@ -8,16 +8,12 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
-#include "opt.hpp"
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.hpp"
-#include "star.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -28,8 +24,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template< typename Rule, typename... Rules >
    struct plus
+      : plus< seq< Rule, Rules... > >
+   {};
+
+   template< typename Rule >
+   struct plus< Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rule, Rules..., opt< plus > >;
+      using rule_t = plus;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -37,16 +39,21 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
-         return seq< Rule, Rules... >::template match< A, M, Action, Control >( in, st... ) && star< Rule, Rules... >::template match< A, M, Action, Control >( in, st... );
+         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
+            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+            }
+            return true;
+         }
+         return false;
       }
    };
 
    template< typename Rule, typename... Rules >
-   inline constexpr bool skip_control< plus< Rule, Rules... > > = true;
+   inline constexpr bool enable_control< plus< Rule, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal