couchbase 3.0.0 → 3.0.1

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/remove_last_states.hpp

@@ -0,0 +1,117 @@
+// 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_CONTRIB_REMOVE_LAST_STATES_HPP
+#define TAO_JSON_PEGTL_CONTRIB_REMOVE_LAST_STATES_HPP
+
+#include <tuple>
+#include <utility>
+
+#include "../config.hpp"
+
+#include "../internal/has_unwind.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   // Remove the last N states of start(), success(), failure(), raise(), apply(), and apply0()
+   template< typename Base, std::size_t N >
+   struct remove_last_states
+      : Base
+   {
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void start_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::start( in, std::get< Is >( t )... ) ) )
+      {
+         Base::start( in, std::get< Is >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void start( const ParseInput& in, States&&... st ) noexcept( noexcept( start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) ) )
+      {
+         start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void success_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::success( in, std::get< Is >( t )... ) ) )
+      {
+         Base::success( in, std::get< Is >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void success( const ParseInput& in, States&&... st ) noexcept( noexcept( success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) ) )
+      {
+         success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void failure_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::failure( in, std::get< Is >( t )... ) ) )
+      {
+         Base::failure( in, std::get< Is >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void failure( const ParseInput& in, States&&... st ) noexcept( noexcept( failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) ) )
+      {
+         failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      [[noreturn]] static void raise_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ )
+      {
+         Base::raise( in, std::get< Is >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      [[noreturn]] static void raise( const ParseInput& in, States&&... st )
+      {
+         raise_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto unwind_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ )
+         -> std::enable_if_t< internal::has_unwind< Base, void, const ParseInput&, std::tuple_element_t< Is, Tuple >... > >
+      {
+         Base::unwind( in, std::get< Is >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static auto unwind( const ParseInput& in, States&&... st )
+         -> decltype( unwind_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) )
+      {
+         unwind_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto apply_impl( const Iterator& begin, const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::template apply< Action >( begin, in, std::get< Is >( t )... ) ) )
+         -> decltype( Base::template apply< Action >( begin, in, std::get< Is >( t )... ) )
+      {
+         return Base::template apply< Action >( begin, in, std::get< Is >( t )... );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename... States >
+      static auto apply( const Iterator& begin, const ParseInput& in, States&&... st ) noexcept( noexcept( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) ) )
+         -> decltype( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) )
+      {
+         return apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+
+      template< template< typename... > class Action, typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto apply0_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::template apply0< Action >( in, std::get< Is >( t )... ) ) )
+         -> decltype( Base::template apply0< Action >( in, std::get< Is >( t )... ) )
+      {
+         return Base::template apply0< Action >( in, std::get< Is >( t )... );
+      }
+
+      template< template< typename... > class Action, typename ParseInput, typename... States >
+      static auto apply0( const ParseInput& in, States&&... st ) noexcept( noexcept( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) ) )
+         -> decltype( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() ) )
+      {
+         return apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - N >() );
+      }
+   };
+
+   template< typename Base >
+   using remove_last_state = remove_last_states< Base, 1 >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/rep_one_min_max.hpp

@@ -5,13 +5,17 @@
 #define TAO_JSON_PEGTL_CONTRIB_REP_ONE_MIN_MAX_HPP
 
 #include <algorithm>
+#include <type_traits>
 
 #include "../config.hpp"
-
-#include "../analysis/counted.hpp"
+#include "../type_list.hpp"
 
 #include "../internal/bump_help.hpp"
