couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

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

@@ -6,21 +6,36 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.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< unsigned Max, typename... Rules >
    struct rep_opt
+      : rep_opt< Max, seq< Rules... > >
+   {};
+
+   template< unsigned Max >
+   struct rep_opt< Max >
+      : success
+   {};
+
+   template< typename... Rules >
+   struct rep_opt< 0, Rules... >
+      : success
+   {};
+
+   template< unsigned Max, typename Rule >
+   struct rep_opt< Max, Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::opt, Rules... >;
+      using rule_t = rep_opt;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode,
@@ -28,18 +43,18 @@ 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 )
       {
-         for( unsigned i = 0; ( i != Max ) && duseltronik< seq< Rules... >, A, rewind_mode::required, Action, Control >::match( in, st... ); ++i ) {
+         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
          }
          return true;
       }
    };
 
    template< unsigned Max, typename... Rules >
-   inline constexpr bool skip_control< rep_opt< Max, Rules... > > = true;
+   inline constexpr bool enable_control< rep_opt< Max, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,10 +6,10 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "enable_control.hpp"
+#include "success.hpp"
 
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -18,24 +18,24 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template<>
    struct require< 0 >
-      : trivial< true >
-   {
-   };
+      : success
+   {};
 
    template< unsigned Amount >
    struct require
    {
-      using analyze_t = analysis::generic< analysis::rule_type::opt >;
+      using rule_t = require;
+      using subs_t = empty_list;
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( in.size( 0 ) ) )
       {
          return in.size( Amount ) >= Amount;
       }
    };
 
    template< unsigned Amount >
-   inline constexpr bool skip_control< require< Amount > > = true;
+   inline constexpr bool enable_control< require< Amount > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -5,8 +5,6 @@
 #define TAO_JSON_PEGTL_INTERNAL_RULES_HPP
 
 #include "action.hpp"
-#include "alnum.hpp"
-#include "alpha.hpp"
 #include "any.hpp"
 #include "apply.hpp"
 #include "apply0.hpp"
@@ -18,9 +16,11 @@
 #include "disable.hpp"
 #include "discard.hpp"
 #include "enable.hpp"
+#include "enable_control.hpp"
 #include "eof.hpp"
 #include "eol.hpp"
 #include "eolf.hpp"
+#include "failure.hpp"
 #include "identifier.hpp"
 #include "if_apply.hpp"
 #include "if_must.hpp"
@@ -31,6 +31,7 @@
 #include "list_must.hpp"
 #include "list_tail.hpp"
 #include "list_tail_pad.hpp"
+#include "minus.hpp"
 #include "must.hpp"
 #include "not_at.hpp"
 #include "one.hpp"
@@ -48,13 +49,12 @@
 #include "rep_opt.hpp"
 #include "require.hpp"
 #include "seq.hpp"
-#include "skip_control.hpp"
 #include "sor.hpp"
 #include "star.hpp"
 #include "star_must.hpp"
 #include "state.hpp"
 #include "string.hpp"
-#include "trivial.hpp"
+#include "success.hpp"
 #include "try_catch_type.hpp"
 #include "until.hpp"
 

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

@@ -6,13 +6,12 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "enable_control.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,33 +20,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template<>
    struct seq<>
-      : trivial< true >
-   {
-   };
-
-   template< typename Rule >
-   struct seq< Rule >
-   {
-      using analyze_t = typename Rule::analyze_t;
-
-      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< Rule >::template match< A, M, Action, Control >( in, st... );
-      }
-   };
+      : success
+   {};
 
    template< typename... Rules >
    struct seq
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
+      using rule_t = seq;
+      using subs_t = type_list< Rules... >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -55,18 +35,23 @@ 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 )
       {
-         auto m = in.template mark< M >();
-         using m_t = decltype( m );
-         return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
+         if constexpr( sizeof...( Rules ) == 1 ) {
+            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
+         }
+         else {
+            auto m = in.template mark< M >();
+            using m_t = decltype( m );
+            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
+         }
       }
    };
 
    template< typename... Rules >
