couchbase 3.0.3-universal-darwin-20

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

@@ -0,0 +1,69 @@
+// Copyright (c) 2019-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_FIRST_STATE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_REMOVE_FIRST_STATE_HPP
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#include "../internal/has_unwind.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   // Applies to start(), success(), failure(), raise(), apply(), and apply0():
+   // The first state is removed when the call is forwarded to Base.
+   template< typename Base >
+   struct remove_first_state
+      : Base
+   {
+      template< typename ParseInput, typename State, typename... States >
+      static void start( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::start( in, st... ) ) )
+      {
+         Base::start( in, st... );
+      }
+
+      template< typename ParseInput, typename State, typename... States >
+      static void success( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::success( in, st... ) ) )
+      {
+         Base::success( in, st... );
+      }
+
+      template< typename ParseInput, typename State, typename... States >
+      static void failure( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::failure( in, st... ) ) )
+      {
+         Base::failure( in, st... );
+      }
+
+      template< typename ParseInput, typename State, typename... States >
+      [[noreturn]] static void raise( const ParseInput& in, State&& /*unused*/, States&&... st )
+      {
+         Base::raise( in, st... );
+      }
+
+      template< typename ParseInput, typename State, typename... States >
+      static auto unwind( const ParseInput& in, State&& /*unused*/, States&&... st )
+         -> std::enable_if_t< internal::has_unwind< Base, void, const ParseInput&, States... > >
+      {
+         Base::unwind( in, st... );
+      }
+
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename State, typename... States >
+      static auto apply( const Iterator& begin, const ParseInput& in, State&& /*unused*/, States&&... 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 State, typename... States >
+      static auto apply0( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::template apply0< Action >( in, st... ) ) )
+         -> decltype( Base::template apply0< Action >( in, st... ) )
+      {
+         return Base::template apply0< Action >( in, st... );
+      }
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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

@@ -0,0 +1,94 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_REP_ONE_MIN_MAX_HPP
+#define TAO_JSON_PEGTL_CONTRIB_REP_ONE_MIN_MAX_HPP
+
+#include <algorithm>
+#include <type_traits>
+
+#include "../config.hpp"
+#include "../type_list.hpp"
+
+#include "../internal/bump_help.hpp"
+#include "../internal/bytes.hpp"
+#include "../internal/enable_control.hpp"
+#include "../internal/opt.hpp"
+
+#include "analyze_traits.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< unsigned Min, unsigned Max, char C >
+      struct rep_one_min_max
+      {
+         using rule_t = rep_one_min_max;
+         using subs_t = empty_list;
+
+         static_assert( Min <= Max );
+
+         template< typename ParseInput >
+         [[nodiscard]] static bool match( ParseInput& in )
+         {
+            const auto size = in.size( Max + 1 );
+            if( size < Min ) {
+               return false;
+            }
+            std::size_t i = 0;
+            while( ( i < size ) && ( in.peek_char( i ) == C ) ) {
+               ++i;
+            }
+            if( ( Min <= i ) && ( i <= Max ) ) {
+               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;
+         }
+      };
+
+      template< unsigned Min, unsigned Max, char C >
+      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 >
+      {};
+
+   }  // 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

@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_REP_STRING_HPP
+#define TAO_JSON_PEGTL_CONTRIB_REP_STRING_HPP
+
+#include <cstddef>
+
+#include "../config.hpp"
+#include "../internal/string.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< std::size_t, typename, char... >
+      struct make_rep_string;
+
+      template< char... Ss, char... Cs >
+      struct make_rep_string< 0, string< Ss... >, Cs... >
+      {
+         using type = string< Ss... >;
+      };
+
+      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
+
+   inline namespace ascii
+   {
+      template< std::size_t N, char... Cs >
+      struct rep_string
+         : internal::make_rep_string< N, internal::string<>, Cs... >::type
+      {};
+
+   }  // namespace ascii
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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