-#include "../internal/skip_control.hpp"
+#include "../internal/bytes.hpp"
+#include "../internal/enable_control.hpp"
+#include "../internal/opt.hpp"
+
+#include "analyze_traits.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
@@ -20,12 +24,13 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< unsigned Min, unsigned Max, char C >
       struct rep_one_min_max
       {
-         using analyze_t = analysis::counted< analysis::rule_type::any, Min >;
+         using rule_t = rep_one_min_max;
+         using subs_t = empty_list;
 
          static_assert( Min <= Max );
 
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in )
+         template< typename ParseInput >
+         [[nodiscard]] static bool match( ParseInput& in )
          {
             const auto size = in.size( Max + 1 );
             if( size < Min ) {
@@ -36,7 +41,29 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                ++i;
             }
             if( ( Min <= i ) && ( i <= Max ) ) {
-               bump_help< result_on_found::success, Input, char, C >( in, i );
+               bump_help< result_on_found::success, ParseInput, char, C >( in, i );
+               return true;
+            }
+            return false;
+         }
+      };
+
+      template< unsigned Max, char C >
+      struct rep_one_min_max< 0, Max, C >
+      {
+         using rule_t = rep_one_min_max;
+         using subs_t = empty_list;
+
+         template< typename ParseInput >
+         [[nodiscard]] static bool match( ParseInput& in )
+         {
+            const auto size = in.size( Max + 1 );
+            std::size_t i = 0;
+            while( ( i < size ) && ( in.peek_char( i ) == C ) ) {
+               ++i;
+            }
+            if( i <= Max ) {
+               bump_help< result_on_found::success, ParseInput, char, C >( in, i );
                return true;
             }
             return false;
@@ -44,19 +71,24 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       };
 
       template< unsigned Min, unsigned Max, char C >
-      inline constexpr bool skip_control< rep_one_min_max< Min, Max, C > > = true;
+      inline constexpr bool enable_control< rep_one_min_max< Min, Max, C > > = false;
 
    }  // namespace internal
 
    inline namespace ascii
    {
       template< unsigned Min, unsigned Max, char C >
-      struct rep_one_min_max : internal::rep_one_min_max< Min, Max, C >
-      {
-      };
+      struct rep_one_min_max
+         : internal::rep_one_min_max< Min, Max, C >
+      {};
 
    }  // namespace ascii
 
+   template< typename Name, unsigned Min, unsigned Max, char C >
+   struct analyze_traits< Name, internal::rep_one_min_max< Min, Max, C > >
+      : std::conditional_t< ( Min != 0 ), analyze_any_traits<>, analyze_opt_traits<> >
+   {};
+
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 
 #endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/rep_string.hpp

@@ -25,8 +25,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< std::size_t N, char... Ss, char... Cs >
       struct make_rep_string< N, string< Ss... >, Cs... >
          : make_rep_string< N - 1, string< Ss..., Cs... >, Cs... >
-      {
-      };
+      {};
 
    }  // namespace internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/shuffle_states.hpp

