couchbase 3.0.0 → 3.0.1

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

@@ -4,49 +4,40 @@
 #ifndef TAO_JSON_PEGTL_INTERNAL_RAISE_HPP
 #define TAO_JSON_PEGTL_INTERNAL_RAISE_HPP
 
-#include <cstdlib>
 #include <stdexcept>
-#include <type_traits>
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
+#include "enable_control.hpp"
 
-#include "../analysis/generic.hpp"
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< typename T >
    struct raise
    {
-      using analyze_t = analysis::generic< analysis::rule_type::any >;
+      using rule_t = raise;
+      using subs_t = empty_list;
 
-#if defined( _MSC_VER )
-#pragma warning( push )
-#pragma warning( disable : 4702 )
-#endif
       template< apply_mode,
                 rewind_mode,
                 template< typename... >
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[noreturn]] static bool match( ParseInput& in, States&&... st )
       {
-         Control< T >::raise( static_cast< const Input& >( in ), st... );
-         throw std::logic_error( "code should be unreachable: Control< T >::raise() did not throw an exception" );  // LCOV_EXCL_LINE
-#if defined( _MSC_VER )
-#pragma warning( pop )
-#endif
+         Control< T >::raise( static_cast< const ParseInput& >( in ), st... );
       }
    };
 
    template< typename T >
-   inline constexpr bool skip_control< raise< T > > = true;
+   inline constexpr bool enable_control< raise< T > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,45 +6,50 @@
 
 #include "../config.hpp"
 
+#include "enable_control.hpp"
+#include "one.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 Lo, typename Peek::data_t Hi >
    struct range
    {
-      static_assert( Lo <= Hi, "invalid range detected" );
+      using rule_t = range;
+      using subs_t = empty_list;
 
-      using analyze_t = analysis::generic< analysis::rule_type::any >;
+      static_assert( Lo < Hi, "invalid range" );
 
       template< int Eol >
       static constexpr bool can_match_eol = ( ( ( Lo <= Eol ) && ( Eol <= Hi ) ) == bool( R ) );
 
-      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( ( ( Lo <= t.data ) && ( t.data <= Hi ) ) == bool( R ) ) {
-                  if constexpr( can_match_eol< Input::eol_t::ch > ) {
-                     in.bump( t.size );
-                  }
-                  else {
-                     in.bump_in_this_line( t.size );
-                  }
-                  return true;
+         if( const auto t = Peek::peek( in ) ) {
+            if( ( ( Lo <= t.data ) && ( t.data <= Hi ) ) == bool( R ) ) {
+               if constexpr( can_match_eol< ParseInput::eol_t::ch > ) {
+                  in.bump( t.size );
                }
+               else {
+                  in.bump_in_this_line( t.size );
+               }
+               return true;
             }
          }
          return false;
       }
    };
 
+   template< result_on_found R, typename Peek, typename Peek::data_t C >
+   struct range< R, Peek, C, C >
+      : one< R, Peek, C >
+   {};
+
    template< result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
-   inline constexpr bool skip_control< range< R, Peek, Lo, Hi > > = true;
+   inline constexpr bool enable_control< range< R, Peek, Lo, Hi > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,10 +6,12 @@
 
 #include "../config.hpp"
 
+#include "enable_control.hpp"
+#include "failure.hpp"
+#include "one.hpp"
 #include "range.hpp"
