couchbase 3.0.0 → 3.0.1

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

@@ -7,9 +7,9 @@
 #include "internal.hpp"
 
 #include "../../config.hpp"
-#include "../../utf32.hpp"
+#include "../utf32.hpp"
 
-#include "../../internal/peek_utf32.hpp"
+#include "../internal/peek_utf32.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
@@ -18,14 +18,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< UProperty P, bool V = true >
       struct binary_property
          : internal::icu::binary_property< internal::peek_utf32_be, P, V >
-      {
-      };
+      {};
 
       template< UProperty P, int V >
       struct property_value
          : internal::icu::property_value< internal::peek_utf32_be, P, V >
-      {
-      };
+      {};
 
       // clang-format off
       struct alphabetic : binary_property< UCHAR_ALPHABETIC > {};
@@ -109,14 +107,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< UProperty P, bool V = true >
       struct binary_property
          : internal::icu::binary_property< internal::peek_utf32_le, P, V >
-      {
-      };
+      {};
 
       template< UProperty P, int V >
       struct property_value
          : internal::icu::property_value< internal::peek_utf32_le, P, V >
-      {
-      };
+      {};
 
       // clang-format off
       struct alphabetic : binary_property< UCHAR_ALPHABETIC > {};

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

@@ -16,14 +16,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE::utf8::icu
    template< UProperty P, bool V = true >
    struct binary_property
       : internal::icu::binary_property< internal::peek_utf8, P, V >
-   {
-   };
+   {};
 
    template< UProperty P, int V >
    struct property_value
       : internal::icu::property_value< internal::peek_utf8, P, V >
-   {
-   };
+   {};
 
    // clang-format off
    struct alphabetic : binary_property< UCHAR_ALPHABETIC > {};

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

@@ -8,10 +8,11 @@
 
 #include "../config.hpp"
 
+#include "../internal/enable_control.hpp"
+#include "../internal/failure.hpp"
 #include "../internal/if_then_else.hpp"
 #include "../internal/seq.hpp"
-#include "../internal/skip_control.hpp"
-#include "../internal/trivial.hpp"
+#include "../internal/success.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
@@ -19,8 +20,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    {
       template< typename Cond, typename Then >
       struct if_pair
-      {
-      };
+      {};
 
       template< typename... Pairs >
       struct if_then;
@@ -33,22 +33,23 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          using else_if_then = if_then< if_pair< Cond, Then >, Pairs..., if_pair< ElseCond, seq< Thens... > > >;
 
          template< typename... Thens >
-         using else_then = if_then_else< Cond, Then, if_then< Pairs..., if_pair< trivial< true >, seq< Thens... > > > >;
+         using else_then = if_then_else< Cond, Then, if_then< Pairs..., if_pair< success, seq< Thens... > > > >;
       };
 
       template<>
       struct if_then<>
-         : trivial< false >
-      {
-      };
+         : failure
+      {};
 
       template< typename... Pairs >
-      inline constexpr bool skip_control< if_then< Pairs... > > = true;
+      inline constexpr bool enable_control< if_then< Pairs... > > = false;
 
    }  // namespace internal
 
    template< typename Cond, typename... Thens >
-   using if_then = internal::if_then< internal::if_pair< Cond, internal::seq< Thens... > > >;
+   struct if_then
+      : internal::if_then< internal::if_pair< Cond, internal::seq< Thens... > > >
+   {};
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

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

@@ -7,6 +7,8 @@
 #include <cstdint>
 #include <cstdlib>
 
+#include <limits>
+#include <string_view>
 #include <type_traits>
 
 #include "../ascii.hpp"
@@ -14,44 +16,44 @@
 #include "../parse_error.hpp"
 #include "../rules.hpp"
 