@@ -0,0 +1,193 @@
+// 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_CONTRIB_SHUFFLE_STATES_HPP
+#define TAO_JSON_PEGTL_CONTRIB_SHUFFLE_STATES_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "../config.hpp"
+
+#include "../internal/has_unwind.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< std::size_t N >
+      struct rotate_left
+      {
+         template< std::size_t I, std::size_t S >
+         static constexpr std::size_t value = ( I + N ) % S;
+      };
+
+      template< std::size_t N >
+      struct rotate_right
+      {
+         template< std::size_t I, std::size_t S >
+         static constexpr std::size_t value = ( I + S - N ) % S;
+      };
+
+      struct reverse
+      {
+         template< std::size_t I, std::size_t S >
+         static constexpr std::size_t value = ( S - 1 ) - I;
+      };
+
+   }  // namespace internal
+
+   // Applies 'Shuffle' to the states of start(), success(), failure(), raise(), apply(), and apply0()
+   template< typename Base, typename Shuffle >
+   struct shuffle_states
+      : Base
+   {
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void start_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::start( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) ) )
+      {
+         Base::start( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void start( const ParseInput& in, States&&... st ) noexcept( noexcept( start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) ) )
+      {
+         start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< typename ParseInput, typename State >
+      static void start( const ParseInput& in, State&& st ) noexcept( noexcept( Base::start( in, st ) ) )
+      {
+         Base::start( in, st );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void success_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::success( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) ) )
+      {
+         Base::success( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void success( const ParseInput& in, States&&... st ) noexcept( noexcept( success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) ) )
+      {
+         success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< typename ParseInput, typename State >
+      static void success( const ParseInput& in, State&& st ) noexcept( noexcept( Base::success( in, st ) ) )
+      {
+         Base::success( in, st );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static void failure_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::failure( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) ) )
+      {
+         Base::failure( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static void failure( const ParseInput& in, States&&... st ) noexcept( noexcept( failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) ) )
+      {
+         failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< typename ParseInput, typename State >
+      static void failure( const ParseInput& in, State&& st ) noexcept( noexcept( Base::failure( in, st ) ) )
+      {
+         Base::failure( in, st );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      [[noreturn]] static void raise_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ )
+      {
+         Base::raise( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      [[noreturn]] static void raise( const ParseInput& in, States&&... st )
+      {
+         raise_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< typename ParseInput, typename State >
+      [[noreturn]] static void raise( const ParseInput& in, State&& st )
+      {
+         Base::raise( in, st );
+      }
+
+      template< typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto unwind_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ )
+         -> std::enable_if_t< internal::has_unwind< Base, void, const ParseInput&, std::tuple_element_t< Shuffle::template value< Is, sizeof...( Is ) >, Tuple >... > >
+      {
+         Base::unwind( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< typename ParseInput, typename... States >
+      static auto unwind( const ParseInput& in, States&&... st )
+         -> decltype( unwind_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) )
+      {
+         unwind_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< typename ParseInput, typename State >
+      static auto unwind( const ParseInput& in, State&& st )
+         -> std::enable_if_t< internal::has_unwind< Base, void, const ParseInput&, State > >
+      {
+         Base::unwind( in, st );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto apply_impl( const Iterator& begin, const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::template apply< Action >( begin, in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) ) )
+         -> decltype( Base::template apply< Action >( begin, in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) )
+      {
+         return Base::template apply< Action >( begin, in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename... States >
+      static auto apply( const Iterator& begin, const ParseInput& in, States&&... st ) noexcept( noexcept( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) ) )
+         -> decltype( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) )
+      {
+         return apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename State >
+      static auto apply( const Iterator& begin, const ParseInput& in, State&& st ) noexcept( noexcept( Base::template apply< Action >( begin, in, st ) ) )
+         -> decltype( Base::template apply< Action >( begin, in, st ) )
+      {
+         return Base::template apply< Action >( begin, in, st );
+      }
+
+      template< template< typename... > class Action, typename ParseInput, typename Tuple, std::size_t... Is >
+      static auto apply0_impl( const ParseInput& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( Base::template apply0< Action >( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) ) )
+         -> decltype( Base::template apply0< Action >( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... ) )
+      {
+         return Base::template apply0< Action >( in, std::get< Shuffle::template value< Is, sizeof...( Is ) > >( t )... );
+      }
+
+      template< template< typename... > class Action, typename ParseInput, typename... States >
+      static auto apply0( const ParseInput& in, States&&... st ) noexcept( noexcept( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) ) )
+         -> decltype( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() ) )
+      {
+         return apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) >() );
+      }
+
+      template< template< typename... > class Action, typename ParseInput, typename State >
+      static auto apply0( const ParseInput& in, State&& st ) noexcept( noexcept( Base::template apply0< Action >( in, st ) ) )
+         -> decltype( Base::template apply0< Action >( in, st ) )
+      {
+         return Base::template apply0< Action >( in, st );
+      }
+   };
+
+   template< typename Base, std::size_t N = 1 >
+   using rotate_states_left = shuffle_states< Base, internal::rotate_left< N > >;
+
+   template< typename Base, std::size_t N = 1 >
+   using rotate_states_right = shuffle_states< Base, internal::rotate_right< N > >;
+
+   template< typename Base >
+   using reverse_states = shuffle_states< Base, internal::reverse >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/state_control.hpp

@@ -0,0 +1,118 @@
+// 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_CONTRIB_STATE_CONTROL_HPP
+#define TAO_JSON_PEGTL_CONTRIB_STATE_CONTROL_HPP
+
+#include <type_traits>
+
+#include "shuffle_states.hpp"
+
+#include "../config.hpp"
+#include "../internal/has_unwind.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   template< template< typename... > class Control >
+   struct state_control
+   {
+      template< typename Rule >
+      struct control
+         : Control< Rule >
+      {
+         static constexpr bool enable = true;
+
+         template< typename ParseInput, typename State, typename... States >
+         static void start( [[maybe_unused]] const ParseInput& in, [[maybe_unused]] State& state, [[maybe_unused]] States&&... st )
+         {
+            if constexpr( Control< Rule >::enable ) {
+               Control< Rule >::start( in, st... );
+            }
+            if constexpr( State::template enable< Rule > ) {
+               state.template start< Rule >( in, st... );
+            }
+#if defined( _MSC_VER )
+            ( (void)st, ... );
+#endif
+         }
+
+         template< typename ParseInput, typename State, typename... States >
+         static void success( [[maybe_unused]] const ParseInput& in, [[maybe_unused]] State& state, [[maybe_unused]] States&&... st )
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template success< Rule >( in, st... );
+            }
+            if constexpr( Control< Rule >::enable ) {
+               Control< Rule >::success( in, st... );
+            }
+#if defined( _MSC_VER )
+            ( (void)st, ... );
+#endif
+         }
+
+         template< typename ParseInput, typename State, typename... States >
+         static void failure( [[maybe_unused]] const ParseInput& in, [[maybe_unused]] State& state, [[maybe_unused]] States&&... st )
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template failure< Rule >( in, st... );
+            }
+            if constexpr( Control< Rule >::enable ) {
+               Control< Rule >::failure( in, st... );
+            }
+#if defined( _MSC_VER )
+            ( (void)st, ... );
+#endif
+         }
+
+         template< typename ParseInput, typename State, typename... States >
+         [[noreturn]] static void raise( const ParseInput& in, [[maybe_unused]] State& state, States&&... st )
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template raise< Rule >( in, st... );
+            }
+            Control< Rule >::raise( in, st... );
+         }
+
+         template< typename ParseInput, typename State, typename... States >
+         static auto unwind( [[maybe_unused]] const ParseInput& in, [[maybe_unused]] State& state, [[maybe_unused]] States&&... st )
+            -> std::enable_if_t< State::template enable< Rule > || ( Control< Rule >::enable && internal::has_unwind< Control< Rule >, void, const ParseInput&, States... > ) >
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template unwind< Rule >( in, st... );
+            }
+            if constexpr( Control< Rule >::enable && internal::has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
+               Control< Rule >::unwind( in, st... );
+            }
+#if defined( _MSC_VER )
+            ( (void)st, ... );
+#endif
+         }
+
+         template< template< typename... > class Action, typename Iterator, typename ParseInput, typename State, typename... States >
+         static auto apply( const Iterator& begin, const ParseInput& in, [[maybe_unused]] State& state, States&&... st )
+            -> decltype( Control< Rule >::template apply< Action >( begin, in, st... ) )
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template apply< Rule >( in, st... );
+            }
+            return Control< Rule >::template apply< Action >( begin, in, st... );
+         }
+
+         template< template< typename... > class Action, typename ParseInput, typename State, typename... States >
+         static auto apply0( const ParseInput& in, [[maybe_unused]] State& state, States&&... st )
+            -> decltype( Control< Rule >::template apply0< Action >( in, st... ) )
+         {
+            if constexpr( State::template enable< Rule > ) {
+               state.template apply0< Rule >( in, st... );
+            }
+            return Control< Rule >::template apply0< Action >( in, st... );
+         }
+      };
+
+      template< typename Rule >
+      using type = rotate_states_right< control< Rule > >;
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif