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

data/ext/third_party/json/include/tao/json/contrib/unordered_map_traits.hpp

@@ -23,7 +23,7 @@ namespace tao::json
       {
          const auto& o = v.get_object();
          for( const auto& i : o ) {
-            r.try_emplace( i.first, Traits< T >::as( i.second, with... ) );
+            r.try_emplace( i.first, i.second.template as_with< T >( with... ) );
          }
       }
 

data/ext/third_party/json/include/tao/json/contrib/unordered_set_traits.hpp

@@ -22,7 +22,7 @@ namespace tao::json
       {
          const auto& a = v.get_array();
          for( const auto& i : a ) {
-            r.try_emplace( Traits< T >::as( i, with... ) );
+            r.emplace( i.template as_with< T >( with... ) );
          }
       }
 
@@ -31,7 +31,7 @@ namespace tao::json
       {
          auto s = parser.begin_array();
          while( parser.element_or_end_array( s ) ) {
-            r.try_emplace( json::consume< T, Traits >( parser ) );
+            r.emplace( json::consume< T, Traits >( parser ) );
          }
       }
    };

data/ext/third_party/json/include/tao/json/events/compare.hpp

@@ -169,12 +169,12 @@ namespace tao::json
             m_object_keys.emplace_back();
          }
 
-         void key( const std::string& v )
+         void key( const std::string_view sv )
          {
             if( !m_match ) {
                m_current.push_back( nullptr );
             }
-            else if( const auto* p = current().find( v ) ) {
+            else if( const auto* p = current().find( sv ) ) {
                if( !m_object_keys.back().insert( p ).second ) {
                   m_match = false;  // duplicate key found! -> fail
                   m_current.push_back( nullptr );
@@ -189,16 +189,6 @@ namespace tao::json
             }
          }
 
-         void key( const std::string_view v )
-         {
-            key( std::string( v ) );
-         }
-
-         void key( const char* v )
-         {
-            key( std::string( v ) );
-         }
-
          void member() noexcept
          {
             m_current.pop_back();

data/ext/third_party/json/include/tao/json/events/from_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_EVENTS_FROM_FILE_HPP
 #define TAO_JSON_EVENTS_FROM_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../internal/action.hpp"
 #include "../internal/errors.hpp"
@@ -16,10 +16,10 @@ namespace tao::json::events
 {
    // Events producer to parse a file containing a JSON string representation.
 
-   template< typename T, typename Consumer >
-   void from_file( Consumer& consumer, T&& filename )
+   template< typename Consumer >
+   void from_file( Consumer& consumer, const std::filesystem::path& path )
    {
-      pegtl::file_input< pegtl::tracking_mode::lazy > in( std::forward< T >( filename ) );
+      pegtl::file_input< pegtl::tracking_mode::lazy > in( path );
       pegtl::parse< internal::grammar, internal::action, internal::errors >( in, consumer );
    }
 

data/ext/third_party/json/include/tao/json/events/from_string.hpp

@@ -15,14 +15,14 @@ namespace tao::json::events
    // Events producer to parse a JSON string representation.
 
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
       pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::events::from_string", byte, line, column );
       json::events::from_input( consumer, std::move( in ) );
    }
 
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
       events::from_string( consumer, data, size, source.c_str(), byte, line, column );
    }

data/ext/third_party/json/include/tao/json/events/invalid_string_to_binary.hpp

@@ -29,7 +29,7 @@ namespace tao::json::events
             Consumer::string( std::move( v ) );
          }
          else {
-            const std::byte* data = reinterpret_cast< const std::byte* >( v.data() );
+            const auto* const data = reinterpret_cast< const std::byte* >( v.data() );
             Consumer::binary( std::vector< std::byte >( data, data + v.size() ) );
          }
       }

data/ext/third_party/json/include/tao/json/events/key_camel_case_to_snake_case.hpp

@@ -21,7 +21,7 @@ namespace tao::json::events
          std::string t;
          bool last_upper = false;
          for( const auto c : v ) {
-            if( std::isupper( c ) ) {
+            if( std::isupper( c ) != 0 ) {
                last_upper = true;
                t += c;
             }
@@ -41,7 +41,7 @@ namespace tao::json::events
          std::string r;
          bool last_lower = false;
          for( const auto c : t ) {
-            if( std::isupper( c ) ) {
+            if( std::isupper( c ) != 0 ) {
                if( last_lower ) {
                   r += '_';
                }
@@ -49,7 +49,7 @@ namespace tao::json::events
                r += static_cast< char >( std::tolower( c ) );
             }
             else {
-               last_lower = static_cast< bool >( std::islower( c ) );
+               last_lower = ( std::islower( c ) != 0 );
                r += c;
             }
          }

data/ext/third_party/json/include/tao/json/events/key_snake_case_to_camel_case.hpp

@@ -26,7 +26,7 @@ namespace tao::json::events
                if( c == '_' ) {
                   r += c;
                }
-               else if( std::isupper( c ) ) {
+               else if( std::isupper( c ) != 0 ) {
                   r += '_';
                   r += c;
                   active = false;

data/ext/third_party/json/include/tao/json/events/tee.hpp

@@ -233,7 +233,7 @@ namespace tao::json
       class tee
       {
       private:
-         static constexpr std::size_t S = sizeof...( Ts );
+         static inline constexpr std::size_t S = sizeof...( Ts );  // NOLINT(readability-identifier-naming)
 
          using I = std::make_index_sequence< S >;
          using H = std::make_index_sequence< S - 1 >;
@@ -371,7 +371,7 @@ namespace tao::json
       {};
 
       template< typename... Ts >
-      tee( Ts&&... )->tee< internal::decay_and_strip_t< Ts >... >;
+      tee( Ts&&... ) -> tee< internal::decay_and_strip_t< Ts >... >;
 
       template< typename... T >
       [[nodiscard]] tee< T&... > tie( T&... t )

data/ext/third_party/json/include/tao/json/events/to_pretty_stream.hpp

@@ -108,7 +108,7 @@ namespace tao::json::events
          os.put( '"' );
       }
 
-      void binary( const tao::binary_view /*unused*/ )
+      void binary( const tao::binary_view /*unused*/ )  // NOLINT(readability-convert-member-functions-to-static)
       {
          // if this throws, consider using binary_to_* transformers
          throw std::runtime_error( "binary data invalid for JSON string representation" );

data/ext/third_party/json/include/tao/json/events/to_stream.hpp

@@ -89,7 +89,7 @@ namespace tao::json::events
          os.put( '"' );
       }
 
-      void binary( const tao::binary_view /*unused*/ )
+      void binary( const tao::binary_view /*unused*/ )  // NOLINT(readability-convert-member-functions-to-static)
       {
          // if this throws, consider using binary_to_* transformers
          throw std::runtime_error( "binary data invalid for JSON string representation" );

data/ext/third_party/json/include/tao/json/events/transformer.hpp

@@ -4,9 +4,9 @@
 #ifndef TAO_JSON_EVENTS_TRANSFORMER_HPP
 #define TAO_JSON_EVENTS_TRANSFORMER_HPP
 
-#include <type_traits>
+#include <utility>
 
-#include "../external/pegtl/internal/always_false.hpp"
+#include "../internal/dependent_false.hpp"
 
 namespace tao::json
 {
@@ -18,7 +18,7 @@ namespace tao::json
          // if this static assert is triggered there is a high chance that 'T' is
          // a traits class template and you intended to call a method starting with "basic_*",
          // e.g. basic_from_file< my_traits >( ... ) instead of from_file< my_traits >( ... ).
-         static_assert( pegtl::internal::always_false< invalid_transformer< T > >::value, "T is not a valid transformer" );
+         static_assert( internal::dependent_false< invalid_transformer< T > >, "T is not a valid transformer" );
       };
 
       template< typename B, template< typename... > class T, typename = void >

data/ext/third_party/json/include/tao/json/events/validate_event_order.hpp

@@ -44,7 +44,7 @@ namespace tao::json::events
             : expected( in_expected )
          {}
 
-         void check( const std::size_t in_expected )
+         void check( const std::size_t in_expected ) const
          {
             if( expected != in_expected ) {
                throw std::logic_error( "inconsistent size" );
@@ -249,7 +249,7 @@ namespace tao::json::events
             default:
                break;
          }
-         assert( sizes.size() );
+         assert( !sizes.empty() );
          sizes.back().check( expected );
          sizes.pop_back();
          end_array();
@@ -399,7 +399,7 @@ namespace tao::json::events
             default:
                break;
          }
-         assert( sizes.size() );
+         assert( !sizes.empty() );
          sizes.back().check( expected );
          sizes.pop_back();
          end_object();

data/ext/third_party/json/include/tao/json/events/virtual_ref.hpp

@@ -25,8 +25,14 @@ namespace tao::json::events
          : m_r( r )
       {}
 
+      virtual_ref( const virtual_ref& ) = delete;
+      virtual_ref( virtual_ref&& ) = delete;
+
       virtual ~virtual_ref() = default;
 
+      virtual_ref& operator=( const virtual_ref& ) = delete;
+      virtual_ref& operator=( virtual_ref&& ) = delete;
+
    private:
       Consumer& m_r;
 

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

@@ -5,18 +5,11 @@
 #define TAO_JSON_PEGTL_HPP
 
 #include "pegtl/config.hpp"
-#include "pegtl/version.hpp"
-
 #include "pegtl/parse.hpp"
+#include "pegtl/version.hpp"
 
 #include "pegtl/ascii.hpp"
 #include "pegtl/rules.hpp"
-#include "pegtl/uint16.hpp"
-#include "pegtl/uint32.hpp"
-#include "pegtl/uint64.hpp"
-#include "pegtl/uint8.hpp"
-#include "pegtl/utf16.hpp"
-#include "pegtl/utf32.hpp"
 #include "pegtl/utf8.hpp"
 
 #include "pegtl/argv_input.hpp"
@@ -27,7 +20,7 @@
 #include "pegtl/read_input.hpp"
 #include "pegtl/string_input.hpp"
 
-// this has to be included *after* the above inputs,
+// This has to be included *after* the above inputs,
 // otherwise the amalgamated header will not work!
 #include "pegtl/file_input.hpp"
 
@@ -45,9 +38,7 @@
 #include "pegtl/discard_input_on_failure.hpp"
 #include "pegtl/discard_input_on_success.hpp"
 
-// The following are not included by
-// default because they include <iostream>.
-
-// #include "pegtl/analyze.hpp"
+#include "pegtl/must_if.hpp"
+#include "pegtl/visit.hpp"
 
 #endif

data/ext/third_party/json/include/tao/json/external/pegtl/argv_input.hpp

@@ -34,17 +34,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< typename T >
       argv_input( char** argv, const std::size_t argn, T&& in_source )
          : memory_input< P, Eol >( static_cast< const char* >( argv[ argn ] ), std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       argv_input( char** argv, const std::size_t argn )
          : argv_input( argv, argn, internal::make_argv_source( argn ) )
-      {
-      }
+      {}
    };
 
    template< typename... Ts >
-   argv_input( Ts&&... )->argv_input<>;
+   argv_input( Ts&&... ) -> argv_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

data/ext/third_party/json/include/tao/json/external/pegtl/ascii.hpp

@@ -5,9 +5,8 @@
 #define TAO_JSON_PEGTL_ASCII_HPP
 
 #include "config.hpp"
-#include "eol.hpp"
 
-#include "internal/always_false.hpp"
+#include "internal/dependent_false.hpp"
 #include "internal/result_on_found.hpp"
 #include "internal/rules.hpp"
 
@@ -16,19 +15,18 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    inline namespace ascii
    {
       // clang-format off
-      struct alnum : internal::alnum {};
-      struct alpha : internal::alpha {};
+      struct alnum : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9' > {};
+      struct alpha : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z' > {};
       struct any : internal::any< internal::peek_char > {};
       struct blank : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\t' > {};
       struct digit : internal::range< internal::result_on_found::success, internal::peek_char, '0', '9' > {};
       struct ellipsis : internal::string< '.', '.', '.' > {};
-      struct eolf : internal::eolf {};
       template< char... Cs > struct forty_two : internal::rep< 42, internal::one< internal::result_on_found::success, internal::peek_char, Cs... > > {};
       struct identifier_first : internal::identifier_first {};
       struct identifier_other : internal::identifier_other {};
       struct identifier : internal::identifier {};
       template< char... Cs > struct istring : internal::istring< Cs... > {};
-      template< char... Cs > struct keyword : internal::seq< internal::string< Cs... >, internal::not_at< internal::identifier_other > > {};
+      template< char... Cs > struct keyword : internal::seq< internal::string< Cs... >, internal::not_at< internal::identifier_other > > { static_assert( sizeof...( Cs ) > 0 ); };
       struct lower : internal::range< internal::result_on_found::success, internal::peek_char, 'a', 'z' > {};
       template< char... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_char, Cs... > {};
       template< char Lo, char Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_char, Lo, Hi > {};
@@ -38,7 +36,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< char Lo, char Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_char, Lo, Hi > {};
       template< char... Cs > struct ranges : internal::ranges< internal::peek_char, Cs... > {};
       struct seven : internal::range< internal::result_on_found::success, internal::peek_char, char( 0 ), char( 127 ) > {};
-      struct shebang : internal::if_must< false, internal::string< '#', '!' >, internal::until< internal::eolf > > {};
+      struct shebang : internal::seq< internal::string< '#', '!' >, internal::until< internal::eolf > > {};
       struct space : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\n', '\r', '\t', '\v', '\f' > {};
       template< char... Cs > struct string : internal::string< Cs... > {};
       template< char C > struct three : internal::string< C, C, C > {};
@@ -47,17 +45,6 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       struct xdigit : internal::ranges< internal::peek_char, '0', '9', 'a', 'f', 'A', 'F' > {};
       // clang-format on
 
-      template<>
-      struct keyword<>
-      {
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& /*unused*/ ) noexcept
-         {
-            static_assert( internal::always_false< Input >::value, "empty keywords not allowed" );
-            return false;
-         }
-      };
-
    }  // namespace ascii
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE

data/ext/third_party/json/include/tao/json/external/pegtl/buffer_input.hpp

@@ -96,9 +96,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          return m_current.line;
       }
 
-      [[nodiscard]] std::size_t byte_in_line() const noexcept
+      [[nodiscard]] std::size_t column() const noexcept
       {
-         return m_current.byte_in_line;
+         return m_current.column;
       }
 
       [[nodiscard]] const Source& source() const noexcept
@@ -149,7 +149,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          if( m_current.data + amount > m_buffer.get() + m_maximum ) {
             throw std::overflow_error( "require beyond end of buffer" );
          }
-         if( const auto r = m_reader( m_end, ( std::min )( buffer_free_after_end(), ( std::max )( amount, Chunk ) ) ) ) {
+         if( const auto r = m_reader( m_end, ( std::min )( buffer_free_after_end(), ( std::max )( amount - buffer_occupied(), Chunk ) ) ) ) {
             m_end += r;
          }
       }

data/ext/third_party/json/include/tao/json/external/pegtl/change_action.hpp

@@ -24,9 +24,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 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 )
       {
          static_assert( !std::is_same_v< Action< void >, NewAction< void > >, "old and new action class templates are identical" );
          return Control< Rule >::template match< A, M, NewAction, Control >( in, st... );

data/ext/third_party/json/include/tao/json/external/pegtl/change_action_and_state.hpp

@@ -25,24 +25,24 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 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 )
       {
          static_assert( !std::is_same_v< Action< void >, NewAction< void > >, "old and new action class templates are identical" );
-         NewState s( static_cast< const Input& >( in ), st... );
+         NewState s( static_cast< const ParseInput& >( in ), st... );
          if( Control< Rule >::template match< A, M, NewAction, Control >( in, s ) ) {
             if constexpr( A == apply_mode::action ) {
-               Action< Rule >::success( static_cast< const Input& >( in ), s, st... );
+               Action< Rule >::success( static_cast< const ParseInput& >( in ), s, st... );
             }
             return true;
          }
          return false;
       }
 
-      template< typename Input,
+      template< typename ParseInput,
                 typename... States >
-      static void success( const Input& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
+      static void success( const ParseInput& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
       {
          s.success( in, st... );
       }

data/ext/third_party/json/include/tao/json/external/pegtl/change_action_and_states.hpp

@@ -27,14 +27,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 template< typename... >
                 class Control,
                 std::size_t... Ns,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( std::index_sequence< Ns... > /*unused*/, Input& in, States&&... st )
+      [[nodiscard]] static bool match( std::index_sequence< Ns... > /*unused*/, ParseInput& in, States&&... st )
       {
          auto t = std::tie( st... );
          if( Control< Rule >::template match< A, M, NewAction, Control >( in, std::get< Ns >( t )... ) ) {
             if constexpr( A == apply_mode::action ) {
-               Action< Rule >::success( static_cast< const Input& >( in ), st... );
+               Action< Rule >::success( static_cast< const ParseInput& >( in ), st... );
             }
             return true;
          }
@@ -48,9 +48,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 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 )
       {
          static_assert( !std::is_same_v< Action< void >, NewAction< void > >, "old and new action class templates are identical" );
          return match< Rule, A, M, Action, Control >( std::index_sequence_for< NewStates... >(), in, NewStates()..., st... );