-   inline constexpr bool skip_control< seq< Rules... > > = true;
+   inline constexpr bool enable_control< seq< Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -8,13 +8,12 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "enable_control.hpp"
+#include "failure.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -23,20 +22,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template<>
    struct sor<>
-      : trivial< false >
-   {
-   };
+      : failure
+   {};
 
    template< typename... Rules >
    struct sor
-      : sor< std::index_sequence_for< Rules... >, Rules... >
-   {
-   };
-
-   template< std::size_t... Indices, typename... Rules >
-   struct sor< std::index_sequence< Indices... >, Rules... >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::sor, Rules... >;
+      using rule_t = sor;
+      using subs_t = type_list< Rules... >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -44,16 +37,30 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                std::size_t... Indices,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( std::index_sequence< Indices... > /*unused*/, ParseInput& in, States&&... st )
       {
          return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
       }
+
+      template< apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
+      {
+         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
+      }
    };
 
    template< typename... Rules >
-   inline constexpr bool skip_control< sor< Rules... > > = true;
+   inline constexpr bool enable_control< sor< Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -8,20 +8,25 @@
 
 #include "../config.hpp"
 
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.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 Rule, typename... Rules >
    struct star
+      : star< seq< Rule, Rules... > >
+   {};
+
+   template< typename Rule >
+   struct star< Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::opt, Rule, Rules..., star >;
+      using rule_t = star;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode,
@@ -29,18 +34,18 @@ 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 )
       {
-         while( seq< Rule, Rules... >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
+         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
          }
          return true;
       }
    };
 
    template< typename Rule, typename... Rules >
-   inline constexpr bool skip_control< star< Rule, Rules... > > = true;
+   inline constexpr bool enable_control< star< Rule, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,21 +6,31 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.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 State, typename... Rules >
    struct state
+      : state< State, seq< Rules... > >
+   {};
+
+   template< typename State >
+   struct state< State >
+      : success
+   {};
+
+   template< typename State, typename Rule >
+   struct state< State, Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
+      using rule_t = state;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -28,13 +38,13 @@ 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 )
       {
-         State s( static_cast< const Input& >( in ), st... );
-         if( duseltronik< seq< Rules... >, A, M, Action, Control >::match( in, s ) ) {
-            s.success( static_cast< const Input& >( in ), st... );
+         State s( static_cast< const ParseInput& >( in ), st... );
+         if( Control< Rule >::template match< A, M, Action, Control >( in, s ) ) {
+            s.success( static_cast< const ParseInput& >( in ), st... );
             return true;
          }
          return false;
@@ -42,7 +52,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    };
 
    template< typename State, typename... Rules >
-   inline constexpr bool skip_control< state< State, Rules... > > = true;
+   inline constexpr bool enable_control< state< State, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -10,11 +10,11 @@
 #include "../config.hpp"
 
 #include "bump_help.hpp"
+#include "enable_control.hpp"
 #include "result_on_found.hpp"
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "success.hpp"
 
-#include "../analysis/counted.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -28,21 +28,21 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
 
    template<>
    struct string<>
-      : trivial< true >
-   {
-   };
+      : success
+   {};
 
    template< char... Cs >
    struct string
    {
-      using analyze_t = analysis::counted< analysis::rule_type::any, sizeof...( Cs ) >;
+      using rule_t = string;
+      using subs_t = empty_list;
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.size( 0 ) ) )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( in.size( 0 ) ) )
       {
          if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
             if( unsafe_equals( in.current(), { Cs... } ) ) {
-               bump_help< result_on_found::success, Input, char, Cs... >( in, sizeof...( Cs ) );
+               bump_help< result_on_found::success, ParseInput, char, Cs... >( in, sizeof...( Cs ) );
                return true;
             }
          }
@@ -51,7 +51,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    };
 
    template< char... Cs >
-   inline constexpr bool skip_control< string< Cs... > > = true;
+   inline constexpr bool enable_control< string< Cs... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal