couchbase 3.0.0.beta.1 → 3.1.0

data/ext/third_party/json/include/tao/json/ubjson.hpp

@@ -8,6 +8,7 @@
 
 #include "ubjson/consume_file.hpp"
 #include "ubjson/consume_string.hpp"
+#include "ubjson/from_binary.hpp"
 #include "ubjson/from_file.hpp"
 #include "ubjson/from_input.hpp"
 #include "ubjson/from_string.hpp"

data/ext/third_party/json/include/tao/json/ubjson/consume_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_UBJSON_CONSUME_FILE_HPP
 #define TAO_JSON_UBJSON_CONSUME_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../external/pegtl/file_input.hpp"
 
@@ -15,17 +15,17 @@
 
 namespace tao::json::ubjson
 {
-   template< typename T, template< typename... > class Traits = traits, typename F >
-   [[nodiscard]] T consume_file( F&& filename )
+   template< typename T, template< typename... > class Traits = traits >
+   [[nodiscard]] T consume_file( const std::filesystem::path& path )
    {
-      ubjson::basic_parts_parser< 1 << 24, utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      ubjson::basic_parts_parser< 1 << 24, utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       return json::consume< T, Traits >( pp );
    }
 
-   template< template< typename... > class Traits = traits, typename F, typename T >
-   void consume_file( F&& filename, T& t )
+   template< template< typename... > class Traits = traits, typename T >
+   void consume_file( const std::filesystem::path& path, T& t )
    {
-      ubjson::basic_parts_parser< 1 << 24, utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      ubjson::basic_parts_parser< 1 << 24, utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       json::consume< Traits >( pp, t );
    }
 

data/ext/third_party/json/include/tao/json/ubjson/events/from_binary.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_UBJSON_EVENTS_FROM_BINARY_HPP
+#define TAO_JSON_UBJSON_EVENTS_FROM_BINARY_HPP
+
+#include "../../binary.hpp"
+#include "../../binary_view.hpp"
+#include "../../external/pegtl/memory_input.hpp"
+
+#include "from_input.hpp"
+
+namespace tao::json::ubjson::events
+{
+   template< typename Consumer >
+   void from_binary( Consumer& consumer, const void* 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 )
+   {
+      const char* cast = static_cast< const char* >( data );
+      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( cast, cast + size, source ? source : "tao::json::ubjson::events::from_binary", byte, line, column );
+      ubjson::events::from_input( consumer, std::move( in ) );
+   }
+
+   template< typename Consumer >
+   void from_binary( Consumer& consumer, const void* 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 )
+   {
+      ubjson::events::from_binary( consumer, data, size, source.c_str(), byte, line, column );
+   }
+
+   template< typename Consumer, typename... Ts >
+   void from_binary( Consumer& consumer, const tao::binary& data, Ts&&... ts )
+   {
+      ubjson::events::from_binary( consumer, data.data(), data.size(), std::forward< Ts >( ts )... );
+   }
+
+   template< typename Consumer, typename... Ts >
+   void from_binary( Consumer& consumer, const tao::binary_view data, Ts&&... ts )
+   {
+      ubjson::events::from_binary( consumer, data.data(), data.size(), std::forward< Ts >( ts )... );
+   }
+
+}  // namespace tao::json::ubjson::events
+
+#endif

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

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_UBJSON_EVENTS_FROM_FILE_HPP
 #define TAO_JSON_UBJSON_EVENTS_FROM_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../../external/pegtl/file_input.hpp"
 #include "../../external/pegtl/parse.hpp"
@@ -15,10 +15,10 @@ namespace tao::json::ubjson::events
 {
    // Events producer to parse a file containing a UBJSON 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 >( in, consumer );
    }
 

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

@@ -14,14 +14,14 @@
 namespace tao::json::ubjson::events
 {
    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 byte_in_line = 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::ubjson::from_string", byte, line, byte_in_line );
+      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::ubjson::events::from_string", byte, line, column );
       ubjson::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 )
    {
       ubjson::events::from_string( consumer, data, size, source.c_str(), byte, line, column );
    }

data/ext/third_party/json/include/tao/json/ubjson/from_binary.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_UBJSON_FROM_BINARY_HPP
+#define TAO_JSON_UBJSON_FROM_BINARY_HPP
+
+#include <utility>
+
+#include "../events/to_value.hpp"
+#include "../events/transformer.hpp"
+
+#include "events/from_binary.hpp"
+
+namespace tao::json::ubjson
+{
+   template< template< typename... > class Traits, template< typename... > class... Transformers, typename... Ts >
+   [[nodiscard]] basic_value< Traits > basic_from_binary( Ts&&... ts )
+   {
+      json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
+      events::from_binary( consumer, std::forward< Ts >( ts )... );
+      return std::move( consumer.value );
+   }
+
+   template< template< typename... > class... Transformers, typename... Ts >
+   [[nodiscard]] value from_binary( Ts&&... ts )
+   {
+      return basic_from_binary< traits, Transformers... >( std::forward< Ts >( ts )... );
+   }
+
+}  // namespace tao::json::ubjson
+
+#endif

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

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_UBJSON_FROM_FILE_HPP
 #define TAO_JSON_UBJSON_FROM_FILE_HPP
 
-#include <string>
+#include <filesystem>
 #include <utility>
 
 #include "../events/to_value.hpp"
@@ -15,17 +15,17 @@
 namespace tao::json::ubjson
 {
    template< template< typename... > class Traits, template< typename... > class... Transformers >
-   [[nodiscard]] basic_value< Traits > basic_from_file( const std::string& filename )
+   [[nodiscard]] basic_value< Traits > basic_from_file( const std::filesystem::path& path )
    {
       json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
-      events::from_file( consumer, filename );
+      events::from_file( consumer, path );
       return std::move( consumer.value );
    }
 
    template< template< typename... > class... Transformers >
-   [[nodiscard]] value from_file( const std::string& filename )
+   [[nodiscard]] value from_file( const std::filesystem::path& path )
    {
-      return basic_from_file< traits, Transformers... >( filename );
+      return basic_from_file< traits, Transformers... >( path );
    }
 
 }  // namespace tao::json::ubjson

data/ext/third_party/json/include/tao/json/ubjson/internal/grammar.hpp

@@ -28,7 +28,8 @@ namespace tao::json
    {
       struct number
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = number;
+         using subs_t = pegtl::empty_list;
 
          template< pegtl::apply_mode A,
                    pegtl::rewind_mode M,
@@ -74,7 +75,7 @@ namespace tao::json
    namespace internal
    {
       // clang-format off
-      template<> inline const std::string errors< ubjson::internal::number >::error_message = "invalid ubjson high-precision number";
+      template<> inline const char* errors< ubjson::internal::number >::error_message = "invalid ubjson high-precision number";
       // clang-format on
 
    }  // namespace internal
@@ -153,7 +154,8 @@ namespace tao::json
       template< std::size_t L, utf8_mode V >
       struct data
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = data;
+         using subs_t = pegtl::empty_list;  // TODO?
 
          template< pegtl::apply_mode A,
                    pegtl::rewind_mode M,

data/ext/third_party/json/include/tao/json/utf8.hpp

@@ -24,7 +24,7 @@ namespace tao::json
       {
          std::size_t i = 0;
          while( i < todo ) {
-            const auto p = pegtl::internal::peek_utf8::peek( in, pegtl::internal::peek_utf8::max_input_size ).size;
+            const auto p = pegtl::internal::peek_utf8::peek( in ).size;
             if( ( p == 0 ) || ( ( i += p ) > todo ) ) {
                return false;
             }

data/ext/third_party/snappy/snappy.cc

@@ -177,6 +177,9 @@ alignas(16) const char pshufb_fill_patterns[7][16] = {
   {0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1},
 };
 
+// j * (16 / j) for all j from 0 to 7. 0 is not actually used.
+const uint8_t pattern_size_table[8] = {0, 16, 16, 15, 16, 15, 12, 14};
+
 #endif  // SNAPPY_HAVE_SSSE3
 
 // Copy [src, src+(op_limit-op)) to [op, (op_limit-op)) but faster than
@@ -248,7 +251,7 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
       // Uninitialized bytes are masked out by the shuffle mask.
       // TODO: remove annotation and macro defs once MSan is fixed.
       SNAPPY_ANNOTATE_MEMORY_IS_INITIALIZED(&pattern, sizeof(pattern));
-      pattern_size *= 16 / pattern_size;
+      pattern_size = pattern_size_table[pattern_size];
       char* op_end = std::min(op_limit, buf_limit - 15);
       while (op < op_end) {
         _mm_storeu_si128(reinterpret_cast<__m128i*>(op), pattern);
@@ -1538,7 +1541,8 @@ class SnappyScatteredWriter {
         full_size_(0),
         op_base_(NULL),
         op_ptr_(NULL),
-        op_limit_(NULL) {
+        op_limit_(NULL),
+        op_limit_min_slop_(NULL) {
   }
   char* GetOutputPtr() { return op_ptr_; }
   void SetOutputPtr(char* op) { op_ptr_ = op; }

data/ext/third_party/spdlog/CMakeLists.txt

@@ -1,14 +1,6 @@
 # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-cmake_minimum_required(VERSION 3.2)
-
-if(${CMAKE_VERSION} VERSION_LESS 3.11)
-    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-    cmake_policy(VERSION 3.11)
-endif()
-
-enable_language(C)
+cmake_minimum_required(VERSION 3.10)
 
 # ---------------------------------------------------------------------------------------
 # Start spdlog project
@@ -40,7 +32,7 @@ endif()
 
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN")
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
     set(CMAKE_CXX_EXTENSIONS ON)
 endif()
 
@@ -131,16 +123,15 @@ if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
     list(APPEND SPDLOG_SRCS src/fmt.cpp)
 endif()
 
-if(WIN32 AND SPDLOG_BUILD_SHARED)
-    list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-endif()
-
 if(SPDLOG_BUILD_SHARED)
+    if(WIN32)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
+        list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
+    endif()
     add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
     target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if(WIN32)
+    if(MSVC)
         target_compile_options(spdlog PUBLIC /wd4251 /wd4275)
-        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
     endif()
     if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
         target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
@@ -200,49 +191,25 @@ endif()
 # ---------------------------------------------------------------------------------------
 # Misc definitions according to tweak options
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_WCHAR_SUPPORT)
-    target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-endif()
-
-if(SPDLOG_WCHAR_FILENAMES)
-    target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_FILENAMES)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_FILENAMES)
-endif()
-
-if(SPDLOG_NO_EXCEPTIONS)
-    target_compile_definitions(spdlog PUBLIC SPDLOG_NO_EXCEPTIONS)
-
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_EXCEPTIONS)
-
-    if(NOT MSVC)
-        target_compile_options(spdlog PRIVATE -fno-exceptions)
+set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
+foreach(
+    SPDLOG_OPTION
+    SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    SPDLOG_WCHAR_FILENAMES
+    SPDLOG_NO_EXCEPTIONS
+    SPDLOG_CLOCK_COARSE
+    SPDLOG_PREVENT_CHILD_FD
+    SPDLOG_NO_THREAD_ID
+    SPDLOG_NO_TLS
+    SPDLOG_NO_ATOMIC_LEVELS)
+    if(${SPDLOG_OPTION})
+        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
+        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
     endif()
-endif()
-
-if(SPDLOG_CLOCK_COARSE)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_CLOCK_COARSE)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_CLOCK_COARSE)
-endif()
-
-if(SPDLOG_PREVENT_CHILD_FD)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_PREVENT_CHILD_FD)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_PREVENT_CHILD_FD)
-endif()
-
-if(SPDLOG_NO_THREAD_ID)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_NO_THREAD_ID)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_THREAD_ID)
-endif()
-
-if(SPDLOG_NO_TLS)
-    target_compile_definitions(spdlog PRIVATE SPDLOG_NO_TLS)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_TLS)
-endif()
+endforeach()
 
-if(SPDLOG_NO_ATOMIC_LEVELS)
-    target_compile_definitions(spdlog PUBLIC SPDLOG_NO_ATOMIC_LEVELS)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_ATOMIC_LEVELS)
+if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
+    target_compile_options(spdlog PRIVATE -fno-exceptions)
 endif()
 
 # ---------------------------------------------------------------------------------------

data/ext/third_party/spdlog/cmake/version.rc.in

@@ -1,5 +1,5 @@
 #define APSTUDIO_READONLY_SYMBOLS
-#include "winres.h"
+#include <windows.h>
 #undef APSTUDIO_READONLY_SYMBOLS
 
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

data/ext/third_party/spdlog/include/spdlog/async.h

@@ -35,7 +35,7 @@ template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
 struct async_factory_impl
 {
     template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
     {
         auto &registry_inst = details::registry::instance();
 
@@ -61,13 +61,13 @@ using async_factory = async_factory_impl<async_overflow_policy::block>;
 using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
 
 template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args)
 {
     return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }
 
 template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args)
 {
     return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }

data/ext/third_party/spdlog/include/spdlog/cfg/argv.h

@@ -21,7 +21,7 @@ namespace spdlog {
 namespace cfg {
 
 // search for SPDLOG_LEVEL= in the args and use it to init the levels
-void load_argv_levels(int argc, const char **argv)
+inline void load_argv_levels(int argc, const char **argv)
 {
     const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
     for (int i = 1; i < argc; i++)
@@ -30,13 +30,12 @@ void load_argv_levels(int argc, const char **argv)
         if (arg.find(spdlog_level_prefix) == 0)
         {
             auto levels_string = arg.substr(spdlog_level_prefix.size());
-            auto levels = helpers::extract_levels(levels_string);
-            details::registry::instance().update_levels(std::move(levels));
+            helpers::load_levels(levels_string);
         }
     }
 }
 
-void load_argv_levels(int argc, char **argv)
+inline void load_argv_levels(int argc, char **argv)
 {
     load_argv_levels(argc, const_cast<const char **>(argv));
 }

data/ext/third_party/spdlog/include/spdlog/cfg/env.h

@@ -17,7 +17,7 @@
 // export SPDLOG_LEVEL=debug
 //
 // turn off all logging except for logger1:
-// export SPDLOG_LEVEL="off,logger1=debug"
+// export SPDLOG_LEVEL="*=off,logger1=debug"
 //
 
 // turn off all logging except for logger1 and logger2:
@@ -25,11 +25,13 @@
 
 namespace spdlog {
 namespace cfg {
-void load_env_levels()
+inline void load_env_levels()
 {
     auto env_val = details::os::getenv("SPDLOG_LEVEL");
-    auto levels = helpers::extract_levels(env_val);
-    details::registry::instance().update_levels(std::move(levels));
+    if (!env_val.empty())
+    {
+        helpers::load_levels(env_val);
+    }
 }
 
 } // namespace cfg