-namespace TAO_JSON_PEGTL_NAMESPACE::integer
+#include "analyze_traits.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
 {
-   namespace internal
+   struct unsigned_rule_old
+      : plus< digit >
    {
-      struct unsigned_rule_old
-         : plus< digit >
-      {
-         // Pre-3.0 version of this rule.
-      };
+      // Pre-3.0 version of this rule.
+   };
 
-      struct unsigned_rule_new
-         : if_then_else< one< '0' >, not_at< digit >, plus< digit > >
-      {
-         // New version that does not allow leading zeros.
-      };
+   struct unsigned_rule_new
+      : if_then_else< one< '0' >, not_at< digit >, plus< digit > >
+   {
+      // New version that does not allow leading zeros.
+   };
 
-      struct signed_rule_old
-         : seq< opt< one< '-', '+' > >, plus< digit > >
-      {
-         // Pre-3.0 version of this rule.
-      };
+   struct signed_rule_old
+      : seq< opt< one< '-', '+' > >, plus< digit > >
+   {
+      // Pre-3.0 version of this rule.
+   };
 
-      struct signed_rule_new
-         : seq< opt< one< '-', '+' > >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
-      {
-         // New version that does not allow leading zeros.
-      };
+   struct signed_rule_new
+      : seq< opt< one< '-', '+' > >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
+   {
+      // New version that does not allow leading zeros.
+   };
 
-      struct signed_rule_bis
-         : seq< opt< one< '-' > >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
-      {
-      };
+   struct signed_rule_bis
+      : seq< opt< one< '-' > >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
+   {};
 
-      struct signed_rule_ter
-         : seq< one< '-', '+' >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
-      {
-      };
+   struct signed_rule_ter
+      : seq< one< '-', '+' >, if_then_else< one< '0' >, not_at< digit >, plus< digit > > >
+   {};
 
+   namespace internal
+   {
       [[nodiscard]] constexpr bool is_digit( const char c ) noexcept
       {
          // We don't use std::isdigit() because it might
@@ -140,15 +142,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
          return convert_positive< Signed >( result, std::string_view( input.data() + offset, input.size() - offset ) );
       }
 
-      template< typename Input >
-      [[nodiscard]] bool match_unsigned( Input& in ) noexcept( noexcept( in.empty() ) )
+      template< typename ParseInput >
+      [[nodiscard]] bool match_unsigned( ParseInput& in ) noexcept( noexcept( in.empty() ) )
       {
          if( !in.empty() ) {
             const char c = in.peek_char();
             if( is_digit( c ) ) {
                in.bump_in_this_line();
                if( c == '0' ) {
-                  return in.empty() || ( !is_digit( in.peek_char() ) );  // TODO: Throw exception on digit?
+                  return in.empty() || ( !is_digit( in.peek_char() ) );
                }
                while( ( !in.empty() ) && is_digit( in.peek_char() ) ) {
                   in.bump_in_this_line();
@@ -159,10 +161,10 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
          return false;
       }
 
-      template< typename Input,
+      template< typename ParseInput,
                 typename Unsigned,
                 Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
-      [[nodiscard]] bool match_and_convert_unsigned_with_maximum( Input& in, Unsigned& st )
+      [[nodiscard]] bool match_and_convert_unsigned_with_maximum( ParseInput& in, Unsigned& st )
       {
          // Assumes st == 0.
 
@@ -171,11 +173,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
             if( is_digit( c ) ) {
                if( c == '0' ) {
                   in.bump_in_this_line();
-                  return in.empty() || ( !is_digit( in.peek_char() ) );  // TODO: Throw exception on digit?
+                  return in.empty() || ( !is_digit( in.peek_char() ) );
                }
                do {
                   if( !accumulate_digit< Unsigned, Maximum >( st, c ) ) {
-                     throw parse_error( "integer overflow", in );  // Consistent with "as if" an action was doing the conversion.
+                     throw TAO_JSON_PEGTL_NAMESPACE::parse_error( "integer overflow", in );  // Consistent with "as if" an action was doing the conversion.
                   }
                   in.bump_in_this_line();
                } while( ( !in.empty() ) && is_digit( c = in.peek_char() ) );
@@ -191,8 +193,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
    {
       // Assumes that 'in' contains a non-empty sequence of ASCII digits.
 
-      template< typename Input, typename Unsigned >
-      static auto apply( const Input& in, Unsigned& st ) -> std::enable_if_t< std::is_unsigned_v< Unsigned >, void >
+      template< typename ActionInput, typename Unsigned >
+      static void apply( const ActionInput& in, Unsigned& st )
       {
          // This function "only" offers basic exception safety.
          st = 0;
@@ -200,28 +202,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
             throw parse_error( "unsigned integer overflow", in );
          }
       }
-
-      template< typename Input, typename State >
-      static auto apply( const Input& in, State& st ) -> std::enable_if_t< std::is_class_v< State >, void >
-      {
-         apply( in, st.converted );  // Compatibility for pre-3.0 behaviour.
-      }
-
-      template< typename Input, typename Unsigned, typename... Ts >
-      static auto apply( const Input& in, std::vector< Unsigned, Ts... >& st ) -> std::enable_if_t< std::is_unsigned_v< Unsigned >, void >
-      {
-         Unsigned u = 0;
-         apply( in, u );
-         st.emplace_back( u );
-      }
    };
 
    struct unsigned_rule
    {
-      using analyze_t = internal::unsigned_rule_new::analyze_t;
+      using rule_t = unsigned_rule;
+      using subs_t = empty_list;
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.empty() ) )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( in.empty() ) )
       {
          return internal::match_unsigned( in );  // Does not check for any overflow.
       }
@@ -229,7 +218,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
 
    struct unsigned_rule_with_action
    {
-      using analyze_t = internal::unsigned_rule_new::analyze_t;
+      using rule_t = unsigned_rule_with_action;
+      using subs_t = empty_list;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -237,9 +227,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static auto match( Input& in, States&&... /*unused*/ ) noexcept( noexcept( in.empty() ) ) -> std::enable_if_t< A == apply_mode::nothing, bool >
+      [[nodiscard]] static auto match( ParseInput& in, States&&... /*unused*/ ) noexcept( noexcept( in.empty() ) ) -> std::enable_if_t< A == apply_mode::nothing, bool >
       {
          return internal::match_unsigned( in );  // Does not check for any overflow.
       }
@@ -250,17 +240,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename Unsigned >
-      [[nodiscard]] static auto match( Input& in, Unsigned& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_unsigned_v< Unsigned >, bool >
+      [[nodiscard]] static auto match( ParseInput& in, Unsigned& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_unsigned_v< Unsigned >, bool >
       {
          // This function "only" offers basic exception safety.
          st = 0;
          return internal::match_and_convert_unsigned_with_maximum( in, st );  // Throws on overflow.
       }
-
-      // TODO: Overload for st.converted?
-      // TODO: Overload for std::vector< Unsigned >?
    };
 
    template< typename Unsigned, Unsigned Maximum >
@@ -270,8 +257,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
 
       static_assert( std::is_unsigned_v< Unsigned > );
 
-      template< typename Input, typename Unsigned2 >
-      static auto apply( const Input& in, Unsigned2& st ) -> std::enable_if_t< std::is_same_v< Unsigned, Unsigned2 >, void >
+      template< typename ActionInput, typename Unsigned2 >
+      static void apply( const ActionInput& in, Unsigned2& st )
       {
          // This function "only" offers basic exception safety.
          st = 0;
@@ -279,43 +266,31 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
             throw parse_error( "unsigned integer overflow", in );
          }
       }
-
-      template< typename Input, typename State >
-      static auto apply( const Input& in, State& st ) -> std::enable_if_t< std::is_class_v< State >, void >
-      {
-         apply( in, st.converted );  // Compatibility for pre-3.0 behaviour.
-      }
-
-      template< typename Input, typename Unsigned2, typename... Ts >
-      static auto apply( const Input& in, std::vector< Unsigned2, Ts... >& st ) -> std::enable_if_t< std::is_same_v< Unsigned, Unsigned2 >, void >
-      {
-         Unsigned u = 0;
-         apply( in, u );
-         st.emplace_back( u );
-      }
    };
 
    template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
    struct maximum_rule
    {
-      static_assert( std::is_unsigned_v< Unsigned > );
+      using rule_t = maximum_rule;
+      using subs_t = empty_list;
 
-      using analyze_t = internal::unsigned_rule_new::analyze_t;
+      static_assert( std::is_unsigned_v< Unsigned > );
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in )
       {
          Unsigned st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< Input, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
       }
    };
 
    template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
    struct maximum_rule_with_action
    {
-      static_assert( std::is_unsigned_v< Unsigned > );
+      using rule_t = maximum_rule_with_action;
+      using subs_t = empty_list;
 
-      using analyze_t = internal::unsigned_rule_new::analyze_t;
+      static_assert( std::is_unsigned_v< Unsigned > );
 
       template< apply_mode A,
                 rewind_mode M,
@@ -323,12 +298,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static auto match( Input& in, States&&... /*unused*/ ) -> std::enable_if_t< A == apply_mode::nothing, bool >
+      [[nodiscard]] static auto match( ParseInput& in, States&&... /*unused*/ ) -> std::enable_if_t< A == apply_mode::nothing, bool >
       {
          Unsigned st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< Input, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
       }
 
       template< apply_mode A,
@@ -337,17 +312,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename Unsigned2 >
-      [[nodiscard]] static auto match( Input& in, Unsigned2& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_same_v< Unsigned, Unsigned2 >, bool >
+      [[nodiscard]] static auto match( ParseInput& in, Unsigned2& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_same_v< Unsigned, Unsigned2 >, bool >
       {
          // This function "only" offers basic exception safety.
          st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< Input, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
       }
-
-      // TODO: Overload for st.converted?
-      // TODO: Overload for std::vector< Unsigned >?
    };
 
    struct signed_action
@@ -355,8 +327,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
       // Assumes that 'in' contains a non-empty sequence of ASCII digits,
       // with optional leading sign; with sign, in.size() must be >= 2.
 
-      template< typename Input, typename Signed >
-      static auto apply( const Input& in, Signed& st ) -> std::enable_if_t< std::is_signed_v< Signed >, void >
+      template< typename ActionInput, typename Signed >
+      static void apply( const ActionInput& in, Signed& st )
       {
          // This function "only" offers basic exception safety.
          st = 0;
@@ -364,30 +336,17 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
             throw parse_error( "signed integer overflow", in );
          }
       }
-
-      template< typename Input, typename State >
-      static auto apply( const Input& in, State& st ) -> std::enable_if_t< std::is_class_v< State >, void >
-      {
-         apply( in, st.converted );  // Compatibility for pre-3.0 behaviour.
-      }
-
-      template< typename Input, typename Signed, typename... Ts >
-      static auto apply( const Input& in, std::vector< Signed, Ts... >& st ) -> std::enable_if_t< std::is_signed_v< Signed >, void >
-      {
-         Signed s = 0;
-         apply( in, s );
-         st.emplace_back( s );
-      }
    };
 
    struct signed_rule
    {
-      using analyze_t = internal::signed_rule_new::analyze_t;
+      using rule_t = signed_rule;
+      using subs_t = empty_list;
 
-      template< typename Input >
-      [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.empty() ) )
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( in.empty() ) )
       {
-         return TAO_JSON_PEGTL_NAMESPACE::parse< internal::signed_rule_new >( in );  // Does not check for any overflow.
+         return TAO_JSON_PEGTL_NAMESPACE::parse< signed_rule_new >( in );  // Does not check for any overflow.
       }
    };
 
@@ -396,20 +355,19 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
       template< typename Rule >
       struct signed_action_action
          : nothing< Rule >
-      {
-      };
+      {};
 
       template<>
       struct signed_action_action< signed_rule_new >
          : signed_action
-      {
-      };
+      {};
 
    }  // namespace internal
 
    struct signed_rule_with_action
    {
-      using analyze_t = internal::signed_rule_new::analyze_t;
+      using rule_t = signed_rule_with_action;
+      using subs_t = empty_list;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -417,11 +375,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static auto match( Input& in, States&&... /*unused*/ ) noexcept( noexcept( in.empty() ) ) -> std::enable_if_t< A == apply_mode::nothing, bool >
+      [[nodiscard]] static auto match( ParseInput& in, States&&... /*unused*/ ) noexcept( noexcept( in.empty() ) ) -> std::enable_if_t< A == apply_mode::nothing, bool >
       {
-         return TAO_JSON_PEGTL_NAMESPACE::parse< internal::signed_rule_new >( in );  // Does not check for any overflow.
+         return TAO_JSON_PEGTL_NAMESPACE::parse< signed_rule_new >( in );  // Does not check for any overflow.
       }
 
       template< apply_mode A,
@@ -430,17 +388,44 @@ namespace TAO_JSON_PEGTL_NAMESPACE::integer
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename Signed >
-      [[nodiscard]] static auto match( Input& in, Signed& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_signed_v< Signed >, bool >
+      [[nodiscard]] static auto match( ParseInput& in, Signed& st ) -> std::enable_if_t< ( A == apply_mode::action ) && std::is_signed_v< Signed >, bool >
       {
-         return TAO_JSON_PEGTL_NAMESPACE::parse< internal::signed_rule_new, internal::signed_action_action >( in, st );  // Throws on overflow.
+         return TAO_JSON_PEGTL_NAMESPACE::parse< signed_rule_new, internal::signed_action_action >( in, st );  // Throws on overflow.
       }
-
-      // TODO: Overload for st.converted?
-      // TODO: Overload for std::vector< Signed >?
    };
 
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::integer
+   template< typename Name >
+   struct analyze_traits< Name, unsigned_rule >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, unsigned_rule_with_action >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Integer, Integer Maximum >
+   struct analyze_traits< Name, maximum_rule< Integer, Maximum > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Integer, Integer Maximum >
+   struct analyze_traits< Name, maximum_rule_with_action< Integer, Maximum > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, signed_rule >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, signed_rule_with_action >
+      : analyze_any_traits<>
+   {};
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
 
 #endif