-#include "skip_control.hpp"
 
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -54,25 +56,24 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Peek, typename Peek::data_t... Cs >
    struct ranges
    {
-      using analyze_t = analysis::generic< analysis::rule_type::any >;
+      using rule_t = ranges;
+      using subs_t = empty_list;
 
       template< int Eol >
       static constexpr bool can_match_eol = ranges_impl< Eol, typename Peek::data_t, Cs... >::can_match_eol;
 
-      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( ranges_impl< Input::eol_t::ch, typename Peek::data_t, Cs... >::match( t.data ) ) {
-                  if constexpr( can_match_eol< Input::eol_t::ch > ) {
-                     in.bump( t.size );
-                  }
-                  else {
-                     in.bump_in_this_line( t.size );
-                  }
-                  return true;
+         if( const auto t = Peek::peek( in ) ) {
+            if( ranges_impl< ParseInput::eol_t::ch, typename Peek::data_t, Cs... >::match( t.data ) ) {
+               if constexpr( can_match_eol< ParseInput::eol_t::ch > ) {
+                  in.bump( t.size );
                }
+               else {
+                  in.bump_in_this_line( t.size );
+               }
+               return true;
             }
          }
          return false;
@@ -82,11 +83,20 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
    struct ranges< Peek, Lo, Hi >
       : range< result_on_found::success, Peek, Lo, Hi >
-   {
-   };
+   {};
+
+   template< typename Peek, typename Peek::data_t C >
+   struct ranges< Peek, C >
+      : one< result_on_found::success, Peek, C >
+   {};
+
+   template< typename Peek >
+   struct ranges< Peek >
+      : failure
+   {};
 
    template< typename Peek, typename Peek::data_t... Cs >
-   inline constexpr bool skip_control< ranges< Peek, Cs... > > = true;
+   inline constexpr bool enable_control< ranges< Peek, Cs... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,11 +6,12 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
+#include "enable_control.hpp"
 
 #include "../apply_mode.hpp"
 #include "../memory_input.hpp"
 #include "../rewind_mode.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -20,7 +21,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Head >
    struct rematch< Head >
    {
-      using analyze_t = typename Head::analyze_t;
+      using rule_t = rematch;
+      using subs_t = type_list< Head >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -28,9 +30,9 @@ 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 Control< Head >::template match< A, M, Action, Control >( in, st... );
       }
@@ -39,7 +41,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    template< typename Head, typename Rule, typename... Rules >
    struct rematch< Head, Rule, Rules... >
    {
-      using analyze_t = typename Head::analyze_t;  // NOTE: Rule and Rules are ignored for analyze().
+      using rule_t = rematch;
+      using subs_t = type_list< Head, Rule, Rules... >;
 
       template< apply_mode A,
                 rewind_mode,
@@ -47,14 +50,14 @@ 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< rewind_mode::required >();
 
          if( Control< Head >::template match< A, rewind_mode::active, Action, Control >( in, st... ) ) {
-            memory_input< Input::tracking_mode_v, typename Input::eol_t, typename Input::source_t > i2( m.iterator(), in.current(), in.source() );
+            memory_input< ParseInput::tracking_mode_v, typename ParseInput::eol_t, typename ParseInput::source_t > i2( m.iterator(), in.current(), in.source() );
             return m( ( Control< Rule >::template match< A, rewind_mode::active, Action, Control >( i2, st... ) && ... && ( i2.restart( m ), Control< Rules >::template match< A, rewind_mode::active, Action, Control >( i2, st... ) ) ) );
          }
          return false;
@@ -62,7 +65,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    };
 
    template< typename Head, typename... Rules >
-   inline constexpr bool skip_control< rematch< Head, Rules... > > = true;
+   inline constexpr bool enable_control< rematch< Head, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -6,35 +6,36 @@
 
 #include "../config.hpp"
 
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "enable_control.hpp"
+#include "seq.hpp"
+#include "success.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/counted.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
-   template< unsigned Num, typename... Rules >
-   struct rep;
+   template< unsigned Cnt, typename... Rules >
+   struct rep
+      : rep< Cnt, seq< Rules... > >
+   {};
 
-   template< unsigned Num >
-   struct rep< Num >
-      : trivial< true >
-   {
-   };
+   template< unsigned Cnt >
+   struct rep< Cnt >
+      : success
+   {};
 
-   template< typename Rule, typename... Rules >
-   struct rep< 0, Rule, Rules... >
-      : trivial< true >
-   {
-   };
+   template< typename Rule >
+   struct rep< 0, Rule >
+      : success
+   {};
 
-   template< unsigned Num, typename... Rules >
-   struct rep
+   template< unsigned Cnt, typename Rule >
+   struct rep< Cnt, Rule >
    {
-      using analyze_t = analysis::counted< analysis::rule_type::seq, Num, Rules... >;
+      using rule_t = rep;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -42,15 +43,15 @@ 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 );
 
-         for( unsigned i = 0; i != Num; ++i ) {
-            if( !( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) ) {
+         for( unsigned i = 0; i != Cnt; ++i ) {
+            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
                return false;
             }
          }
@@ -58,8 +59,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       }
    };
 
-   template< unsigned Num, typename... Rules >
-   inline constexpr bool skip_control< rep< Num, Rules... > > = true;
+   template< unsigned Cnt, typename... Rules >
+   inline constexpr bool enable_control< rep< Cnt, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

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

@@ -8,39 +8,41 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
+#include "enable_control.hpp"
+#include "failure.hpp"
 #include "not_at.hpp"
 #include "seq.hpp"
-#include "skip_control.hpp"
-#include "trivial.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/counted.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< unsigned Min, unsigned Max, typename... Rules >
-   struct rep_min_max;
+   struct rep_min_max
+      : rep_min_max< Min, Max, seq< Rules... > >
+   {
+      static_assert( Min <= Max );
+   };
 
    template< unsigned Min, unsigned Max >
    struct rep_min_max< Min, Max >
-      : trivial< false >
+      : failure
    {
       static_assert( Min <= Max );
    };
 
-   template< typename Rule, typename... Rules >
-   struct rep_min_max< 0, 0, Rule, Rules... >
-      : not_at< Rule, Rules... >
-   {
-   };
+   template< typename Rule >
+   struct rep_min_max< 0, 0, Rule >
+      : not_at< Rule >
+   {};
 
-   template< unsigned Min, unsigned Max, typename... Rules >
-   struct rep_min_max
+   template< unsigned Min, unsigned Max, typename Rule >
+   struct rep_min_max< Min, Max, Rule >
    {
-      using analyze_t = analysis::counted< analysis::rule_type::seq, Min, Rules... >;
+      using rule_t = rep_min_max;
+      using subs_t = type_list< Rule >;
 
       static_assert( Min <= Max );
 
@@ -50,29 +52,29 @@ 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 );
 
          for( unsigned i = 0; i != Min; ++i ) {
-            if( !( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) ) {
+            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
                return false;
             }
          }
          for( unsigned i = Min; i != Max; ++i ) {
-            if( !duseltronik< seq< Rules... >, A, rewind_mode::required, Action, Control >::match( in, st... ) ) {
+            if( !Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
                return m( true );
             }
          }
-         return m( duseltronik< not_at< Rules... >, A, m_t::next_rewind_mode, Action, Control >::match( in, st... ) );  // NOTE that not_at<> will always rewind.
+         return m( Control< not_at< Rule > >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );  // NOTE that not_at<> will always rewind.
       }
    };
 
    template< unsigned Min, unsigned Max, typename... Rules >
-   inline constexpr bool skip_control< rep_min_max< Min, Max, Rules... > > = true;
+   inline constexpr bool enable_control< rep_min_max< Min, Max, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal