Merge pull request #2011 from sjanel/bugfix/fixclangcompilation

Fix compilation error in clang 13 in C++20 mode - ambiguous call to log function

.clang-format

@@ -32,9 +32,9 @@ BraceWrapping:
   BeforeCatch:     true
   BeforeElse:      true
   IndentBraces:    false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
 BreakBeforeInheritanceComma: false
@@ -88,7 +88,7 @@ PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Right
 ReflowComments:  true
-SortIncludes:    true
+SortIncludes:    false
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: false
@@ -104,5 +104,6 @@ SpacesInSquareBrackets: false
 Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
+IndentPPDirectives: AfterHash
 ...
 

.clang-tidy

@@ -0,0 +1,54 @@
+Checks: 'cppcoreguidelines-*,
+performance-*,
+modernize-*,
+google-*,
+misc-*
+cert-*,
+readability-*,
+clang-analyzer-*,
+-performance-unnecessary-value-param,
+-modernize-use-trailing-return-type,
+-google-runtime-references,
+-misc-non-private-member-variables-in-classes,
+-readability-braces-around-statements,
+-google-readability-braces-around-statements,
+-cppcoreguidelines-avoid-magic-numbers,
+-readability-magic-numbers,
+-readability-magic-numbers,
+-cppcoreguidelines-pro-type-vararg,
+-cppcoreguidelines-pro-bounds-pointer-arithmetic,
+-cppcoreguidelines-avoid-c-arrays,
+-modernize-avoid-c-arrays,
+-cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+-readability-named-parameter,
+-cert-env33-c
+'
+
+
+WarningsAsErrors: ''
+HeaderFilterRegex: '*spdlog/[^f].*'
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+
+CheckOptions:    
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+

.gitattributes

@@ -0,0 +1 @@
+* text=false

.gitignore

@@ -1,5 +1,5 @@
 # Auto generated files
-build/*
+build/*
 *.slo
 *.lo
 *.o
@@ -34,6 +34,9 @@ build/*
 # Codelite
 .codelite
 
+# KDevelop
+*.kdev4
+
 # .orig files
 *.orig
 
@@ -46,6 +49,7 @@ example/*
 !example/example.sln
 !example/example.vcxproj
 !example/CMakeLists.txt
+!example/meson.build
 !example/multisink.cpp
 !example/jni
 
@@ -65,4 +69,15 @@ install_manifest.txt
 /tests/logs/*
 
 # idea
-.idea/
+.idea/
+cmake-build-*/
+*.db
+*.ipch
+*.filters
+*.db-wal
+*.opendb
+*.db-shm
+*.vcxproj
+*.tcl
+*.user
+*.sln

.travis.yml

@@ -5,92 +5,117 @@
 sudo: required
 language: cpp
 
+# gcc t
 addons: &gcc48
   apt:
     packages:
       - g++-4.8
-      - valgrind
     sources:
       - ubuntu-toolchain-r-test
 
+# gcc 7.0
 addons: &gcc7
   apt:
     packages:
       - g++-7
-      - valgrind
     sources:
       - ubuntu-toolchain-r-test
 
+
+# gcc 9.0
+addons: &gcc9
+  apt:
+    packages:
+      - g++-9
+    sources:
+      - ubuntu-toolchain-r-test
+
+
+# Clang 3.5
 addons: &clang35
   apt:
     packages:
       - clang-3.5
-      - valgrind
     sources:
       - ubuntu-toolchain-r-test
       - llvm-toolchain-precise-3.5
+      
 
-addons: &clang6
+addons: &clang10
   apt:
     packages:
-      - clang-6.0
-      - valgrind
+      - clang-10
+      - lldb-10
+      - lld-10
     sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-6.0
+      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main"
+        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+        
+addons: &clang12
+  apt:
+    packages:
+      - clang-12
+      - lldb-12
+      - lld-12
+    sources:
+      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main"
+        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"        
+
 
 matrix:
   include:
-    # Test gcc-4.8: C++11, Build=Debug/Release
-    - env: GCC_VERSION=4.8 BUILD_TYPE=Debug CPP=11
-      os: linux
-      addons: *gcc48
-
+    # Test gcc-4.8: C++11, Build=Release
     - env: GCC_VERSION=4.8 BUILD_TYPE=Release CPP=11
       os: linux
       addons: *gcc48
-  
+      
+    # Test gcc-7: C++11, Build=Release
     - env: GCC_VERSION=7 BUILD_TYPE=Release CPP=11
       os: linux
       addons: *gcc7
-
-    # Test clang-3.5: C++11, Build=Debug/Release
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Debug CPP=11
+      
+     # Test gcc-9: C++17, Build=Release
+    - env: GCC_VERSION=9 BUILD_TYPE=Release CPP=17
       os: linux
-      addons: *clang35
+      addons: *gcc9
 
+    # Test clang-3.5: C++11, Build=Release
     - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11
       os: linux
       addons: *clang35
 
-      # Test clang-6.0: C++11, Build=Debug, ASAN=On
-    - env: CLANG_VERSION=6.0 BUILD_TYPE=Debug CPP=11 ASAN=On TSAN=Off
-      os: linux
-      addons: *clang6
-      
-    - env: CLANG_VERSION=6.0 BUILD_TYPE=Release CPP=11 ASAN=On TSAN=Off
-      os: linux
-      addons: *clang6
-      
-      # Test clang-6.0: C++11, Build=Debug, TSAN=On
-    - env: CLANG_VERSION=6.0 BUILD_TYPE=Debug CPP=11 ASAN=Off TSAN=On
-      os: linux
-      addons: *clang6
-      
-    - env: CLANG_VERSION=6.0 BUILD_TYPE=Release CPP=11 ASAN=Off TSAN=On
-      os: linux
-      addons: *clang6
+    # Text osx
+    - env: BUILD_TYPE=Release CPP=11 ASAN=Off TSAN=Off
+      os: osx
 
+    # Test clang-10.0: C++11, Build=Release
+    - env: CLANG_VERSION=10 BUILD_TYPE=Release CPP=11 ASAN=On
+      os: linux
+      dist: bionic
+      addons: *clang10
+      
+    # Test clang-10.0: C++17, Build=Debug
+    - env: CLANG_VERSION=10 BUILD_TYPE=Debug CPP=17 ASAN=Off
+      os: linux
+      dist: bionic
+      addons: *clang10
+      
+            
+    # Test clang-12.0: C++17, Build=Debug
+    - env: CLANG_VERSION=12 BUILD_TYPE=Debug CPP=17 ASAN=Off
+      os: linux
+      dist: bionic
+      addons: *clang12
+                        
 
 before_script:
   - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
   - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export CXX="clang++" CC="clang"; fi
   - which $CXX
   - which $CC
-  - which valgrind
   - $CXX --version
   - cmake --version
-  - valgrind --version
 
 script:
   - cd ${TRAVIS_BUILD_DIR}
@@ -100,14 +125,14 @@ script:
       --warn-uninitialized \
       -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
       -DCMAKE_CXX_STANDARD=$CPP \
-      -DSPDLOG_BUILD_EXAMPLES=ON \
+      -DSPDLOG_BUILD_EXAMPLE=ON \
+      -DSPDLOG_BUILD_EXAMPLE_HO=ON \
+      -DSPDLOG_BUILD_WARNINGS=ON \
       -DSPDLOG_BUILD_BENCH=OFF \
-      -DSPDLOG_SANITIZE_ADDRESS=$ASAN \
-      -DSPDLOG_SANITIZE_THREAD=$TSAN
+      -DSPDLOG_BUILD_TESTS=ON \
+      -DSPDLOG_BUILD_TESTS_HO=OFF \
+      -DSPDLOG_SANITIZE_ADDRESS=$ASAN 
+      
   - make VERBOSE=1 -j2
   - ctest -j2 --output-on-failure
-
-
-
-notifications:
-  email: false
+  

CMakeLists.txt

@@ -1,139 +1,319 @@
-#
-# Copyright(c) 2015 Ruslan Baratov.
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-#
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+cmake_minimum_required(VERSION 3.10)
+
+# ---------------------------------------------------------------------------------------
+# Start spdlog project
+# ---------------------------------------------------------------------------------------
+include(cmake/utils.cmake)
+include(cmake/ide.cmake)
+
+spdlog_extract_version()
+
+project(spdlog VERSION ${SPDLOG_VERSION} LANGUAGES CXX)
+message(STATUS "Build spdlog: ${SPDLOG_VERSION}")
 
-cmake_minimum_required(VERSION 3.1)
-project(spdlog VERSION 1.1.0 LANGUAGES CXX)
-include(CTest)
-include(CMakeDependentOption)
 include(GNUInstallDirs)
 
-#---------------------------------------------------------------------------------------
-# set default build to release
-#---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------
+# Set CMake policies to support later version behaviour
+# ---------------------------------------------------------------------------------------
+if(POLICY CMP0077)
+    cmake_policy(SET CMP0077 NEW) # option() honors variables already set
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Set default build to release
+# ---------------------------------------------------------------------------------------
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
 endif()
 
-message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
+# ---------------------------------------------------------------------------------------
+# Compiler config
+# ---------------------------------------------------------------------------------------
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+# make sure __cplusplus is defined when using msvc and enable parallel build
+if(MSVC)
+    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus /MP")
+endif()
 
-#---------------------------------------------------------------------------------------
-# compiler config
-#---------------------------------------------------------------------------------------
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    add_compile_options("-Wall")
-    add_compile_options("-Wextra")
-    add_compile_options("-pedantic")
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
+    set(CMAKE_CXX_EXTENSIONS ON)
 endif()
 
-#---------------------------------------------------------------------------------------
-# address sanitizers check
-#---------------------------------------------------------------------------------------
-include(cmake/sanitizers.cmake)
+# ---------------------------------------------------------------------------------------
+# Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
+# ---------------------------------------------------------------------------------------
+# Check if spdlog is being used directly or via add_subdirectory, but allow overriding
+if(NOT DEFINED SPDLOG_MASTER_PROJECT)
+    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+        set(SPDLOG_MASTER_PROJECT ON)
+    else()
+        set(SPDLOG_MASTER_PROJECT OFF)
+    endif()
+endif()
+
+option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)
+
+# build shared option
+option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
+
+# precompiled headers option
+option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)
+
+# example options
+option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
+option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
+
+# testing options
+option(SPDLOG_BUILD_TESTS "Build tests" OFF)
+option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
+
+# bench options
+option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
+
+# sanitizer options
+option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
+
+# warning options
+option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
+
+# install options
+option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
+option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
+option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
+option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
+
+if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
+    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
+endif()
+
+# misc tweakme options
+if(WIN32)
+    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
+    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
+else()
+    set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
+    set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
+else()
+    set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
+endif()
+
+option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
+option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
+option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
+option(
+    SPDLOG_NO_ATOMIC_LEVELS
+    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
+    OFF)
+option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
+
+# clang-tidy
+if(${CMAKE_VERSION} VERSION_GREATER "3.5")
+    option(SPDLOG_TIDY "run clang-tidy" OFF)
+endif()
+
+if(SPDLOG_TIDY)
+    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    message(STATUS "Enabled clang-tidy")
+endif()
+
+find_package(Threads REQUIRED)
+message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
+# ---------------------------------------------------------------------------------------
+# Static/Shared library (shared not supported in windows yet)
+# ---------------------------------------------------------------------------------------
+set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)
+
+if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    list(APPEND SPDLOG_SRCS src/fmt.cpp)
+endif()
+
+if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
+    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(MSVC)
+        target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
+                                             /wd4275>)
+    endif()
+    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
+    endif()
+else()
+    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
+endif()
 
-#---------------------------------------------------------------------------------------
-# spdlog target
-#---------------------------------------------------------------------------------------
-add_library(spdlog INTERFACE)
 add_library(spdlog::spdlog ALIAS spdlog)
 
-option(SPDLOG_BUILD_EXAMPLES "Build examples" ON)
-option(SPDLOG_BUILD_BENCH "Build benchmarks" ON)
+target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
+target_include_directories(spdlog PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+                                         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+target_link_libraries(spdlog PUBLIC Threads::Threads)
+spdlog_enable_warnings(spdlog)
 
-cmake_dependent_option(SPDLOG_BUILD_TESTING
-    "Build spdlog tests" ON
-    "BUILD_TESTING" OFF
-)
+set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR})
+set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
 
-target_include_directories(
-    spdlog
-    INTERFACE
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-)
-
-set(HEADER_BASE "${CMAKE_CURRENT_SOURCE_DIR}/include")
-
-if(SPDLOG_BUILD_EXAMPLES)
-    add_subdirectory(example)
+if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
+    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
 endif()
 
-if(SPDLOG_BUILD_TESTING)
+# ---------------------------------------------------------------------------------------
+# Header only version
+# ---------------------------------------------------------------------------------------
+add_library(spdlog_header_only INTERFACE)
+add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
+
+target_include_directories(spdlog_header_only INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+                                                        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
+
+# ---------------------------------------------------------------------------------------
+# Use fmt package if using external fmt
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT TARGET fmt::fmt)
+        find_package(fmt CONFIG REQUIRED)
+    endif()
+    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
+    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
+
+    # use external fmt-header-nly
+    if(SPDLOG_FMT_EXTERNAL_HO)
+        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
+        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
+    else() # use external compile fmt
+        target_link_libraries(spdlog PUBLIC fmt::fmt)
+        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
+    endif()
+
+    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Add required libraries for Android CMake build
+# ---------------------------------------------------------------------------------------
+if(ANDROID)
+    target_link_libraries(spdlog PUBLIC log)
+    target_link_libraries(spdlog_header_only INTERFACE log)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Misc definitions according to tweak options
+# ---------------------------------------------------------------------------------------
+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
+    SPDLOG_DISABLE_DEFAULT_LOGGER)
+    if(${SPDLOG_OPTION})
+        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
+        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
+    endif()
+endforeach()
+
+if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
+    target_compile_options(spdlog PRIVATE -fno-exceptions)
+endif()
+
+# ---------------------------------------------------------------------------------------
+# Build binaries
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating example(s)")
+    add_subdirectory(example)
+    spdlog_enable_warnings(example)
+    if(SPDLOG_BUILD_EXAMPLE_HO)
+        spdlog_enable_warnings(example_header_only)
+    endif()
+endif()
+
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating tests")
+    enable_testing()
     add_subdirectory(tests)
 endif()
 
-if(SPDLOG_BUILD_BENCH)
+if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+    message(STATUS "Generating benchmarks")
     add_subdirectory(bench)
 endif()
 
-#---------------------------------------------------------------------------------------
-# Install/export targets and files
-#---------------------------------------------------------------------------------------
-# set files and directories
-set(config_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
-set(include_install_dir "${CMAKE_INSTALL_INCLUDEDIR}")
-set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-set(version_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
-set(project_config "${PROJECT_NAME}Config.cmake")
-set(pkg_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc")
-set(targets_export_name "${PROJECT_NAME}Targets")
-set(namespace "${PROJECT_NAME}::")
+# ---------------------------------------------------------------------------------------
+# Install
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_INSTALL)
+    message(STATUS "Generating install")
+    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
+    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
+    set(config_targets_file "spdlogConfigTargets.cmake")
+    set(version_config_file "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfigVersion.cmake")
+    set(export_dest_dir "${CMAKE_INSTALL_LIBDIR}/cmake/spdlog")
+    set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    set(pkg_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc")
 
-# generate package version file
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(
-    "${version_config}" COMPATIBILITY SameMajorVersion
-)
+    # ---------------------------------------------------------------------------------------
+    # Include files
+    # ---------------------------------------------------------------------------------------
+    install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
+    install(
+        TARGETS spdlog spdlog_header_only
+        EXPORT spdlog
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-# configure pkg config file
-configure_file("cmake/spdlog.pc.in" "${pkg_config}" @ONLY)
+    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
+                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
+    endif()
 
-# install targets
-install(
-    TARGETS spdlog
-    EXPORT "${targets_export_name}"
-)
+    # ---------------------------------------------------------------------------------------
+    # Install pkg-config file
+    # ---------------------------------------------------------------------------------------
+    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
+    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
+    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
+    configure_file("cmake/${PROJECT_NAME}.pc.in" "${pkg_config}" @ONLY)
+    install(FILES "${pkg_config}" DESTINATION "${pkgconfig_install_dir}")
 
-# install headers
-install(
-    DIRECTORY "${HEADER_BASE}/${PROJECT_NAME}"
-    DESTINATION "${include_install_dir}"
-)
+    # ---------------------------------------------------------------------------------------
+    # Install CMake config files
+    # ---------------------------------------------------------------------------------------
+    install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})
 
-# install project version file
-install(
-    FILES "${version_config}"
-    DESTINATION "${config_install_dir}"
-)
+    include(CMakePackageConfigHelpers)
+    configure_file("${project_config_in}" "${project_config_out}" @ONLY)
 
-# install pkg config file
-install(
-    FILES "${pkg_config}"
-    DESTINATION "${pkgconfig_install_dir}"
-)
+    write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
+    install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}")
 
-# install project config file
-install(
-    EXPORT "${targets_export_name}"
-    NAMESPACE "${namespace}"
-    DESTINATION "${config_install_dir}"
-    FILE ${project_config}
-)
-
-# export build directory config file
-export(
-    EXPORT ${targets_export_name}
-    NAMESPACE "${namespace}"
-    FILE ${project_config}
-)
-
-# register project in CMake user registry
-export(PACKAGE ${PROJECT_NAME})
-
-file(GLOB_RECURSE spdlog_include_SRCS "${HEADER_BASE}/*.h")
-add_custom_target(spdlog_headers_for_ide SOURCES ${spdlog_include_SRCS})
+    # ---------------------------------------------------------------------------------------
+    # Support creation of installable packages
+    # ---------------------------------------------------------------------------------------
+    include(cmake/spdlogCPack.cmake)
+endif()

INSTALL

@@ -1,13 +1,24 @@
-spdlog is header only library.
-Just copy the files to your build tree and use a C++11 compiler
+Header only version:
+==================================================================
+Just copy the files to your build tree and use a C++11 compiler.
+Or use CMake:
+  add_executable(example_header_only example.cpp)
+  target_link_libraries(example_header_only spdlog::spdlog_header_only)
+
+
+Compiled library version:
+==================================================================
+CMake:
+  add_executable(example example.cpp)
+  target_link_libraries(example spdlog::spdlog)
+
+Or copy src/spdlog.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
 
 Tested on:
 gcc 4.8.1 and above
 clang 3.5
 Visual Studio 2013
 
-gcc 4.8 flags: --std==c++11 -pthread -O3 -flto -Wl,--no-as-needed
-gcc 4.9 flags: --std=c++11 -pthread -O3 -flto
 
 
-see the makefile in the example folder
+

LICENSE

@@ -20,3 +20,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
+-- NOTE: Third party dependency used by this software --
+This software depends on the fmt lib (MIT License),
+and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
+

README.md

@@ -1,122 +1,103 @@
 # spdlog
 
-Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.org/gabime/spdlog.svg?branch=master)](https://travis-ci.org/gabime/spdlog)  [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true)](https://ci.appveyor.com/project/gabime/spdlog)
+Very fast, header-only/compiled, C++ logging library. [![Build Status](https://travis-ci.com/gabime/spdlog.svg?branch=v1.x)](https://travis-ci.com/gabime/spdlog)  [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
 
+## Install 
+#### Header only version
+Copy the source [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
 
-## Install
-#### Just copy the headers:
-
-* Copy the source [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
-
-#### Or use your favorite package manager:
-
-* Ubuntu: `apt-get install libspdlog-dev`
-* Homebrew: `brew install spdlog`
-* FreeBSD:  `cd /usr/ports/devel/spdlog/ && make install clean`
-* Fedora: `yum install spdlog`
-* Gentoo: `emerge dev-libs/spdlog`
-* Arch Linux: `yaourt -S spdlog-git`
-* vcpkg: `vcpkg install spdlog`
- 
+#### Static lib version (recommended - much faster compile times)
+```console
+$ git clone https://github.com/gabime/spdlog.git
+$ cd spdlog && mkdir build && cd build
+$ cmake .. && make -j
+```
+      
+   see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
 
 ## Platforms
- * Linux, FreeBSD, Solaris, AIX
- * Windows (vc 2013+, cygwin)
- * Mac OSX (clang 3.5+)
+ * Linux, FreeBSD, OpenBSD, Solaris, AIX
+ * Windows (msvc 2013+, cygwin)
+ * macOS (clang 3.5+)
  * Android
 
+## Package managers:
+* Homebrew: `brew install spdlog`
+* MacPorts: `sudo port install spdlog`
+* FreeBSD:  `cd /usr/ports/devel/spdlog/ && make install clean`
+* Fedora: `dnf install spdlog`
+* Gentoo: `emerge dev-libs/spdlog`
+* Arch Linux: `pacman -S spdlog`
+* vcpkg: `vcpkg install spdlog`
+* conan: `spdlog/[>=1.4.1]`
+* conda: `conda install -c conda-forge spdlog`
+* build2: ```depends: spdlog ^1.8.2```
+
+
+
 ## Features
-* Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
-* Headers only, just copy and use.
-* Feature rich using the excellent [fmt](https://github.com/fmtlib/fmt) library.
-* Fast asynchronous mode (optional)
+* Very fast (see [benchmarks](#benchmarks) below).
+* Headers only or compiled
+* Feature rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
+* Asynchronous mode (optional)
 * [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
-* Conditional Logging
 * Multi/Single threaded loggers.
 * Various log targets:
     * Rotating log files.
     * Daily log files.
     * Console logging (colors supported).
     * syslog.
-    * Windows debugger (```OutputDebugString(..)```)
-    * Easily extendable with custom log targets  (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface).
-* Severity based filtering - threshold levels can be modified in runtime as well as in compile time.
-
-
-
-## Benchmarks
-
-Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
-
-#### Synchronous mode
-```
-*******************************************************************************
-Single thread, 1,000,000 iterations
-*******************************************************************************
-basic_st...		    Elapsed: 0.226664	4,411,806/sec
-rotating_st...	 	    Elapsed: 0.214339	4,665,499/sec
-daily_st...		    Elapsed: 0.211292	4,732,797/sec
-null_st...		    Elapsed: 0.102815	9,726,227/sec
-
-*******************************************************************************
-10 threads sharing same logger, 1,000,000 iterations
-*******************************************************************************
-basic_mt...		    Elapsed: 0.882268	1,133,441/sec
-rotating_mt...              Elapsed: 0.875515	1,142,184/sec
-daily_mt...		    Elapsed: 0.879573	1,136,915/sec
-null_mt...		    Elapsed: 0.220114	4,543,105/sec
-``` 
-#### Asynchronous mode
-```
-*******************************************************************************
-10 threads sharing same logger, 1,000,000 iterations 
-*******************************************************************************
-async...		Elapsed: 0.429088	2,330,524/sec
-async...		Elapsed: 0.411501	2,430,126/sec
-async...		Elapsed: 0.428979	2,331,116/sec
-
-```
-
+    * Windows event log.
+    * Windows debugger (```OutputDebugString(..)```).
+    * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
+* Log filtering - log levels can be modified in runtime as well as in compile time.
+* Support for loading log levels from argv or from environment var.
+* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display later on demand.
+ 
 ## Usage samples
 
+#### Basic usage
+```c++
+#include "spdlog/spdlog.h"
+
+int main() 
+{
+    spdlog::info("Welcome to spdlog!");
+    spdlog::error("Some error message with arg: {}", 1);
+    
+    spdlog::warn("Easy padding in numbers like {:08d}", 12);
+    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    spdlog::info("Support for floats {:03.2f}", 1.23456);
+    spdlog::info("Positional args are {1} {0}..", "too", "supported");
+    spdlog::info("{:<30}", "left aligned");
+    
+    spdlog::set_level(spdlog::level::debug); // Set global log level to debug
+    spdlog::debug("This message should be displayed..");    
+    
+    // change log pattern
+    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
+    
+    // Compile time log levels
+    // define SPDLOG_ACTIVE_LEVEL to desired level
+    SPDLOG_TRACE("Some trace message with param {}", 42);
+    SPDLOG_DEBUG("Some debug message");
+}
+
+```
+---
+#### Create stdout/stderr logger object
 ```c++
 #include "spdlog/spdlog.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 void stdout_example()
 {
     // create color multi threaded logger
-    auto console = spdlog::stdout_color_mt("console");
-    console->info("Welcome to spdlog!");
-    console->error("Some error message with arg: {}", 1);
-
-    auto err_logger = spdlog::stderr_color_mt("stderr");
-    err_logger->error("Some error message");
-
-    // Formatting examples
-    console->warn("Easy padding in numbers like {:08d}", 12);
-    console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    console->info("Support for floats {:03.2f}", 1.23456);
-    console->info("Positional args are {1} {0}..", "too", "supported");
-    console->info("{:<30}", "left aligned");
-
+    auto console = spdlog::stdout_color_mt("console");    
+    auto err_logger = spdlog::stderr_color_mt("stderr");    
     spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
-    console->debug("This message should not be displayed!");
-    console->set_level(spdlog::level::trace); // Set specific logger's log level
-    console->debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
-    console->info("This an info message with custom format");
-
-    // Compile time log levels
-    // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
-    SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
-    SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
 }
 ```
+
 ---
 #### Basic file logger
 ```c++
@@ -125,12 +106,11 @@ void basic_logfile_example()
 {
     try 
     {
-        auto my_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
+        auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
     }
     catch (const spdlog::spdlog_ex &ex)
     {
         std::cout << "Log init failed: " << ex.what() << std::endl;
-        return 1;
     }
 }
 ```
@@ -141,7 +121,9 @@ void basic_logfile_example()
 void rotating_example()
 {
     // Create a file rotating logger with 5mb size max and 3 rotated files
-    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+    auto max_size = 1048576 * 5;
+    auto max_files = 3;
+    auto logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", max_size, max_files);
 }
 ```
 
@@ -153,20 +135,80 @@ void rotating_example()
 void daily_example()
 {
     // Create a daily logger - a new file is created every day on 2:30am
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+    auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
 }
 
 ```
 
+---
+#### Backtrace support
+```c++
+// Debug messages can be stored in a ring buffer instead of being logged immediately.
+// This is useful in order to display debug logs only when really nededed (e.g. when error happens).
+// When needed, call dump_backtrace() to see them.
+
+spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. Older messages will be dropped.
+// or my_logger->enable_backtrace(32)..
+for(int i = 0; i < 100; i++)
+{
+  spdlog::debug("Backtrace message {}", i); // not logged yet..
+}
+// e.g. if some error happened:
+spdlog::dump_backtrace(); // log them now! show the last 32 messages
+
+// or my_logger->dump_backtrace(32)..
+```
+
 ---
 #### Periodic flush
 ```c++
 // periodically flush all *registered* loggers every 3 seconds:
-// warning: only use if all your loggers are thread safe!
+// warning: only use if all your loggers are thread safe ("_mt" loggers)
 spdlog::flush_every(std::chrono::seconds(3));
 
 ```
 
+---
+#### Stopwatch
+```c++
+// Stopwatch support for spdlog
+#include "spdlog/stopwatch.h"
+void stopwatch_example()
+{
+    spdlog::stopwatch sw;    
+    spdlog::debug("Elapsed {}", sw);
+    spdlog::debug("Elapsed {:.3}", sw);       
+}
+
+```
+
+---
+#### Log binary data in hex
+```c++
+// many types of std::container<char> types can be used.
+// ranges are supported too.
+// format flags:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
+// {:a} - show ASCII if :n is not set.
+
+#include "spdlog/fmt/bin_to_hex.h"
+
+void binary_example()
+{
+    auto console = spdlog::get("console");
+    std::array<char, 80> buf;
+    console->info("Binary example: {}", spdlog::to_hex(buf));
+    console->info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
+    // more examples:
+    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
+}
+
+```
 
 ---
 #### Logger with multi sinks - each with different format and log level
@@ -244,6 +286,37 @@ void user_defined_example()
 }
 
 ```
+
+---
+#### User defined flags in the log pattern
+```c++ 
+// Log patterns can contain custom flags.
+// the following example will add new flag '%*' - which will be bound to a <my_formatter_flag> instance.
+#include "spdlog/pattern_formatter.h"
+class my_formatter_flag : public spdlog::custom_flag_formatter
+{
+public:
+    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
+    {
+        std::string some_txt = "custom-flag";
+        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
+    }
+
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
+        return spdlog::details::make_unique<my_formatter_flag>();
+    }
+};
+
+void custom_flags_example()
+{    
+    auto formatter = std::make_unique<spdlog::pattern_formatter>();
+    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
+    spdlog::set_formatter(std::move(formatter));
+}
+
+```
+
 ---
 #### Custom error handler
 ```c++
@@ -255,6 +328,7 @@ void err_handler_example()
 }
 
 ```
+
 ---
 #### syslog 
 ```c++
@@ -269,14 +343,95 @@ void syslog_example()
 ---
 #### Android example 
 ```c++
-#incude "spdlog/sinks/android_sink.h"
+#include "spdlog/sinks/android_sink.h"
 void android_example()
 {
     std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger("android", tag);
+    auto android_logger = spdlog::android_logger_mt("android", tag);
     android_logger->critical("Use \"adb shell logcat\" to view this message.");
 }
 ```
 
+---
+#### Load log levels from env variable or from argv
+
+```c++
+#include "spdlog/cfg/env.h"
+int main (int argc, char *argv[])
+{
+    spdlog::cfg::load_env_levels();
+    // or from command line:
+    // ./example SPDLOG_LEVEL=info,mylogger=trace
+    // #include "spdlog/cfg/argv.h" // for loading levels from argv
+    // spdlog::cfg::load_argv_levels(argc, argv);
+}
+```
+So then you can:
+
+```console
+$ export SPDLOG_LEVEL=info,mylogger=trace
+$ ./example
+```
+
+---
+## Benchmarks
+
+Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+
+#### Synchronous mode
+```
+[info] **************************************************************
+[info] Single thread, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_st         Elapsed: 0.17 secs        5,777,626/sec
+[info] rotating_st      Elapsed: 0.18 secs        5,475,894/sec
+[info] daily_st         Elapsed: 0.20 secs        5,062,659/sec
+[info] empty_logger     Elapsed: 0.07 secs       14,127,300/sec
+[info] **************************************************************
+[info] C-string (400 bytes). Single thread, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_st         Elapsed: 0.41 secs        2,412,483/sec
+[info] rotating_st      Elapsed: 0.72 secs        1,389,196/sec
+[info] daily_st         Elapsed: 0.42 secs        2,393,298/sec
+[info] null_st          Elapsed: 0.04 secs       27,446,957/sec
+[info] **************************************************************
+[info] 10 threads, competing over the same logger object, 1,000,000 iterations
+[info] **************************************************************
+[info] basic_mt         Elapsed: 0.60 secs        1,659,613/sec
+[info] rotating_mt      Elapsed: 0.62 secs        1,612,493/sec
+[info] daily_mt         Elapsed: 0.61 secs        1,638,305/sec
+[info] null_mt          Elapsed: 0.16 secs        6,272,758/sec
+```
+#### Asynchronous mode
+```
+[info] -------------------------------------------------
+[info] Messages     : 1,000,000
+[info] Threads      : 10
+[info] Queue        : 8,192 slots
+[info] Queue memory : 8,192 x 272 = 2,176 KB 
+[info] -------------------------------------------------
+[info] 
+[info] *********************************
+[info] Queue Overflow Policy: block
+[info] *********************************
+[info] Elapsed: 1.70784 secs     585,535/sec
+[info] Elapsed: 1.69805 secs     588,910/sec
+[info] Elapsed: 1.7026 secs      587,337/sec
+[info] 
+[info] *********************************
+[info] Queue Overflow Policy: overrun
+[info] *********************************
+[info] Elapsed: 0.372816 secs    2,682,285/sec
+[info] Elapsed: 0.379758 secs    2,633,255/sec
+[info] Elapsed: 0.373532 secs    2,677,147/sec
+
+```
+
 ## Documentation
 Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
+
+---
+
+Thanks to [JetBrains](https://www.jetbrains.com/?from=spdlog) for donating product licenses to help develop **spdlog** <a href="https://www.jetbrains.com/?from=spdlog"><img src="logos/jetbrains-variant-4.svg" width="94" align="center" /></a>
+
+

appveyor.yml

@@ -1,32 +1,78 @@
 version: 1.0.{build}
-image: Visual Studio 2015
+image: Visual Studio 2017
 environment:
   matrix:
-  - GENERATOR: '"MinGW Makefiles"'
-    BUILD_TYPE: Debug
-  - GENERATOR: '"MinGW Makefiles"'
-    BUILD_TYPE: Release
-  - GENERATOR: '"Visual Studio 14 2015"'
-    BUILD_TYPE: Debug
-  - GENERATOR: '"Visual Studio 14 2015"'
-    BUILD_TYPE: Release
-  - GENERATOR: '"Visual Studio 14 2015 Win64"'
-    BUILD_TYPE: Debug
-  - GENERATOR: '"Visual Studio 14 2015 Win64"'
-    BUILD_TYPE: Release
+    - GENERATOR: '"Visual Studio 14 2015"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 14 2015"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 14 2015 Win64"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 14 2015 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+    - GENERATOR: '"Visual Studio 15 2017 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'ON'
+      BUILD_EXAMPLE: 'OFF'
+    - GENERATOR: '"Visual Studio 16 2019" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'OFF'
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
 build_script:
-- cmd: >-
-    set
+  - cmd: >-
+      set
 
-    mkdir build
+      mkdir build
 
-    cd build
+      cd build
 
-    set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
+      set PATH=%PATH%;C:\Program Files\Git\usr\bin
 
-    set PATH=C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
+      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=ON ..
 
-    cmake .. -G %GENERATOR% -DCMAKE_BUILD_TYPE=%BUILD_TYPE%
+      cmake --build . --config %BUILD_TYPE%
 
-    cmake --build . --config %BUILD_TYPE%
-test: off
+before_test:
+  - set PATH=%PATH%;C:\projects\spdlog\build\%BUILD_TYPE%
+  
+test_script:
+  - C:\projects\spdlog\build\tests\%BUILD_TYPE%\spdlog-utests.exe

bench/CMakeLists.txt

@@ -1,43 +1,40 @@
-# *************************************************************************/
-# * Copyright (c) 2015 Ruslan Baratov.                                    */
-# *                                                                       */
-# * Permission is hereby granted, free of charge, to any person obtaining */
-# * a copy of this software and associated documentation files (the       */
-# * "Software"), to deal in the Software without restriction, including   */
-# * without limitation the rights to use, copy, modify, merge, publish,   */
-# * distribute, sublicense, and/or sell copies of the Software, and to    */
-# * permit persons to whom the Software is furnished to do so, subject to */
-# * the following conditions:                                             */
-# *                                                                       */
-# * The above copyright notice and this permission notice shall be        */
-# * included in all copies or substantial portions of the Software.       */
-# *                                                                       */
-# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-# * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-# * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-# * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-# * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-# * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-# * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-# *************************************************************************/
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-cmake_minimum_required(VERSION 3.1)
-project(SpdlogBench CXX)
+cmake_minimum_required(VERSION 3.10)
+project(spdlog_bench CXX)
 
 if(NOT TARGET spdlog)
-  # Stand-alone build
-  find_package(spdlog CONFIG REQUIRED)
+    # Stand-alone build
+    find_package(spdlog CONFIG REQUIRED)
 endif()
 
 find_package(Threads REQUIRED)
+find_package(benchmark CONFIG)
+if(NOT benchmark_FOUND)
+    message(STATUS "Using CMake Version ${CMAKE_VERSION}")
+    if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.11.0")
+        # User can fetch googlebenchmark
+        message(STATUS "Downloading GoogleBenchmark")
+        include(FetchContent)
+        set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE INTERNAL "")
+        # Do not build and run googlebenchmark tests
+        FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.5.2)
+
+        FetchContent_MakeAvailable(googlebenchmark)
+    else()
+        message(FATAL_ERROR "GoogleBenchmark is missing. Use CMake >= 3.11 or download it")
+    endif()
+endif()
 
 add_executable(bench bench.cpp)
-target_link_libraries(bench spdlog::spdlog Threads::Threads)
+spdlog_enable_warnings(bench)
+target_link_libraries(bench PRIVATE spdlog::spdlog)
 
 add_executable(async_bench async_bench.cpp)
-target_link_libraries(async_bench spdlog::spdlog Threads::Threads)
+target_link_libraries(async_bench PRIVATE spdlog::spdlog)
 
 add_executable(latency latency.cpp)
-target_link_libraries(latency spdlog::spdlog Threads::Threads)
+target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)
 
-file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
+add_executable(formatter-bench formatter-bench.cpp)
+target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)

bench/Makefile

@@ -1,27 +0,0 @@
-CXX	?= g++
-CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../include -fmax-errors=1
-CXX_RELEASE_FLAGS = -Ofast -flto -Wl,--no-as-needed
-
-
-binaries=bench latency async_bench
-
-all: $(binaries)
-
-bench: bench.cpp
-	$(CXX) bench.cpp -o bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-	
-
-async_bench: async_bench.cpp
-	$(CXX) async_bench.cpp -o async_bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-	
-	
-latency: latency.cpp
-	$(CXX) latency.cpp -o latency $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-				
-
-.PHONY: clean
-
-clean:
-	rm -f *.o logs/* $(binaries)
-
-rebuild: clean all

bench/async_bench.cpp

@@ -6,10 +6,16 @@
 //
 // bench.cpp : spdlog benchmarks
 //
+#include "spdlog/spdlog.h"
 #include "spdlog/async.h"
 #include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/spdlog.h"
+
+#ifdef SPDLOG_FMT_EXTERNAL
+#    include <fmt/format.h>
+#else
+#    include "spdlog/fmt/bundled/format.h"
+#endif
+
 #include "utils.h"
 #include <atomic>
 #include <iostream>
@@ -25,6 +31,11 @@ using namespace utils;
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
 
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4996) // disable fopen warning under msvc
+#endif                              // _MSC_VER
+
 int count_lines(const char *filename)
 {
     int counter = 0;
@@ -35,24 +46,41 @@ int count_lines(const char *filename)
         if ('\n' == ch)
             counter++;
     }
+    fclose(infile);
 
     return counter;
 }
+
+void verify_file(const char *filename, int expected_count)
+{
+    spdlog::info("Verifying {} to contain {} line..", filename, expected_count);
+    auto count = count_lines(filename);
+    if (count != expected_count)
+    {
+        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count, expected_count);
+        exit(1);
+    }
+    spdlog::info("Line count OK ({})\n", count);
+}
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+
 int main(int argc, char *argv[])
 {
 
     int howmany = 1000000;
-    int queue_size = howmany + 2;
+    int queue_size = std::min(howmany + 2, 8192);
     int threads = 10;
     int iters = 3;
 
     try
     {
-        auto console = spdlog::stdout_color_mt("console");
+        spdlog::set_pattern("[%^%l%$] %v");
         if (argc == 1)
         {
-            console->set_pattern("%v");
-            console->info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
+            spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
             return 0;
         }
 
@@ -61,38 +89,56 @@ int main(int argc, char *argv[])
         if (argc > 2)
             threads = atoi(argv[2]);
         if (argc > 3)
+        {
             queue_size = atoi(argv[3]);
+            if (queue_size > 500000)
+            {
+                spdlog::error("Max queue size allowed: 500,000");
+                exit(1);
+            }
+        }
 
         if (argc > 4)
             iters = atoi(argv[4]);
 
-        console->info("-------------------------------------------------");
-        console->info("Messages: {:14n}", howmany);
-        console->info("Threads : {:14n}", threads);
-        console->info("Queue   : {:14n}", queue_size);
-        console->info("Iters   : {:>14n}", iters);
-        console->info("-------------------------------------------------");
+        auto slot_size = sizeof(spdlog::details::async_msg);
+        spdlog::info("-------------------------------------------------");
+        spdlog::info("Messages     : {:L}", howmany);
+        spdlog::info("Threads      : {:L}", threads);
+        spdlog::info("Queue        : {:L} slots", queue_size);
+        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
+        spdlog::info("Total iters  : {:L}", iters);
+        spdlog::info("-------------------------------------------------");
 
         const char *filename = "logs/basic_async.log";
-
+        spdlog::info("");
+        spdlog::info("*********************************");
+        spdlog::info("Queue Overflow Policy: block");
+        spdlog::info("*********************************");
         for (int i = 0; i < iters; i++)
         {
             auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
             auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
             auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
             bench_mt(howmany, std::move(logger), threads);
-            auto count = count_lines(filename);
-
-            if (count != howmany)
-            {
-                console->error("Test failed. {} has {:n} lines instead of {:n}", filename, count, howmany);
-                exit(1);
-            }
-            else
-            {
-                console->info("Line count OK ({:n})\n", count);
-            }
+            // verify_file(filename, howmany);
         }
+
+        spdlog::info("");
+        spdlog::info("*********************************");
+        spdlog::info("Queue Overflow Policy: overrun");
+        spdlog::info("*********************************");
+        // do same test but discard oldest if queue is full instead of blocking
+        filename = "logs/basic_async-overrun.log";
+        for (int i = 0; i < iters; i++)
+        {
+            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+            auto logger =
+                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::overrun_oldest);
+            bench_mt(howmany, std::move(logger), threads);
+        }
+        spdlog::shutdown();
     }
     catch (std::exception &ex)
     {
@@ -134,5 +180,5 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_co
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::get("console")->info("Elapsed: {} secs\t {:n}/sec", delta_d, int(howmany / delta_d));
+    spdlog::info("Elapsed: {} secs\t {:L}/sec", delta_d, int(howmany / delta_d));
 }

bench/bench.cpp

@@ -6,99 +6,138 @@
 //
 // bench.cpp : spdlog benchmarks
 //
-#include "spdlog/async.h"
+#include "spdlog/spdlog.h"
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/spdlog.h"
+
+#ifdef SPDLOG_FMT_EXTERNAL
+#    include <fmt/locale.h>
+#else
+#    include "spdlog/fmt/bundled/format.h"
+#endif
+
 #include "utils.h"
 #include <atomic>
 #include <cstdlib> // EXIT_FAILURE
-#include <iostream>
 #include <memory>
 #include <string>
 #include <thread>
 
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
 void bench(int howmany, std::shared_ptr<spdlog::logger> log);
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count);
+
+// void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log);
+// void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log);
+
+static const size_t file_size = 30 * 1024 * 1024;
+static const size_t rotating_files = 5;
+static const int max_threads = 1000;
+
+void bench_threaded_logging(size_t threads, int iters)
+{
+    spdlog::info("**************************************************************");
+    spdlog::info(fmt::format(std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
+    spdlog::info("**************************************************************");
+
+    auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
+    bench_mt(iters, std::move(basic_mt), threads);
+    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
+    basic_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(basic_mt_tracing), threads);
+
+    spdlog::info("");
+    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
+    bench_mt(iters, std::move(rotating_mt), threads);
+    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
+    rotating_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(rotating_mt_tracing), threads);
+
+    spdlog::info("");
+    auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
+    bench_mt(iters, std::move(daily_mt), threads);
+    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
+    daily_mt_tracing->enable_backtrace(32);
+    bench_mt(iters, std::move(daily_mt_tracing), threads);
+
+    spdlog::info("");
+    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
+    empty_logger->set_level(spdlog::level::off);
+    bench(iters, empty_logger);
+    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
+    empty_logger_tracing->set_level(spdlog::level::off);
+    empty_logger_tracing->enable_backtrace(32);
+    bench(iters, empty_logger_tracing);
+}
+
+void bench_single_threaded(int iters)
+{
+    spdlog::info("**************************************************************");
+    spdlog::info(fmt::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
+    spdlog::info("**************************************************************");
+
+    auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
+    bench(iters, std::move(basic_st));
+
+    auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
+    bench(iters, std::move(basic_st_tracing));
+
+    spdlog::info("");
+    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
+    bench(iters, std::move(rotating_st));
+    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
+    rotating_st_tracing->enable_backtrace(32);
+    bench(iters, std::move(rotating_st_tracing));
+
+    spdlog::info("");
+    auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
+    bench(iters, std::move(daily_st));
+    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
+    daily_st_tracing->enable_backtrace(32);
+    bench(iters, std::move(daily_st_tracing));
+
+    spdlog::info("");
+    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
+    empty_logger->set_level(spdlog::level::off);
+    bench(iters, empty_logger);
+
+    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
+    empty_logger_tracing->set_level(spdlog::level::off);
+    empty_logger_tracing->enable_backtrace(32);
+    bench(iters, empty_logger_tracing);
+}
 
 int main(int argc, char *argv[])
 {
-
-    int howmany = 1000000;
-    int queue_size = howmany + 2;
-    int threads = 10;
-    int file_size = 30 * 1024 * 1024;
-    int rotating_files = 5;
-
+    spdlog::set_automatic_registration(false);
+    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
+    int iters = 250000;
+    size_t threads = 4;
     try
     {
 
         if (argc > 1)
-            howmany = atoi(argv[1]);
-        if (argc > 2)
-            threads = atoi(argv[2]);
-        if (argc > 3)
-            queue_size = atoi(argv[3]);
-
-        cout << "******************************************************************"
-                "*************\n";
-        cout << "Single thread, " << format(howmany) << " iterations" << endl;
-        cout << "******************************************************************"
-                "*************\n";
-
-        auto basic_st = spdlog::basic_logger_mt("basic_st", "logs/basic_st.log", true);
-        bench(howmany, basic_st);
-
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
-        bench(howmany, rotating_st);
-
-        auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
-        bench(howmany, daily_st);
-
-        bench(howmany, spdlog::create<null_sink_st>("null_st"));
-
-        cout << "\n****************************************************************"
-                "***************\n";
-        cout << threads << " threads sharing same logger, " << format(howmany) << " iterations" << endl;
-        cout << "******************************************************************"
-                "*************\n";
-
-        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
-        bench_mt(howmany, basic_mt, threads);
-
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
-        bench_mt(howmany, rotating_mt, threads);
-
-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
-        bench_mt(howmany, daily_mt, threads);
-        bench_mt(howmany, spdlog::create<null_sink_mt>("null_mt"), threads);
-
-        cout << "\n****************************************************************"
-                "***************\n";
-        cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations " << endl;
-        cout << "******************************************************************"
-                "*************\n";
-
-        for (int i = 0; i < 3; ++i)
         {
-            spdlog::init_thread_pool(queue_size, 1);
-            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("async", "logs/basic_async.log", true);
-            bench_mt(howmany, as, threads);
-            spdlog::drop("async");
+            iters = std::stoi(argv[1]);
         }
+        if (argc > 2)
+        {
+            threads = std::stoul(argv[2]);
+        }
+
+        if (threads > max_threads)
+        {
+            throw std::runtime_error(fmt::format("Number of threads exceeds maximum({})", max_threads));
+        }
+
+        bench_single_threaded(iters);
+        bench_threaded_logging(1, iters);
+        bench_threaded_logging(threads, iters);
     }
     catch (std::exception &ex)
     {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
+        spdlog::error(ex.what());
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
@@ -106,8 +145,10 @@ int main(int argc, char *argv[])
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
     using std::chrono::high_resolution_clock;
-    cout << log->name() << "...\t\t" << flush;
+
     auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
     {
@@ -117,24 +158,28 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
 
-    cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
+    spdlog::info(
+        fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count)
 {
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
     using std::chrono::high_resolution_clock;
-    cout << log->name() << "...\t\t" << flush;
-    vector<thread> threads;
+
+    std::vector<std::thread> threads;
+    threads.reserve(thread_count);
     auto start = high_resolution_clock::now();
-    for (int t = 0; t < thread_count; ++t)
+    for (size_t t = 0; t < thread_count; ++t)
     {
-        threads.push_back(std::thread([&]() {
-            for (int j = 0; j < howmany / thread_count; j++)
+        threads.emplace_back([&]() {
+            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++)
             {
                 log->info("Hello logger: msg number {}", j);
             }
-        }));
+        });
     }
 
     for (auto &t : threads)
@@ -144,5 +189,58 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
+    spdlog::info(
+        fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
+    spdlog::drop(log->name());
 }
+
+/*
+void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using std::chrono::high_resolution_clock;
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+
+    auto orig_default = spdlog::default_logger();
+    spdlog::set_default_logger(log);
+    auto start = high_resolution_clock::now();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        spdlog::info("Hello logger: msg number {}", i);
+    }
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::drop(log->name());
+    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
+}
+
+void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using std::chrono::high_resolution_clock;
+    using std::chrono::duration;
+    using std::chrono::duration_cast;
+
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
+
+    auto orig_default = spdlog::default_logger();
+    spdlog::set_default_logger(log);
+    auto start = high_resolution_clock::now();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        spdlog::log(spdlog::level::info, msg);
+    }
+
+    auto delta = high_resolution_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>>(delta).count();
+    spdlog::drop(log->name());
+    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
+}
+
+*/

bench/formatter-bench.cpp

@@ -0,0 +1,80 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include "benchmark/benchmark.h"
+
+#include "spdlog/spdlog.h"
+#include "spdlog/pattern_formatter.h"
+
+void bench_formatter(benchmark::State &state, std::string pattern)
+{
+    auto formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern);
+    spdlog::memory_buf_t dest;
+    std::string logger_name = "logger-name";
+    const char *text = "Hello. This is some message with length of 80                                   ";
+
+    spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
+    spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
+
+    for (auto _ : state)
+    {
+        dest.clear();
+        formatter->format(msg, dest);
+        benchmark::DoNotOptimize(dest);
+    }
+}
+
+void bench_formatters()
+{
+    // basic patterns(single flag)
+    std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
+    std::vector<std::string> basic_patterns;
+    for (auto &flag : all_flags)
+    {
+        auto pattern = std::string("%") + flag;
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+
+        //        pattern = std::string("%16") + flag;
+        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+        //
+        //        // bench center padding
+        //        pattern = std::string("%=16") + flag;
+        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+    }
+
+    // complex patterns
+    std::vector<std::string> patterns = {
+        "[%D %X] [%l] [%n] %v",
+        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v",
+        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
+    };
+    for (auto &pattern : patterns)
+    {
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)->Iterations(2500000);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+
+    spdlog::set_pattern("[%^%l%$] %v");
+    if (argc != 2)
+    {
+        spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
+        exit(1);
+    }
+
+    std::string pattern = argv[1];
+    if (pattern == "all")
+    {
+        bench_formatters();
+    }
+    else
+    {
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
+    }
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
+}

bench/latency.cpp

@@ -6,146 +6,172 @@
 //
 // latency.cpp : spdlog latency benchmarks
 //
+
+#include "benchmark/benchmark.h"
+
+#include "spdlog/spdlog.h"
 #include "spdlog/async.h"
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/spdlog.h"
-#include "utils.h"
-#include <atomic>
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <thread>
 
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log);
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-int main(int, char *[])
+void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
 {
-    std::srand(static_cast<unsigned>(std::time(nullptr))); // use current time as seed for random generator
-    int howmany = 1000000;
-    int queue_size = howmany + 2;
-    int threads = 10;
-    int file_size = 30 * 1024 * 1024;
-    int rotating_files = 5;
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
 
-    try
+    for (auto _ : state)
     {
-
-        cout << "******************************************************************"
-                "*************\n";
-        cout << "Single thread\n";
-        cout << "******************************************************************"
-                "*************\n";
-
-        auto basic_st = spdlog::basic_logger_mt("basic_st", "logs/basic_st.log", true);
-        bench(howmany, basic_st);
-
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
-        bench(howmany, rotating_st);
-
-        auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
-        bench(howmany, daily_st);
-
-        bench(howmany, spdlog::create<null_sink_st>("null_st"));
-
-        cout << "\n****************************************************************"
-                "***************\n";
-        cout << threads << " threads sharing same logger\n";
-        cout << "******************************************************************"
-                "*************\n";
-
-        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
-        bench_mt(howmany, basic_mt, threads);
-
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
-        bench_mt(howmany, rotating_mt, threads);
-
-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
-        bench_mt(howmany, daily_mt, threads);
-        bench(howmany, spdlog::create<null_sink_st>("null_mt"));
-
-        cout << "\n****************************************************************"
-                "***************\n";
-        cout << "async logging.. " << threads << " threads sharing same logger\n";
-        cout << "******************************************************************"
-                "*************\n";
-
-        for (int i = 0; i < 3; ++i)
-        {
-            spdlog::init_thread_pool(queue_size, 1);
-            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("async", "logs/basic_async.log", true);
-            bench_mt(howmany, as, threads);
-            spdlog::drop("async");
-        }
+        logger->info(msg);
     }
-    catch (std::exception &ex)
-    {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
 }
 
-void bench(int howmany, std::shared_ptr<spdlog::logger> log)
+void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
 {
-    using namespace std::chrono;
-    using chrono::high_resolution_clock;
-    using chrono::milliseconds;
-    using chrono::nanoseconds;
-
-    cout << log->name() << "...\t\t" << flush;
-    nanoseconds total_nanos = nanoseconds::zero();
-    for (auto i = 0; i < howmany; ++i)
+    int i = 0;
+    for (auto _ : state)
     {
-        auto start = high_resolution_clock::now();
-        log->info("Hello logger: msg number {}", i);
-        auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
-        total_nanos += delta_nanos;
+        logger->info("Hello logger: msg number {}...............", ++i);
     }
-
-    auto avg = total_nanos.count() / howmany;
-    cout << format(avg) << " ns/call" << endl;
 }
 
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
+void bench_logger_fmt_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
 {
-    using namespace std::chrono;
-    using chrono::high_resolution_clock;
-    using chrono::milliseconds;
-    using chrono::nanoseconds;
-
-    cout << log->name() << "...\t\t" << flush;
-    vector<thread> threads;
-    std::atomic<nanoseconds::rep> total_nanos{0};
-    for (int t = 0; t < thread_count; ++t)
+    int i = 0;
+    for (auto _ : state)
     {
-        threads.push_back(std::thread([&]() {
-            for (int j = 0; j < howmany / thread_count; j++)
-            {
-                auto start = high_resolution_clock::now();
-                log->info("Hello logger: msg number {}", j);
-                auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
-                total_nanos += delta_nanos.count();
-            }
-        }));
+        logger->info(FMT_STRING("Hello logger: msg number {}..............."), ++i);
+        ;
+    }
+}
+
+void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
+    int i = 0;
+    benchmark::DoNotOptimize(i);      // prevent unused warnings
+    benchmark::DoNotOptimize(logger); // prevent unused warnings
+    for (auto _ : state)
+    {
+        SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
+        SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
+    }
+}
+
+#ifdef __linux__
+void bench_dev_null()
+{
+    auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
+    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
+    spdlog::drop("/dev/null_st");
+
+    auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
+    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
+    spdlog::drop("/dev/null_mt");
+}
+#endif // __linux__
+
+int main(int argc, char *argv[])
+{
+    using spdlog::sinks::null_sink_mt;
+    using spdlog::sinks::null_sink_st;
+
+    size_t file_size = 30 * 1024 * 1024;
+    size_t rotating_files = 5;
+    int n_threads = benchmark::CPUInfo::Get().num_cpus;
+
+    auto full_bench = argc > 1 && std::string(argv[1]) == "full";
+
+    // disabled loggers
+    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    disabled_logger->set_level(spdlog::level::off);
+    benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
+    // with backtrace of 64
+    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    tracing_disabled_logger->enable_backtrace(64);
+    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
+
+    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
+    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
+    benchmark::RegisterBenchmark("null_sink_fmt_string", bench_logger_fmt_string, null_logger_st);
+    // with backtrace of 64
+    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    tracing_null_logger_st->enable_backtrace(64);
+    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
+
+#ifdef __linux
+    bench_dev_null();
+#endif // __linux__
+
+    if (full_bench)
+    {
+        // basic_st
+        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
+        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
+        spdlog::drop("basic_st");
+        // with backtrace of 64
+        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
+        tracing_basic_st->enable_backtrace(64);
+        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
+        spdlog::drop("tracing_basic_st");
+
+        // rotating st
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
+        spdlog::drop("rotating_st");
+        // with backtrace of 64
+        auto tracing_rotating_st =
+            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
+        spdlog::drop("tracing_rotating_st");
+
+        // daily st
+        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
+        spdlog::drop("daily_st");
+        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
+        spdlog::drop("tracing_daily_st");
+
+        //
+        // Multi threaded bench, 10 loggers using same logger concurrently
+        //
+        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
+
+        // basic_mt
+        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
+        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("basic_mt");
+
+        // rotating mt
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("rotating_mt");
+
+        // daily mt
+        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
+        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
+        spdlog::drop("daily_mt");
     }
 
-    for (auto &t : threads)
-    {
-        t.join();
-    };
+    // async
+    auto queue_size = 1024 * 1024 * 3;
+    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
+    auto async_logger = std::make_shared<spdlog::async_logger>(
+        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
+    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
 
-    auto avg = total_nanos / howmany;
-    cout << format(avg) << " ns/call" << endl;
+    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
+        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
+    async_logger_tracing->enable_backtrace(32);
+    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
+
+    benchmark::Initialize(&argc, argv);
+    benchmark::RunSpecifiedBenchmarks();
 }

bench/logs/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore

bench/mem

@@ -1,19 +0,0 @@
-#!/bin/sh
-
-if [ $# -lt 1 ]; then
-  echo "usage: $0 <program>"
-fi
-
-PROG=$1
-
-if [ ! -x "$PROG" ]; then
-  echo $PROG not found or not executable.
-  exit 1
-fi
-
-$* &
-PID=$!
-
-while `kill -0 $PID 2>/dev/null`; do
-  ps -eo size,pid,user,pcpu,command --sort -size | awk '{ line=1 ; hr=$1/1024 ; printf("%13.2f Mb ",hr); } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | grep -v grep | grep -v $0 | grep $PROG
-done

bench/spdlog-async.cpp

@@ -1,77 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#include <atomic>
-#include <chrono>
-#include <cstdlib>
-#include <iostream>
-#include <thread>
-#include <vector>
-
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-
-using namespace std;
-
-int main(int argc, char *argv[])
-{
-    using namespace std::chrono;
-    using clock = steady_clock;
-
-    int thread_count = 10;
-    if (argc > 1)
-        thread_count = std::atoi(argv[1]);
-
-    int howmany = 1000000;
-    spdlog::init_thread_pool(howmany, 1);
-
-    auto logger = spdlog::create_async_logger<spdlog::sinks::basic_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
-    logger->set_pattern("[%Y-%m-%d %T.%F]: %L %t %v");
-
-    std::cout << "To stop, press <Enter>" << std::endl;
-    std::atomic<bool> run{true};
-    std::thread stoper(std::thread([&run]() {
-        std::cin.get();
-        run = false;
-    }));
-
-    while (run)
-    {
-        std::atomic<int> msg_counter{0};
-        std::vector<std::thread> threads;
-
-        auto start = clock::now();
-        for (int t = 0; t < thread_count; ++t)
-        {
-            threads.push_back(std::thread([&]() {
-                while (true)
-                {
-                    int counter = ++msg_counter;
-                    if (counter > howmany)
-                        break;
-                    logger->info("spdlog message #{}: This is some text for your pleasure", counter);
-                }
-            }));
-        }
-
-        for (auto &t : threads)
-        {
-            t.join();
-        }
-
-        duration<float> delta = clock::now() - start;
-        float deltaf = delta.count();
-        auto rate = howmany / deltaf;
-
-        std::cout << "Total: " << howmany << std::endl;
-        std::cout << "Threads: " << thread_count << std::endl;
-        std::cout << "Delta = " << std::fixed << deltaf << " seconds" << std::endl;
-        std::cout << "Rate = " << std::fixed << rate << "/sec" << std::endl;
-    } // while
-
-    stoper.join();
-
-    return 0;
-}

cmake/Config.cmake.in

@@ -1,24 +0,0 @@
-# *************************************************************************/
-# * Copyright (c) 2015 Ruslan Baratov.                                    */
-# *                                                                       */
-# * Permission is hereby granted, free of charge, to any person obtaining */
-# * a copy of this software and associated documentation files (the       */
-# * "Software"), to deal in the Software without restriction, including   */
-# * without limitation the rights to use, copy, modify, merge, publish,   */
-# * distribute, sublicense, and/or sell copies of the Software, and to    */
-# * permit persons to whom the Software is furnished to do so, subject to */
-# * the following conditions:                                             */
-# *                                                                       */
-# * The above copyright notice and this permission notice shall be        */
-# * included in all copies or substantial portions of the Software.       */
-# *                                                                       */
-# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-# * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-# * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-# * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-# * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-# * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-# * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-# *************************************************************************/
-
-include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")

cmake/ide.cmake

@@ -0,0 +1,18 @@
+# ---------------------------------------------------------------------------------------
+# IDE support for headers
+# ---------------------------------------------------------------------------------------
+set(SPDLOG_HEADERS_DIR "${CMAKE_CURRENT_LIST_DIR}/../include")
+
+file(GLOB SPDLOG_TOP_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/*.h")
+file(GLOB SPDLOG_DETAILS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/details/*.h")
+file(GLOB SPDLOG_SINKS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h")
+file(GLOB SPDLOG_FMT_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h")
+file(GLOB SPDLOG_FMT_BUNDELED_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h")
+set(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS}
+                       ${SPDLOG_FMT_BUNDELED_HEADERS})
+
+source_group("Header Files\\spdlog" FILES ${SPDLOG_TOP_HEADERS})
+source_group("Header Files\\spdlog\\details" FILES ${SPDLOG_DETAILS_HEADERS})
+source_group("Header Files\\spdlog\\sinks" FILES ${SPDLOG_SINKS_HEADERS})
+source_group("Header Files\\spdlog\\fmt" FILES ${SPDLOG_FMT_HEADERS})
+source_group("Header Files\\spdlog\\fmt\\bundled\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS})

cmake/pch.h.in

@@ -0,0 +1,258 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// details/pattern_formatter-inl.h
+// fmt/bin_to_hex.h
+// fmt/bundled/format-inl.h
+#include <cctype>
+
+// details/file_helper-inl.h
+// details/os-inl.h
+// fmt/bundled/core.h
+// fmt/bundled/posix.h
+// logger-inl.h
+// sinks/daily_file_sink.h
+// sinks/stdout_sinks.h
+#include <cstdio>
+
+// details/os-inl.h
+// fmt/bundled/posix.h
+#include <cstdlib>
+
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// fmt/bundled/core.h
+// fmt/bundled/format-inl.h
+#include <cstring>
+
+// details/os-inl.h
+// details/os.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// fmt/bundled/chrono.h
+// sinks/daily_file_sink.h
+// sinks/rotating_file_sink-inl.h
+#include <ctime>
+
+// fmt/bundled/format-inl.h
+#include <climits>
+
+// fmt/bundled/format-inl.h
+#include <cwchar>
+
+// fmt/bundled/format-inl.h
+// fmt/bundled/format.h
+#include <cmath>
+
+// fmt/bundled/format-inl.h
+#include <cstdarg>
+
+// details/file_helper-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/posix.h
+// sinks/rotating_file_sink-inl.h
+#include <cerrno>
+
+// details/circular_q.h
+// details/thread_pool-inl.h
+// fmt/bundled/format-inl.h
+#include <cassert>
+
+// async_logger-inl.h
+// cfg/helpers-inl.h
+// log_levels.h
+// common.h
+// details/file_helper-inl.h
+// details/log_msg.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/registry-inl.h
+// details/registry.h
+// details/tcp_client-windows.h
+// details/tcp_client.h
+// fmt/bundled/core.h
+// sinks/android_sink.h
+// sinks/ansicolor_sink.h
+// sinks/basic_file_sink.h
+// sinks/daily_file_sink.h
+// sinks/dup_filter_sink.h
+// sinks/msvc_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/syslog_sink.h
+// sinks/tcp_sink.h
+// sinks/win_eventlog_sink.h
+// sinks/wincolor_sink.h
+// spdlog.h:
+#include <string>
+
+// cfg/helpers-inl.h
+// fmt/bundled/chrono.h
+#include <sstream>
+
+// fmt/bundled/ostream.h
+// sinks/ostream_sink.h
+#include <ostream>
+
+// cfg/log_levels.h
+// details/registry-inl.h
+// details/registry.h
+#include <unordered_map>
+
+// details/circular_q.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/thread_pool.h
+// fmt/bundled/compile.h
+// logger.h
+// sinks/dist_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/win_eventlog_sink.h
+#include <vector>
+
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// sinks/ansicolor_sink.h
+// sinks/syslog_sink.h
+// sinks/systemd_sink.h
+// sinks/wincolor_sink.h
+#include <array>
+
+// details/file_helper-inl.h
+// details/file_helper.h
+// sinks/rotating_file_sink-inl.h
+#include <tuple>
+
+// details/os-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/printf.h
+#include <limits>
+
+// common.h
+// details/backtracer.h
+// details/null_mutex.h
+#include <atomic>
+
+// common.h
+// details/backtracer.h
+// details/null_mutex.h
+#include <locale>
+
+// common.h
+#include <initializer_list>
+
+// common.h
+#include <exception>
+
+// common.h
+// details/fmt_helper.h
+// fmt/bundled/core.h
+// fmt/bundled/ranges.h
+#include <type_traits>
+
+// cfg/helpers-inl.h
+// details/null_mutex.h
+// details/pattern_formatter-inl.h
+#include <utility>
+
+// async.h
+// async_logger-inl.h
+// common.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// fmt/bundled/format.h
+// sinks/ansicolor_sink.h
+// sinks/base_sink-inl.h
+// sinks/dist_sink.h
+// sinks/stdout_sinks-inl.h
+// sinks/wincolor_sink.h
+// spdlog.h
+#include <memory>
+
+// async.h
+// common.h
+// details/backtracer.h
+// details/periodic_worker.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// sinks/tcp_sink.h
+// spdlog.h
+#include <functional>
+
+// details/mpmc_blocking_q.h
+// details/periodic_worker.h
+#include <condition_variable>
+
+// details/os-inl.h
+// fmt/bundled/format.h
+// fmt/bundled/printf.h
+// sinks/dist_sink.h
+#include <algorithm>
+
+// common.h
+// details/file_helper-inl.h
+// details/fmt_helper.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/pattern_formatter.h
+// details/periodic_worker.h
+// details/registry-inl.h
+// details/registry.h
+// details/thread_pool.h
+// fmt/bundled/chrono.h
+// sinks/android_sink.h
+// sinks/daily_file_sink.h
+// sinks/dup_filter_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/tcp_sink.h
+// spdlog.h
+#include <chrono>
+
+// details/file_helper-inl.h
+// details/os-inl.h
+// details/pattern_formatter-inl.h
+// details/periodic_worker.h
+// details/thread_pool.h
+// sinks/android_sink.h
+#include <thread>
+
+// async.h
+// details/backtracer.h
+// details/console_globals.h
+// details/mpmc_blocking_q.h
+// details/pattern_formatter-inl.h
+// details/periodic_worker.h
+// details/registry.h
+// sinks/android_sink.h
+// sinks/ansicolor_sink.h
+// sinks/basic_file_sink.h
+// sinks/daily_file_sink.h
+// sinks/dist_sink.h
+// sinks/dup_filter_sink.h
+// sinks/msvc_sink.h
+// sinks/null_sink.h
+// sinks/ostream_sink.h
+// sinks/ringbuffer_sink.h
+// sinks/rotating_file_sink-inl.h
+// sinks/rotating_file_sink.h
+// sinks/tcp_sink.h
+// sinks/win_eventlog_sink.h
+// sinks/wincolor_sink.h
+//
+// color_sinks.cpp
+// file_sinks.cpp
+// spdlog.cpp
+// stdout_sinks.cpp
+#include <mutex>
+
+// spdlog
+#include <spdlog/common.h>

cmake/sanitizers.cmake

@@ -1,21 +0,0 @@
-if(SPDLOG_SANITIZE_THREAD AND SPDLOG_SANITIZE_ADDRESS)
-    message(FATAL_ERROR "AddressSanitizer is not compatible with ThreadSanitizer.")
-endif()
-
-if(SPDLOG_SANITIZE_ADDRESS)
-    message(STATUS "AddressSanitizer enabled")
-    set(SANITIZER_FLAGS "-fsanitize=address,undefined")
-    add_compile_options("-fno-sanitize=signed-integer-overflow")
-endif()
-
-if(SPDLOG_SANITIZE_THREAD)
-    message(STATUS "ThreadSanitizer enabled")
-    set(SANITIZER_FLAGS "-fsanitize=thread")
-endif()
-
-if(SPDLOG_SANITIZE_THREAD OR SPDLOG_SANITIZE_ADDRESS)
-    add_compile_options(${SANITIZER_FLAGS})
-    add_compile_options("-fno-sanitize-recover=all")
-    add_compile_options("-fno-omit-frame-pointer")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAGS} -fuse-ld=gold")
-endif()

cmake/spdlog.pc.in

@@ -1,6 +1,13 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-includedir=${prefix}/include
-
-Name: @PROJECT_NAME@
-Description: Super fast C++ logging library. 
-Version: @PROJECT_VERSION@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+includedir=${prefix}/include
+libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
+
+Name: lib@PROJECT_NAME@
+Description: Fast C++ logging library.
+URL: https://github.com/gabime/@PROJECT_NAME@
+Version: @SPDLOG_VERSION@
+CFlags: -I${includedir} @PKG_CONFIG_DEFINES@
+Libs: -L${libdir} -lspdlog -pthread
+Requires: @PKG_CONFIG_REQUIRES@
+

cmake/spdlogCPack.cmake

@@ -0,0 +1,60 @@
+set(CPACK_GENERATOR "TGZ;ZIP" CACHE STRING "Semicolon separated list of generators")
+
+set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
+set(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR}" "${PROJECT_NAME}" ALL .)
+
+set(CPACK_PROJECT_URL "https://github.com/gabime/spdlog")
+set(CPACK_PACKAGE_VENDOR "Gabi Melman")
+set(CPACK_PACKAGE_CONTACT "Gabi Melman <gmelman1@gmail.com>")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Fast C++ logging library")
+set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
+if(PROJECT_VERSION_TWEAK)
+    set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})
+endif()
+set(CPACK_PACKAGE_RELOCATABLE ON CACHE BOOL "Build relocatable package")
+
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
+set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
+set(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})
+set(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${CPACK_PROJECT_URL})
+set(CPACK_RPM_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
+set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
+
+if(CPACK_PACKAGE_NAME)
+    set(CPACK_RPM_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+else()
+    set(CPACK_RPM_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_DEBIAN_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
+    set(CPACK_RPM_PACKAGE_NAME "${PROJECT_NAME}")
+    set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
+endif()
+
+if(CPACK_RPM_PACKAGE_RELEASE)
+    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}-${CPACK_RPM_PACKAGE_RELEASE}")
+endif()
+if(CPACK_DEBIAN_PACKAGE_RELEASE)
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}-${CPACK_DEBIAN_PACKAGE_RELEASE}")
+endif()
+
+if(CPACK_RPM_PACKAGE_ARCHITECTURE)
+    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.${CPACK_RPM_PACKAGE_ARCHITECTURE}")
+endif()
+if(CPACK_DEBIAN_PACKAGE_ARCHITECTURE)
+    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
+endif()
+set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.rpm")
+set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.deb")
+
+if(NOT CPACK_PACKAGE_RELOCATABLE)
+    # Depend on pkgconfig rpm to create the system pkgconfig folder
+    set(CPACK_RPM_PACKAGE_REQUIRES pkgconfig)
+    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+        "${CPACK_PACKAGING_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif()
+
+include(CPack)

cmake/spdlogConfig.cmake.in

@@ -0,0 +1,15 @@
+# Copyright(c) 2019 spdlog authors
+# Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+find_package(Threads REQUIRED)
+
+set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)
+set(config_targets_file @config_targets_file@)
+
+if(SPDLOG_FMT_EXTERNAL)
+    include(CMakeFindDependencyMacro)
+    find_dependency(fmt CONFIG)
+endif()
+
+
+include("${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}")

cmake/utils.cmake

@@ -0,0 +1,62 @@
+# Get spdlog version from include/spdlog/version.h and put it in SPDLOG_VERSION
+function(spdlog_extract_version)
+    file(READ "${CMAKE_CURRENT_LIST_DIR}/include/spdlog/version.h" file_contents)
+    string(REGEX MATCH "SPDLOG_VER_MAJOR ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract major version number from spdlog/version.h")
+    endif()
+    set(ver_major ${CMAKE_MATCH_1})
+
+    string(REGEX MATCH "SPDLOG_VER_MINOR ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract minor version number from spdlog/version.h")
+    endif()
+
+    set(ver_minor ${CMAKE_MATCH_1})
+    string(REGEX MATCH "SPDLOG_VER_PATCH ([0-9]+)" _ "${file_contents}")
+    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
+        message(FATAL_ERROR "Could not extract patch version number from spdlog/version.h")
+    endif()
+    set(ver_patch ${CMAKE_MATCH_1})
+
+    set(SPDLOG_VERSION_MAJOR ${ver_major} PARENT_SCOPE)
+    set(SPDLOG_VERSION_MINOR ${ver_minor} PARENT_SCOPE)
+    set(SPDLOG_VERSION_PATCH ${ver_patch} PARENT_SCOPE)
+    set(SPDLOG_VERSION "${ver_major}.${ver_minor}.${ver_patch}" PARENT_SCOPE)
+endfunction()
+
+# Turn on warnings on the given target
+function(spdlog_enable_warnings target_name)
+    if(SPDLOG_BUILD_WARNINGS)
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+            list(APPEND MSVC_OPTIONS "/W3")
+            if(MSVC_VERSION GREATER 1900) # Allow non fatal security warnings for msvc 2015
+                list(APPEND MSVC_OPTIONS "/WX")
+            endif()
+        endif()
+
+        target_compile_options(
+            ${target_name}
+            PRIVATE $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
+                    -Wall
+                    -Wextra
+                    -Wconversion
+                    -pedantic
+                    -Werror
+                    -Wfatal-errors>
+                    $<$<CXX_COMPILER_ID:MSVC>:${MSVC_OPTIONS}>)
+    endif()
+endfunction()
+
+# Enable address sanitizer (gcc/clang only)
+function(spdlog_enable_sanitizer target_name)
+    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
+    endif()
+    message(STATUS "Address sanitizer enabled")
+    target_compile_options(${target_name} PRIVATE -fsanitize=address,undefined)
+    target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)
+    target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)
+    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
+    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
+endfunction()

cmake/version.rc.in

@@ -0,0 +1,42 @@
+#define APSTUDIO_READONLY_SYMBOLS
+#include <windows.h>
+#undef APSTUDIO_READONLY_SYMBOLS
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
+ PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "spdlog dll\0"
+            VALUE "FileVersion", "@SPDLOG_VERSION@.0\0"
+            VALUE "InternalName", "spdlog.dll\0"
+            VALUE "LegalCopyright", "Copyright (C) spdlog\0"
+            VALUE "ProductName", "spdlog\0"
+            VALUE "ProductVersion", "@SPDLOG_VERSION@.0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+
+
+
+

example/CMakeLists.txt

@@ -1,43 +1,23 @@
-# *************************************************************************/
-# * Copyright (c) 2015 Ruslan Baratov.                                    */
-# *                                                                       */
-# * Permission is hereby granted, free of charge, to any person obtaining */
-# * a copy of this software and associated documentation files (the       */
-# * "Software"), to deal in the Software without restriction, including   */
-# * without limitation the rights to use, copy, modify, merge, publish,   */
-# * distribute, sublicense, and/or sell copies of the Software, and to    */
-# * permit persons to whom the Software is furnished to do so, subject to */
-# * the following conditions:                                             */
-# *                                                                       */
-# * The above copyright notice and this permission notice shall be        */
-# * included in all copies or substantial portions of the Software.       */
-# *                                                                       */
-# * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-# * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-# * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-# * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-# * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-# * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-# * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-# *************************************************************************/
+# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-cmake_minimum_required(VERSION 3.1)
-project(SpdlogExamples CXX)
+cmake_minimum_required(VERSION 3.10)
+project(spdlog_examples CXX)
 
 if(NOT TARGET spdlog)
-  # Stand-alone build
-  find_package(spdlog CONFIG REQUIRED)
+    # Stand-alone build
+    find_package(spdlog REQUIRED)
 endif()
 
-find_package(Threads REQUIRED)
-
+# ---------------------------------------------------------------------------------------
+# Example of using pre-compiled library
+# ---------------------------------------------------------------------------------------
 add_executable(example example.cpp)
-target_link_libraries(example spdlog::spdlog Threads::Threads)
+target_link_libraries(example PRIVATE spdlog::spdlog)
 
-add_executable(multisink multisink.cpp)
-target_link_libraries(multisink spdlog::spdlog Threads::Threads)
-
-file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
-
-enable_testing()
-add_test(NAME example COMMAND example)
+# ---------------------------------------------------------------------------------------
+# Example of using header-only library
+# ---------------------------------------------------------------------------------------
+if(SPDLOG_BUILD_EXAMPLE_HO)
+    add_executable(example_header_only example.cpp)
+    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
+endif()

example/Makefile

@@ -1,21 +0,0 @@
-CXX	?= g++
-CXX_FLAGS = -Wall -Wextra -pedantic -std=c++11 -pthread -I../include -fmax-errors=1
-CXX_RELEASE_FLAGS = -O3 -march=native
-CXX_DEBUG_FLAGS= -g
-
-all:	example 
-debug:	example-debug
-
-example: example.cpp
-	$(CXX) example.cpp -o example $(CXX_FLAGS) $(CXX_RELEASE_FLAGS) $(CXXFLAGS)
-
-
-example-debug: example.cpp
-	$(CXX) example.cpp -o example-debug $(CXX_FLAGS) $(CXX_DEBUG_FLAGS) $(CXXFLAGS)
-
-clean:
-	rm -f *.o logs/*.txt example example-debug
-
-
-rebuild: clean all
-rebuild-debug: clean debug

example/Makefile.clang

@@ -1,26 +0,0 @@
-CXX	= clang++
-CXXFLAGS	= -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -I../include
-CXX_RELEASE_FLAGS = -O2
-CXX_DEBUG_FLAGS= -g 
-
-
-all:	example 
-debug: example-debug 
-
-example: example.cpp
-	$(CXX) example.cpp -o example-clang $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-
-	
-
-example-debug: example.cpp
-	$(CXX) example.cpp -o example-clang-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)
-
-
-clean:
-	rm -f *.o logs/*.txt example-clang example-clang-debug 
-
-
-rebuild: clean all
-rebuild-debug: clean debug
-
-

example/Makefile.mingw

@@ -1,25 +0,0 @@
-CXX	?= g++
-CXXFLAGS	=  -D_WIN32_WINNT=0x600 -march=native -Wall -Wextra -pedantic -std=gnu++0x -pthread -Wl,--no-as-needed  -I../include 
-CXX_RELEASE_FLAGS = -O3 
-CXX_DEBUG_FLAGS= -g 
-
-
-all:	example 
-debug: example-debug 
-
-example: example.cpp
-	$(CXX) example.cpp -o example $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-
-	
-example-debug: example.cpp
-	$(CXX) example.cpp -o example-debug $(CXXFLAGS) $(CXX_DEBUG_FLAGS)
-
-
-clean:
-	rm -f *.o logs/*.txt example example-debug
-
-
-rebuild: clean all
-rebuild-debug: clean debug
-
-

example/example.cpp

@@ -1,131 +1,148 @@
 //
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-//
+
 // spdlog usage example
-//
-//
 
-#include <iostream>
+#include <cstdio>
 
-void stdout_example();
+void load_levels_example();
+void stdout_logger_example();
 void basic_example();
 void rotating_example();
 void daily_example();
 void async_example();
+void binary_example();
+void stopwatch_example();
+void trace_example();
 void multi_sink_example();
 void user_defined_example();
 void err_handler_example();
 void syslog_example();
+void custom_flags_example();
 
 #include "spdlog/spdlog.h"
+#include "spdlog/cfg/env.h"  // support for loading levels from the environment variable
+#include "spdlog/fmt/ostr.h" // support for user defined types
 
 int main(int, char *[])
 {
+    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
+    load_levels_example();
+
+    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
+
+    spdlog::warn("Easy padding in numbers like {:08d}", 12);
+    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    spdlog::info("Support for floats {:03.2f}", 1.23456);
+    spdlog::info("Positional args are {1} {0}..", "too", "supported");
+    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
+
+    // Runtime log levels
+    spdlog::set_level(spdlog::level::info); // Set global log level to info
+    spdlog::debug("This message should not be displayed!");
+    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
+    spdlog::debug("This message should be displayed..");
+
+    // Customize msg format for all loggers
+    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
+    spdlog::info("This an info message with custom format");
+    spdlog::set_pattern("%+"); // back to default format
+    spdlog::set_level(spdlog::level::info);
+
+    // Backtrace support
+    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
+    // When needed, call dump_backtrace() to see what happened:
+    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
+    for (int i = 0; i < 100; i++)
+    {
+        spdlog::debug("Backtrace message {}", i); // not logged..
+    }
+    // e.g. if some error happened:
+    spdlog::dump_backtrace(); // log them now!
 
     try
     {
-        // console logging example
-        stdout_example();
-
-        // various file loggers
+        stdout_logger_example();
         basic_example();
         rotating_example();
         daily_example();
-
-        // async logging using a backing thread pool
         async_example();
-
-        // a logger can have multiple targets with different formats
+        binary_example();
         multi_sink_example();
-
-        // user defined types logging by implementing operator<<
         user_defined_example();
-
-        // custom  error handler
         err_handler_example();
+        trace_example();
+        stopwatch_example();
+        custom_flags_example();
 
-        // flush all *registered* loggers using a worker thread every 3 seconds.
+        // Flush all *registered* loggers using a worker thread every 3 seconds.
         // note: registered loggers *must* be thread safe for this to work correctly!
         spdlog::flush_every(std::chrono::seconds(3));
 
-        // apply some function on all registered loggers
+        // Apply some function on all registered loggers
         spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
 
-        // release any threads created by spdlog, and drop all loggers in the registry.
+        // Release all spdlog resources, and drop all loggers in the registry.
+        // This is optional (only mandatory if using windows + async log).
         spdlog::shutdown();
     }
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
+
+    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
     catch (const spdlog::spdlog_ex &ex)
     {
-        std::cout << "Log init failed: " << ex.what() << std::endl;
+        std::printf("Log initialization failed: %s\n", ex.what());
         return 1;
     }
 }
 
 #include "spdlog/sinks/stdout_color_sinks.h"
-// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed
-void stdout_example()
+// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
+void stdout_logger_example()
 {
-    // create color multi threaded logger
+    // Create color multi threaded logger.
     auto console = spdlog::stdout_color_mt("console");
-    console->info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-    console->error("Some error message with arg: {}", 1);
-
-    auto err_logger = spdlog::stderr_color_mt("stderr");
-    err_logger->error("Some error message");
-
-    // Formatting examples
-    console->warn("Easy padding in numbers like {:08d}", 12);
-    console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    console->info("Support for floats {:03.2f}", 1.23456);
-    console->info("Positional args are {1} {0}..", "too", "supported");
-    console->info("{:<30}", "left aligned");
-
-    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
-    console->debug("This message should not be displayed!");
-    console->set_level(spdlog::level::trace); // Set specific logger's log level
-    console->debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
-    console->info("This an info message with custom format");
-
-    // Compile time log levels
-    // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
-    SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
-    SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
+    // or for stderr:
+    // auto console = spdlog::stderr_color_mt("error-logger");
 }
 
 #include "spdlog/sinks/basic_file_sink.h"
 void basic_example()
 {
-    // Create basic file logger (not rotated)
-    auto my_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
+    // Create basic file logger (not rotated).
+    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
 }
 
 #include "spdlog/sinks/rotating_file_sink.h"
 void rotating_example()
 {
-    // Create a file rotating logger with 5mb size max and 3 rotated files
+    // Create a file rotating logger with 5mb size max and 3 rotated files.
     auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
 }
 
 #include "spdlog/sinks/daily_file_sink.h"
 void daily_example()
 {
-    // Create a daily logger - a new file is created every day on 2:30am
+    // Create a daily logger - a new file is created every day on 2:30am.
     auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
 }
 
+#include "spdlog/cfg/env.h"
+void load_levels_example()
+{
+    // Set the log level to "info" and mylogger to "trace":
+    // SPDLOG_LEVEL=info,mylogger=trace && ./example
+    spdlog::cfg::load_env_levels();
+    // or from command line:
+    // ./example SPDLOG_LEVEL=info,mylogger=trace
+    // #include "spdlog/cfg/argv.h" // for loading levels from argv
+    // spdlog::cfg::load_argv_levels(args, argv);
+}
+
 #include "spdlog/async.h"
 void async_example()
 {
-    // default thread pool settings can be modified *before* creating the async logger:
+    // Default thread pool settings can be modified *before* creating the async logger:
     // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
     auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
     // alternatively:
@@ -137,9 +154,58 @@ void async_example()
     }
 }
 
-// create logger with 2 targets with different log levels and formats
-// the console will show only warnings or errors, while the file will log all
+// Log binary data as hex.
+// Many types of std::container<char> types can be used.
+// Iterator ranges are supported too.
+// Format flags:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
 
+#include "spdlog/fmt/bin_to_hex.h"
+void binary_example()
+{
+    std::vector<char> buf(80);
+    for (int i = 0; i < 80; i++)
+    {
+        buf.push_back(static_cast<char>(i & 0xff));
+    }
+    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
+    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
+    // more examples:
+    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
+    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
+    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
+    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
+}
+
+// Compile time log levels.
+// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
+void trace_example()
+{
+    // trace from default logger
+    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
+    // debug from default logger
+    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
+
+    // trace from logger object
+    auto logger = spdlog::get("file_logger");
+    SPDLOG_LOGGER_TRACE(logger, "another trace message");
+}
+
+// stopwatch example
+#include "spdlog/stopwatch.h"
+#include <thread>
+void stopwatch_example()
+{
+    spdlog::stopwatch sw;
+    std::this_thread::sleep_for(std::chrono::milliseconds(123));
+    spdlog::info("Stopwatch: {} seconds", sw);
+}
+
+// A logger with multiple sinks (stdout and file) - each with a different format and log level.
 void multi_sink_example()
 {
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
@@ -154,8 +220,8 @@ void multi_sink_example()
     logger.warn("this should appear in both console and file");
     logger.info("this message should not appear in the console, only in the file");
 }
-// user defined types logging by implementing operator<<
-#include "spdlog/fmt/ostr.h" // must be included
+
+// User defined types logging by implementing operator<<
 struct my_type
 {
     int i;
@@ -168,22 +234,19 @@ struct my_type
 
 void user_defined_example()
 {
-    spdlog::get("console")->info("user defined type: {}", my_type{14});
+    spdlog::info("user defined type: {}", my_type{14});
 }
 
-//
-// custom error handler
-//
+// Custom error handler. Will be triggered on log failure.
 void err_handler_example()
 {
     // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** ERROR HANDLER EXAMPLE ***: {}", msg); });
-    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
 }
 
 // syslog example (linux/osx/freebsd)
 #ifndef _WIN32
-#include "spdlog/sinks/syslog_sink.h"
+#    include "spdlog/sinks/syslog_sink.h"
 void syslog_example()
 {
     std::string ident = "spdlog-example";
@@ -192,14 +255,40 @@ void syslog_example()
 }
 #endif
 
-// Android example
+// Android example.
 #if defined(__ANDROID__)
-#include "spdlog/sinks/android_sink.h"
+#    include "spdlog/sinks/android_sink.h"
 void android_example()
 {
     std::string tag = "spdlog-android";
     auto android_logger = spdlog::android_logger_mt("android", tag);
     android_logger->critical("Use \"adb shell logcat\" to view this message.");
 }
-
 #endif
+
+// Log patterns can contain custom flags.
+// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
+#include "spdlog/pattern_formatter.h"
+class my_formatter_flag : public spdlog::custom_flag_formatter
+{
+public:
+    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
+    {
+        std::string some_txt = "custom-flag";
+        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
+    }
+
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
+        return spdlog::details::make_unique<my_formatter_flag>();
+    }
+};
+
+void custom_flags_example()
+{
+
+    using spdlog::details::make_unique; // for pre c++14
+    auto formatter = make_unique<spdlog::pattern_formatter>();
+    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
+    spdlog::set_formatter(std::move(formatter));
+}

example/example.sln

@@ -1,106 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27703.2018
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example", "example.vcxproj", "{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "spdlog", "spdlog", "{7FC6AB76-AD88-4135-888C-0568E81475AF}"
-	ProjectSection(SolutionItems) = preProject
-		..\include\spdlog\async.h = ..\include\spdlog\async.h
-		..\include\spdlog\async_logger.h = ..\include\spdlog\async_logger.h
-		..\include\spdlog\common.h = ..\include\spdlog\common.h
-		..\include\spdlog\formatter.h = ..\include\spdlog\formatter.h
-		..\include\spdlog\logger.h = ..\include\spdlog\logger.h
-		..\include\spdlog\spdlog.h = ..\include\spdlog\spdlog.h
-		..\include\spdlog\tweakme.h = ..\include\spdlog\tweakme.h
-		..\include\spdlog\version.h = ..\include\spdlog\version.h
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "details", "details", "{08E93803-E650-42D9-BBB4-3C16979F850E}"
-	ProjectSection(SolutionItems) = preProject
-		..\include\spdlog\details\async_logger_impl.h = ..\include\spdlog\details\async_logger_impl.h
-		..\include\spdlog\details\circular_q.h = ..\include\spdlog\details\circular_q.h
-		..\include\spdlog\details\console_globals.h = ..\include\spdlog\details\console_globals.h
-		..\include\spdlog\details\file_helper.h = ..\include\spdlog\details\file_helper.h
-		..\include\spdlog\details\fmt_helper.h = ..\include\spdlog\details\fmt_helper.h
-		..\include\spdlog\details\log_msg.h = ..\include\spdlog\details\log_msg.h
-		..\include\spdlog\details\logger_impl.h = ..\include\spdlog\details\logger_impl.h
-		..\include\spdlog\details\mpmc_blocking_q.h = ..\include\spdlog\details\mpmc_blocking_q.h
-		..\include\spdlog\details\null_mutex.h = ..\include\spdlog\details\null_mutex.h
-		..\include\spdlog\details\os.h = ..\include\spdlog\details\os.h
-		..\include\spdlog\details\pattern_formatter.h = ..\include\spdlog\details\pattern_formatter.h
-		..\include\spdlog\details\periodic_worker.h = ..\include\spdlog\details\periodic_worker.h
-		..\include\spdlog\details\registry.h = ..\include\spdlog\details\registry.h
-		..\include\spdlog\details\spdlog_impl.h = ..\include\spdlog\details\spdlog_impl.h
-		..\include\spdlog\details\thread_pool.h = ..\include\spdlog\details\thread_pool.h
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "fmt", "fmt", "{82378DE1-8463-4F91-91A0-C2C40E2AEA2A}"
-	ProjectSection(SolutionItems) = preProject
-		..\include\spdlog\fmt\fmt.h = ..\include\spdlog\fmt\fmt.h
-		..\include\spdlog\fmt\ostr.h = ..\include\spdlog\fmt\ostr.h
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "bundled", "bundled", "{D9CA4494-80D1-48D1-A897-D3564F7B27FF}"
-	ProjectSection(SolutionItems) = preProject
-		..\include\spdlog\fmt\bundled\format.cc = ..\include\spdlog\fmt\bundled\format.cc
-		..\include\spdlog\fmt\bundled\format.h = ..\include\spdlog\fmt\bundled\format.h
-		..\include\spdlog\fmt\bundled\LICENSE.rst = ..\include\spdlog\fmt\bundled\LICENSE.rst
-		..\include\spdlog\fmt\bundled\ostream.cc = ..\include\spdlog\fmt\bundled\ostream.cc
-		..\include\spdlog\fmt\bundled\ostream.h = ..\include\spdlog\fmt\bundled\ostream.h
-		..\include\spdlog\fmt\bundled\posix.cc = ..\include\spdlog\fmt\bundled\posix.cc
-		..\include\spdlog\fmt\bundled\posix.h = ..\include\spdlog\fmt\bundled\posix.h
-		..\include\spdlog\fmt\bundled\printf.cc = ..\include\spdlog\fmt\bundled\printf.cc
-		..\include\spdlog\fmt\bundled\printf.h = ..\include\spdlog\fmt\bundled\printf.h
-		..\include\spdlog\fmt\bundled\time.h = ..\include\spdlog\fmt\bundled\time.h
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sinks", "sinks", "{27D16BB9-2B81-4F61-80EC-0C7A777248E4}"
-	ProjectSection(SolutionItems) = preProject
-		..\include\spdlog\sinks\android_sink.h = ..\include\spdlog\sinks\android_sink.h
-		..\include\spdlog\sinks\ansicolor_sink.h = ..\include\spdlog\sinks\ansicolor_sink.h
-		..\include\spdlog\sinks\base_sink.h = ..\include\spdlog\sinks\base_sink.h
-		..\include\spdlog\sinks\dist_sink.h = ..\include\spdlog\sinks\dist_sink.h
-		..\include\spdlog\sinks\file_sinks.h = ..\include\spdlog\sinks\file_sinks.h
-		..\include\spdlog\sinks\msvc_sink.h = ..\include\spdlog\sinks\msvc_sink.h
-		..\include\spdlog\sinks\null_sink.h = ..\include\spdlog\sinks\null_sink.h
-		..\include\spdlog\sinks\ostream_sink.h = ..\include\spdlog\sinks\ostream_sink.h
-		..\include\spdlog\sinks\sink.h = ..\include\spdlog\sinks\sink.h
-		..\include\spdlog\sinks\stdout_color_sinks.h = ..\include\spdlog\sinks\stdout_color_sinks.h
-		..\include\spdlog\sinks\stdout_sinks.h = ..\include\spdlog\sinks\stdout_sinks.h
-		..\include\spdlog\sinks\syslog_sink.h = ..\include\spdlog\sinks\syslog_sink.h
-		..\include\spdlog\sinks\wincolor_sink.h = ..\include\spdlog\sinks\wincolor_sink.h
-		..\include\spdlog\sinks\windebug_sink.h = ..\include\spdlog\sinks\windebug_sink.h
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Debug|x64 = Debug|x64
-		Release|Win32 = Release|Win32
-		Release|x64 = Release|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|Win32.Build.0 = Debug|Win32
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|x64.ActiveCfg = Debug|x64
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Debug|x64.Build.0 = Debug|x64
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|Win32.ActiveCfg = Release|Win32
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|Win32.Build.0 = Release|Win32
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|x64.ActiveCfg = Release|x64
-		{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}.Release|x64.Build.0 = Release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{08E93803-E650-42D9-BBB4-3C16979F850E} = {7FC6AB76-AD88-4135-888C-0568E81475AF}
-		{82378DE1-8463-4F91-91A0-C2C40E2AEA2A} = {7FC6AB76-AD88-4135-888C-0568E81475AF}
-		{D9CA4494-80D1-48D1-A897-D3564F7B27FF} = {82378DE1-8463-4F91-91A0-C2C40E2AEA2A}
-		{27D16BB9-2B81-4F61-80EC-0C7A777248E4} = {7FC6AB76-AD88-4135-888C-0568E81475AF}
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {1BF53532-C5DC-4236-B195-9E17CBE40A48}
-	EndGlobalSection
-EndGlobal

example/example.vcxproj

@@ -1,168 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="example.cpp" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>.</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PrecompiledHeaderFile>
-      </PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>
-      </PrecompiledHeaderOutputFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PrecompiledHeaderFile>
-      </PrecompiledHeaderFile>
-      <PrecompiledHeaderOutputFile>
-      </PrecompiledHeaderOutputFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

example/jni/Android.mk

@@ -1,15 +0,0 @@
-# Setup a project
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := example
-LOCAL_SRC_FILES := example.cpp
-LOCAL_CPPFLAGS += -Wall -Wshadow -Wextra -pedantic -std=c++11 -fPIE -pie
-LOCAL_LDFLAGS +=  -fPIE -pie
-
-# Add exception support and set path for spdlog's headers
-LOCAL_CPPFLAGS += -fexceptions -I../include
-# Use android's log library
-LOCAL_LDFLAGS += -llog
-
-include $(BUILD_EXECUTABLE)

example/jni/Application.mk

@@ -1,2 +0,0 @@
-# Exceptions are used in spdlog. Link to an exception-ready C++ runtime.
-APP_STL = gnustl_static

example/jni/example.cpp

@@ -1,157 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-//
-// spdlog usage example
-//
-//
-
-#define SPDLOG_TRACE_ON
-#define SPDLOG_DEBUG_ON
-
-#include "spdlog/spdlog.h"
-
-#include <iostream>
-#include <memory>
-
-void async_example();
-void syslog_example();
-void android_example();
-void user_defined_example();
-void err_handler_example();
-
-namespace spd = spdlog;
-int main(int, char *[])
-{
-    try
-    {
-        // Console logger with color
-        auto console = spd::stdout_color_mt("console");
-        console->info("Welcome to spdlog!");
-        console->error("Some error message with arg{}..", 1);
-
-        // Formatting examples
-        console->warn("Easy padding in numbers like {:08d}", 12);
-        console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-        console->info("Support for floats {:03.2f}", 1.23456);
-        console->info("Positional args are {1} {0}..", "too", "supported");
-        console->info("{:<30}", "left aligned");
-
-        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
-
-        // Create basic file logger (not rotated)
-        auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic-log.txt");
-        my_logger->info("Some log message");
-
-        // Create a file rotating logger with 5mb size max and 3 rotated files
-        auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-        for (int i = 0; i < 10; ++i)
-            rotating_logger->info("{} * {} equals {:>10}", i, i, i * i);
-
-        // Create a daily logger - a new file is created every day on 2:30am
-        auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-        // trigger flush if the log severity is error or higher
-        daily_logger->flush_on(spd::level::err);
-        daily_logger->info(123.44);
-
-        // Customize msg format for all messages
-        spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
-        rotating_logger->info("This is another message with custom format");
-
-        // Runtime log levels
-        spd::set_level(spd::level::info); // Set global log level to info
-        console->debug("This message should not be displayed!");
-        console->set_level(spd::level::debug); // Set specific logger's log level
-        console->debug("This message should be displayed..");
-
-        // Compile time log levels
-        // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
-        SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
-        SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
-
-        // Asynchronous logging is very fast..
-        // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
-        async_example();
-
-        // syslog example. linux/osx only
-        syslog_example();
-
-        // android example. compile with NDK
-        android_example();
-
-        // Log user-defined types example
-        user_defined_example();
-
-        // Change default log error handler
-        err_handler_example();
-
-        // Apply a function on all registered loggers
-        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release and close all loggers
-        spdlog::drop_all();
-    }
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
-    catch (const spd::spdlog_ex &ex)
-    {
-        std::cout << "Log init failed: " << ex.what() << std::endl;
-        return 1;
-    }
-}
-
-void async_example()
-{
-    size_t q_size = 4096; // queue size must be power of 2
-    spdlog::set_async_mode(q_size);
-    auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
-    for (int i = 0; i < 100; ++i)
-        async_file->info("Async message #{}", i);
-}
-
-// syslog example (linux/osx/freebsd)
-void syslog_example()
-{
-#ifdef SPDLOG_ENABLE_SYSLOG
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-#endif
-}
-
-// Android example
-void android_example()
-{
-#if defined(__ANDROID__)
-    std::string tag = "spdlog-android";
-    auto android_logger = spd::android_logger("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-#endif
-}
-
-// user defined types logging by implementing operator<<
-struct my_type
-{
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
-    {
-        return os << "[my_type i=" << c.i << "]";
-    }
-};
-
-#include "spdlog/fmt/ostr.h" // must be included
-void user_defined_example()
-{
-    spd::get("console")->info("user defined type: {}", my_type{14});
-}
-
-//
-// custom error handler
-//
-void err_handler_example()
-{
-    // can be set globaly or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { std::cerr << "my err handler: " << msg << std::endl; });
-    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-}

example/logs/.gitignore

@@ -1 +0,0 @@
-*.txt

example/multisink.cpp

@@ -1,46 +0,0 @@
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/stdout_sinks.h"
-#include "spdlog/spdlog.h"
-#include <iostream>
-#include <memory>
-
-int main(int, char *[])
-{
-    bool enable_debug = true;
-    try
-    {
-        // This other example use a single logger with multiple sinks.
-        // This means that the same log_msg is forwarded to multiple sinks;
-        // Each sink can have it's own log level and a message will be logged.
-        std::vector<spdlog::sink_ptr> sinks;
-        sinks.push_back(std::make_shared<spdlog::sinks::stdout_sink_mt>());
-        sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("./log_regular_file.txt"));
-        sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("./log_debug_file.txt"));
-
-        spdlog::logger console_multisink("multisink", sinks.begin(), sinks.end());
-        console_multisink.set_level(spdlog::level::warn);
-
-        sinks[0]->set_level(spdlog::level::trace); // console. Allow everything.  Default value
-        sinks[1]->set_level(spdlog::level::trace); //  regular file. Allow everything.  Default value
-        sinks[2]->set_level(spdlog::level::off);   //  regular file. Ignore everything.
-
-        console_multisink.warn("warn: will print only on console and regular file");
-
-        if (enable_debug)
-        {
-            console_multisink.set_level(spdlog::level::debug); // level of the logger
-            sinks[1]->set_level(spdlog::level::debug);         // regular file
-            sinks[2]->set_level(spdlog::level::debug);         // debug file
-        }
-        console_multisink.debug("Debug: you should see this on console and both files");
-
-        // Release and close all loggers
-        spdlog::drop_all();
-    }
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::cout << "Log init failed: " << ex.what() << std::endl;
-        return 1;
-    }
-}

example/utils.h

@@ -1,34 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <iomanip>
-#include <locale>
-#include <sstream>
-
-namespace utils {
-
-template<typename T>
-inline std::string format(const T &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << value;
-    return ss.str();
-}
-
-template<>
-inline std::string format(const double &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << std::fixed << std::setprecision(1) << value;
-    return ss.str();
-}
-
-} // namespace utils

format.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-echo -n "Running dos2unix     "
-find . -name "*\.h" -o -name "*\.cpp"|xargs -I {} sh -c "dos2unix '{}' 2>/dev/null; echo -n '.'"
-echo
-echo -n "Running clang-format "
-find . -name "*\.h" -o -name "*\.cpp"|xargs -I {} sh -c "clang-format -i {}; echo -n '.'"
-echo
-
-

include/spdlog/async.h

@@ -1,15 +1,12 @@
-
-//
-// Copyright(c) 2018 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
 //
 // Async logging using global thread pool
 // All loggers created here share same global thread pool.
-// Each log message is pushed to a queue along withe a shared pointer to the
+// Each log message is pushed to a queue along with a shared pointer to the
 // logger.
 // If a logger deleted while having pending messages in the queue, it's actual
 // destruction will defer
@@ -17,12 +14,13 @@
 // This is because each message in the queue holds a shared_ptr to the
 // originating logger.
 
-#include "spdlog/async_logger.h"
-#include "spdlog/details/registry.h"
-#include "spdlog/details/thread_pool.h"
+#include <spdlog/async_logger.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/thread_pool.h>
 
 #include <memory>
 #include <mutex>
+#include <functional>
 
 namespace spdlog {
 
@@ -37,22 +35,24 @@ 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(const 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();
 
         // create global thread pool if not already exists..
-        std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
+
+        auto &mutex = registry_inst.tp_mutex();
+        std::lock_guard<std::recursive_mutex> tp_lock(mutex);
         auto tp = registry_inst.get_tp();
         if (tp == nullptr)
         {
-            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1);
+            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
             registry_inst.set_tp(tp);
         }
 
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(logger_name, std::move(sink), std::move(tp), OverflowPolicy);
-        registry_inst.register_and_init(new_logger);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
 };
@@ -61,22 +61,28 @@ 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(const 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>(logger_name, std::forward<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(const 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>(logger_name, std::forward<SinkArgs>(sink_args)...);
+    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+}
+
+// set global thread pool.
+inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
+{
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);
+    details::registry::instance().set_tp(std::move(tp));
 }
 
 // set global thread pool.
 inline void init_thread_pool(size_t q_size, size_t thread_count)
 {
-    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count);
-    details::registry::instance().set_tp(std::move(tp));
+    init_thread_pool(q_size, thread_count, [] {});
 }
 
 // get the global thread pool.

include/spdlog/async_logger-inl.h

@@ -0,0 +1,92 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/async_logger.h>
+#endif
+
+#include <spdlog/sinks/sink.h>
+#include <spdlog/details/thread_pool.h>
+
+#include <memory>
+#include <string>
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+{}
+
+SPDLOG_INLINE spdlog::async_logger::async_logger(
+    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+{}
+
+// send the log message to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
+    }
+}
+
+// send flush request to the thread pool
+SPDLOG_INLINE void spdlog::async_logger::flush_()
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
+        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
+    }
+    else
+    {
+        throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
+    }
+}
+
+//
+// backend functions - called from the thread pool to do the actual job
+//
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
+{
+    for (auto &sink : sinks_)
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
+            SPDLOG_LOGGER_CATCH()
+        }
+    }
+
+    if (should_flush_(msg))
+    {
+        backend_flush_();
+    }
+}
+
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
+{
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
+        SPDLOG_LOGGER_CATCH()
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+{
+    auto cloned = std::make_shared<spdlog::async_logger>(*this);
+    cloned->name_ = std::move(new_name);
+    return cloned;
+}

include/spdlog/async_logger.h

@@ -1,30 +1,20 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
-// Very fast asynchronous logger (millions of logs per second on an average
-// desktop)
-// Uses pre allocated lockfree queue for maximum throughput even under large
-// number of threads.
+// Fast asynchronous logger.
+// Uses pre allocated queue.
 // Creates a single back thread to pop messages from the queue and log them.
 //
 // Upon each log write the logger:
 //    1. Checks if its log level is enough to log the message
 //    2. Push a new copy of the message to a queue (or block the caller until
 //    space is available in the queue)
-//    3. will throw spdlog_ex upon log exceptions
 // Upon destruction, logs all remaining messages in the queue before
 // destructing..
 
-#include "spdlog/common.h"
-#include "spdlog/logger.h"
-
-#include <chrono>
-#include <memory>
-#include <string>
+#include <spdlog/logger.h>
 
 namespace spdlog {
 
@@ -40,14 +30,18 @@ namespace details {
 class thread_pool;
 }
 
-class async_logger SPDLOG_FINAL : public std::enable_shared_from_this<async_logger>, public logger
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
 {
     friend class details::thread_pool;
 
 public:
     template<typename It>
-    async_logger(std::string logger_name, const It &begin, const It &end, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block);
+    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
+        async_overflow_policy overflow_policy = async_overflow_policy::block)
+        : logger(std::move(logger_name), begin, end)
+        , thread_pool_(std::move(tp))
+        , overflow_policy_(overflow_policy)
+    {}
 
     async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
         async_overflow_policy overflow_policy = async_overflow_policy::block);
@@ -55,11 +49,12 @@ public:
     async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
         async_overflow_policy overflow_policy = async_overflow_policy::block);
 
-protected:
-    void sink_it_(details::log_msg &msg) override;
-    void flush_() override;
+    std::shared_ptr<logger> clone(std::string new_name) override;
 
-    void backend_log_(details::log_msg &incoming_log_msg);
+protected:
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+    void backend_sink_it_(const details::log_msg &incoming_log_msg);
     void backend_flush_();
 
 private:
@@ -68,4 +63,6 @@ private:
 };
 } // namespace spdlog
 
-#include "details/async_logger_impl.h"
+#ifdef SPDLOG_HEADER_ONLY
+#    include "async_logger-inl.h"
+#endif

include/spdlog/cfg/argv.h

@@ -0,0 +1,44 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+
+//
+// Init log levels using each argv entry that starts with "SPDLOG_LEVEL="
+//
+// set all loggers to debug level:
+// example.exe "SPDLOG_LEVEL=debug"
+
+// set logger1 to trace level
+// example.exe "SPDLOG_LEVEL=logger1=trace"
+
+// turn off all logging except for logger1 and logger2:
+// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+
+// search for SPDLOG_LEVEL= in the args and use it to init the levels
+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++)
+    {
+        std::string arg = argv[i];
+        if (arg.find(spdlog_level_prefix) == 0)
+        {
+            auto levels_string = arg.substr(spdlog_level_prefix.size());
+            helpers::load_levels(levels_string);
+        }
+    }
+}
+
+inline void load_argv_levels(int argc, char **argv)
+{
+    load_argv_levels(argc, const_cast<const char **>(argv));
+}
+
+} // namespace cfg
+} // namespace spdlog

include/spdlog/cfg/env.h

@@ -0,0 +1,38 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+#include <spdlog/cfg/helpers.h>
+#include <spdlog/details/registry.h>
+#include <spdlog/details/os.h>
+
+//
+// Init levels and patterns from env variables SPDLOG_LEVEL
+// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger).
+// Note - fallback to "info" level on unrecognized levels
+//
+// Examples:
+//
+// set global level to debug:
+// export SPDLOG_LEVEL=debug
+//
+// turn off all logging except for logger1:
+// export SPDLOG_LEVEL="*=off,logger1=debug"
+//
+
+// turn off all logging except for logger1 and logger2:
+// export SPDLOG_LEVEL="off,logger1=debug,logger2=info"
+
+namespace spdlog {
+namespace cfg {
+inline void load_env_levels()
+{
+    auto env_val = details::os::getenv("SPDLOG_LEVEL");
+    if (!env_val.empty())
+    {
+        helpers::load_levels(env_val);
+    }
+}
+
+} // namespace cfg
+} // namespace spdlog

include/spdlog/cfg/helpers-inl.h

@@ -0,0 +1,120 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/cfg/helpers.h>
+#endif
+
+#include <spdlog/spdlog.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/registry.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <sstream>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+
+// inplace convert to lowercase
+inline std::string &to_lower_(std::string &str)
+{
+    std::transform(
+        str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); });
+    return str;
+}
+
+// inplace trim spaces
+inline std::string &trim_(std::string &str)
+{
+    const char *spaces = " \n\r\t";
+    str.erase(str.find_last_not_of(spaces) + 1);
+    str.erase(0, str.find_first_not_of(spaces));
+    return str;
+}
+
+// return (name,value) trimmed pair from given "name=value" string.
+// return empty string on missing parts
+// "key=val" => ("key", "val")
+// " key  =  val " => ("key", "val")
+// "key=" => ("key", "")
+// "val" => ("", "val")
+
+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str)
+{
+    auto n = str.find(sep);
+    std::string k, v;
+    if (n == std::string::npos)
+    {
+        v = str;
+    }
+    else
+    {
+        k = str.substr(0, n);
+        v = str.substr(n + 1);
+    }
+    return std::make_pair(trim_(k), trim_(v));
+}
+
+// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
+// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str)
+{
+    std::string token;
+    std::istringstream token_stream(str);
+    std::unordered_map<std::string, std::string> rv{};
+    while (std::getline(token_stream, token, ','))
+    {
+        if (token.empty())
+        {
+            continue;
+        }
+        auto kv = extract_kv_('=', token);
+        rv[kv.first] = kv.second;
+    }
+    return rv;
+}
+
+SPDLOG_INLINE void load_levels(const std::string &input)
+{
+    if (input.empty() || input.size() > 512)
+    {
+        return;
+    }
+
+    auto key_vals = extract_key_vals_(input);
+    std::unordered_map<std::string, level::level_enum> levels;
+    level::level_enum global_level = level::info;
+    bool global_level_found = false;
+
+    for (auto &name_level : key_vals)
+    {
+        auto &logger_name = name_level.first;
+        auto level_name = to_lower_(name_level.second);
+        auto level = level::from_str(level_name);
+        // ignore unrecognized level names
+        if (level == level::off && level_name != "off")
+        {
+            continue;
+        }
+        if (logger_name.empty()) // no logger name indicate global level
+        {
+            global_level_found = true;
+            global_level = level;
+        }
+        else
+        {
+            levels[logger_name] = level;
+        }
+    }
+
+    details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
+}
+
+} // namespace helpers
+} // namespace cfg
+} // namespace spdlog

include/spdlog/cfg/helpers.h

@@ -0,0 +1,29 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <unordered_map>
+
+namespace spdlog {
+namespace cfg {
+namespace helpers {
+//
+// Init levels from given string
+//
+// Examples:
+//
+// set global level to debug: "debug"
+// turn off all logging except for logger1: "off,logger1=debug"
+// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
+//
+SPDLOG_API void load_levels(const std::string &txt);
+} // namespace helpers
+
+} // namespace cfg
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "helpers-inl.h"
+#endif // SPDLOG_HEADER_ONLY

include/spdlog/common-inl.h

@@ -0,0 +1,78 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/common.h>
+#endif
+
+#include <algorithm>
+#include <iterator>
+
+namespace spdlog {
+namespace level {
+
+#if __cplusplus >= 201703L
+constexpr
+#endif
+    static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
+
+static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;
+
+SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return level_string_views[l];
+}
+
+SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+{
+    return short_level_names[l];
+}
+
+SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
+{
+    auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
+    if (it != std::end(level_string_views))
+        return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));
+
+    // check also for "warn" and "err" before giving up..
+    if (name == "warn")
+    {
+        return level::warn;
+    }
+    if (name == "err")
+    {
+        return level::err;
+    }
+    return level::off;
+}
+} // namespace level
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
+    : msg_(std::move(msg))
+{}
+
+SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
+{
+    memory_buf_t outbuf;
+    fmt::format_system_error(outbuf, last_errno, msg.c_str());
+    msg_ = fmt::to_string(outbuf);
+}
+
+SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
+{
+    return msg_.c_str();
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno)
+{
+    SPDLOG_THROW(spdlog_ex(msg, last_errno));
+}
+
+SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
+{
+    SPDLOG_THROW(spdlog_ex(std::move(msg)));
+}
+
+} // namespace spdlog

include/spdlog/common.h

@@ -1,53 +1,93 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
-#include "spdlog/tweakme.h"
+#include <spdlog/tweakme.h>
+#include <spdlog/details/null_mutex.h>
 
 #include <atomic>
 #include <chrono>
-#include <functional>
 #include <initializer_list>
 #include <memory>
-#include <stdexcept>
+#include <exception>
 #include <string>
-#include <unordered_map>
+#include <type_traits>
+#include <functional>
 
-#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#include <codecvt>
-#include <locale>
+#ifdef SPDLOG_COMPILED_LIB
+#    undef SPDLOG_HEADER_ONLY
+#    if defined(_WIN32) && defined(SPDLOG_SHARED_LIB)
+#        ifdef spdlog_EXPORTS
+#            define SPDLOG_API __declspec(dllexport)
+#        else
+#            define SPDLOG_API __declspec(dllimport)
+#        endif
+#    else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB)
+#        define SPDLOG_API
+#    endif
+#    define SPDLOG_INLINE
+#else // !defined(SPDLOG_COMPILED_LIB)
+#    define SPDLOG_API
+#    define SPDLOG_HEADER_ONLY
+#    define SPDLOG_INLINE inline
+#endif // #ifdef SPDLOG_COMPILED_LIB
+
+#include <spdlog/fmt/fmt.h>
+
+// backward compatibility with fmt versions older than 8
+#if FMT_VERSION >= 80000
+#    define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#        include <spdlog/fmt/xchar.h>
+#    endif
+#else
+#    define SPDLOG_FMT_RUNTIME(format_string) format_string
 #endif
 
-#include "spdlog/details/null_mutex.h"
-
 // visual studio upto 2013 does not support noexcept nor constexpr
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define SPDLOG_NOEXCEPT throw()
-#define SPDLOG_CONSTEXPR
+#    define SPDLOG_NOEXCEPT _NOEXCEPT
+#    define SPDLOG_CONSTEXPR
 #else
-#define SPDLOG_NOEXCEPT noexcept
-#define SPDLOG_CONSTEXPR constexpr
-#endif
-
-// final keyword support. On by default. See tweakme.h
-#if defined(SPDLOG_NO_FINAL)
-#define SPDLOG_FINAL
-#else
-#define SPDLOG_FINAL final
+#    define SPDLOG_NOEXCEPT noexcept
+#    define SPDLOG_CONSTEXPR constexpr
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#define SPDLOG_DEPRECATED __attribute__((deprecated))
+#    define SPDLOG_DEPRECATED __attribute__((deprecated))
 #elif defined(_MSC_VER)
-#define SPDLOG_DEPRECATED __declspec(deprecated)
+#    define SPDLOG_DEPRECATED __declspec(deprecated)
 #else
-#define SPDLOG_DEPRECATED
+#    define SPDLOG_DEPRECATED
 #endif
 
-#include "spdlog/fmt/fmt.h"
+// disable thread local on msvc 2013
+#ifndef SPDLOG_NO_TLS
+#    if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+#        define SPDLOG_NO_TLS 1
+#    endif
+#endif
+
+#ifndef SPDLOG_FUNCTION
+#    define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+#endif
+
+#ifdef SPDLOG_NO_EXCEPTIONS
+#    define SPDLOG_TRY
+#    define SPDLOG_THROW(ex)                                                                                                               \
+        do                                                                                                                                 \
+        {                                                                                                                                  \
+            printf("spdlog fatal error: %s\n", ex.what());                                                                                 \
+            std::abort();                                                                                                                  \
+        } while (0)
+#    define SPDLOG_CATCH_STD
+#else
+#    define SPDLOG_TRY try
+#    define SPDLOG_THROW(ex) throw(ex)
+#    define SPDLOG_CATCH_STD                                                                                                               \
+        catch (const std::exception &) {}
+#endif
 
 namespace spdlog {
 
@@ -57,10 +97,49 @@ namespace sinks {
 class sink;
 }
 
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+using filename_t = std::wstring;
+// allow macro expansion to occur in SPDLOG_FILENAME_T
+#    define SPDLOG_FILENAME_T_INNER(s) L##s
+#    define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
+#else
+using filename_t = std::string;
+#    define SPDLOG_FILENAME_T(s) s
+#endif
+
 using log_clock = std::chrono::system_clock;
 using sink_ptr = std::shared_ptr<sinks::sink>;
 using sinks_init_list = std::initializer_list<sink_ptr>;
-using log_err_handler = std::function<void(const std::string &err_msg)>;
+using err_handler = std::function<void(const std::string &err_msg)>;
+using string_view_t = fmt::basic_string_view<char>;
+using wstring_view_t = fmt::basic_string_view<wchar_t>;
+using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
+using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#    ifndef _WIN32
+#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#    else
+template<typename T>
+struct is_convertible_to_wstring_view : std::is_convertible<T, wstring_view_t>
+{};
+template<class T>
+struct is_convertible_to_wformat_string : std::is_convertible<T, fmt::wformat_string<>>
+{};
+#    endif // _WIN32
+#else
+template<typename>
+struct is_convertible_to_wstring_view : std::false_type
+{};
+template<class>
+struct is_convertible_to_wformat_string : std::false_type
+{};
+#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
+template<class T>
+struct is_convertible_to_basic_format_string
+    : std::integral_constant<bool, std::is_convertible<const T &, fmt::format_string<>>::value || is_convertible_to_wformat_string<T>::value>
+{};
 
 #if defined(SPDLOG_NO_ATOMIC_LEVELS)
 using level_t = details::null_atomic_int;
@@ -68,57 +147,72 @@ using level_t = details::null_atomic_int;
 using level_t = std::atomic<int>;
 #endif
 
+#define SPDLOG_LEVEL_TRACE 0
+#define SPDLOG_LEVEL_DEBUG 1
+#define SPDLOG_LEVEL_INFO 2
+#define SPDLOG_LEVEL_WARN 3
+#define SPDLOG_LEVEL_ERROR 4
+#define SPDLOG_LEVEL_CRITICAL 5
+#define SPDLOG_LEVEL_OFF 6
+
+#if !defined(SPDLOG_ACTIVE_LEVEL)
+#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#endif
+
 // Log level enum
 namespace level {
 enum level_enum
 {
-    trace = 0,
-    debug = 1,
-    info = 2,
-    warn = 3,
-    err = 4,
-    critical = 5,
-    off = 6
+    trace = SPDLOG_LEVEL_TRACE,
+    debug = SPDLOG_LEVEL_DEBUG,
+    info = SPDLOG_LEVEL_INFO,
+    warn = SPDLOG_LEVEL_WARN,
+    err = SPDLOG_LEVEL_ERROR,
+    critical = SPDLOG_LEVEL_CRITICAL,
+    off = SPDLOG_LEVEL_OFF,
+    n_levels
 };
 
+#define SPDLOG_LEVEL_NAME_TRACE string_view_t("trace", 5)
+#define SPDLOG_LEVEL_NAME_DEBUG string_view_t("debug", 5)
+#define SPDLOG_LEVEL_NAME_INFO string_view_t("info", 4)
+#define SPDLOG_LEVEL_NAME_WARNING string_view_t("warning", 7)
+#define SPDLOG_LEVEL_NAME_ERROR string_view_t("error", 5)
+#define SPDLOG_LEVEL_NAME_CRITICAL string_view_t("critical", 8)
+#define SPDLOG_LEVEL_NAME_OFF string_view_t("off", 3)
+
 #if !defined(SPDLOG_LEVEL_NAMES)
-#define SPDLOG_LEVEL_NAMES                                                                                                                 \
-    {                                                                                                                                      \
-        "trace", "debug", "info", "warning", "error", "critical", "off"                                                                    \
-    }
+#    define SPDLOG_LEVEL_NAMES                                                                                                             \
+        {                                                                                                                                  \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR,  \
+                SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF                                                                          \
+        }
 #endif
-static const char *level_names[] SPDLOG_LEVEL_NAMES;
 
-static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"};
+#if !defined(SPDLOG_SHORT_LEVEL_NAMES)
 
-inline const char *to_c_str(spdlog::level::level_enum l)
-{
-    return level_names[l];
-}
+#    define SPDLOG_SHORT_LEVEL_NAMES                                                                                                       \
+        {                                                                                                                                  \
+            "T", "D", "I", "W", "E", "C", "O"                                                                                              \
+        }
+#endif
 
-inline const char *to_short_c_str(spdlog::level::level_enum l)
-{
-    return short_level_names[l];
-}
+SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
+SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
 
-inline spdlog::level::level_enum from_str(const std::string &name)
-{
-    static std::unordered_map<std::string, level_enum> name_to_level = // map string->level
-        {{level_names[0], level::trace},                               // trace
-            {level_names[1], level::debug},                            // debug
-            {level_names[2], level::info},                             // info
-            {level_names[3], level::warn},                             // warn
-            {level_names[4], level::err},                              // err
-            {level_names[5], level::critical},                         // critical
-            {level_names[6], level::off}};                             // off
-
-    auto lvl_it = name_to_level.find(name);
-    return lvl_it != name_to_level.end() ? lvl_it->second : level::off;
-}
-
-using level_hasher = std::hash<int>;
 } // namespace level
 
+//
+// Color mode used by sinks with color support.
+//
+enum class color_mode
+{
+    always,
+    automatic,
+    never
+};
+
 //
 // Pattern time - specific time getting to use for pattern_formatter.
 // local time by default
@@ -132,46 +226,54 @@ enum class pattern_time_type
 //
 // Log exception
 //
-class spdlog_ex : public std::exception
+class SPDLOG_API spdlog_ex : public std::exception
 {
 public:
-    explicit spdlog_ex(const std::string &msg)
-        : msg_(msg)
-    {
-    }
-
-    spdlog_ex(const std::string &msg, int last_errno)
-    {
-        fmt::memory_buffer outbuf;
-        fmt::format_system_error(outbuf, last_errno, msg);
-        msg_ = fmt::to_string(outbuf);
-    }
-
-    const char *what() const SPDLOG_NOEXCEPT override
-    {
-        return msg_.c_str();
-    }
+    explicit spdlog_ex(std::string msg);
+    spdlog_ex(const std::string &msg, int last_errno);
+    const char *what() const SPDLOG_NOEXCEPT override;
 
 private:
     std::string msg_;
 };
 
-//
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-//
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-using filename_t = std::wstring;
-#else
-using filename_t = std::string;
-#endif
+[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
+[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);
 
-#define SPDLOG_CATCH_AND_HANDLE                                                                                                            \
-    catch (const std::exception &ex)                                                                                                       \
-    {                                                                                                                                      \
-        err_handler_(ex.what());                                                                                                           \
-    }                                                                                                                                      \
-    catch (...)                                                                                                                            \
-    {                                                                                                                                      \
-        err_handler_("Unknown exeption in logger");                                                                                        \
+struct source_loc
+{
+    SPDLOG_CONSTEXPR source_loc() = default;
+    SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)
+        : filename{filename_in}
+        , line{line_in}
+        , funcname{funcname_in}
+    {}
+
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
+    {
+        return line == 0;
     }
+    const char *filename{nullptr};
+    int line{0};
+    const char *funcname{nullptr};
+};
+
+namespace details {
+// make_unique support for pre c++14
+
+#if __cplusplus >= 201402L // C++14 and beyond
+using std::make_unique;
+#else
+template<typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args &&...args)
+{
+    static_assert(!std::is_array<T>::value, "arrays not supported");
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+} // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "common-inl.h"
+#endif

include/spdlog/details/async_logger_impl.h

@@ -1,100 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// async logger implementation
-// uses a thread pool to perform the actual logging
-
-#include "spdlog/details/thread_pool.h"
-
-#include <chrono>
-#include <memory>
-#include <string>
-
-template<typename It>
-inline spdlog::async_logger::async_logger(
-    std::string logger_name, const It &begin, const It &end, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : logger(std::move(logger_name), begin, end)
-    , thread_pool_(tp)
-    , overflow_policy_(overflow_policy)
-{
-}
-
-inline spdlog::async_logger::async_logger(
-    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), tp, overflow_policy)
-{
-}
-
-inline spdlog::async_logger::async_logger(
-    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), {single_sink}, tp, overflow_policy)
-{
-}
-
-// send the log message to the thread pool
-inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
-{
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-    incr_msg_counter_(msg);
-#endif
-    if (auto pool_ptr = thread_pool_.lock())
-    {
-        pool_ptr->post_log(shared_from_this(), std::move(msg), overflow_policy_);
-    }
-    else
-    {
-        throw spdlog_ex("async log: thread pool doesn't exist anymore");
-    }
-}
-
-// send flush request to the thread pool
-inline void spdlog::async_logger::flush_()
-{
-    if (auto pool_ptr = thread_pool_.lock())
-    {
-        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-    }
-    else
-    {
-        throw spdlog_ex("async flush: thread pool doesn't exist anymore");
-    }
-}
-
-//
-// backend functions - called from the thread pool to do the actual job
-//
-inline void spdlog::async_logger::backend_log_(details::log_msg &incoming_log_msg)
-{
-    try
-    {
-        for (auto &s : sinks_)
-        {
-            if (s->should_log(incoming_log_msg.level))
-            {
-                s->log(incoming_log_msg);
-            }
-        }
-    }
-    SPDLOG_CATCH_AND_HANDLE
-
-    if (should_flush_(incoming_log_msg))
-    {
-        backend_flush_();
-    }
-}
-
-inline void spdlog::async_logger::backend_flush_()
-{
-    try
-    {
-        for (auto &sink : sinks_)
-        {
-            sink->flush();
-        }
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}

include/spdlog/details/backtracer-inl.h

@@ -0,0 +1,69 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/backtracer.h>
+#endif
+namespace spdlog {
+namespace details {
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+}
+
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+}
+
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+    return *this;
+}
+
+SPDLOG_INLINE void backtracer::enable(size_t size)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(true, std::memory_order_relaxed);
+    messages_ = circular_q<log_msg_buffer>{size};
+}
+
+SPDLOG_INLINE void backtracer::disable()
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(false, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    messages_.push_back(log_msg_buffer{msg});
+}
+
+// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty())
+    {
+        auto &front_msg = messages_.front();
+        fun(front_msg);
+        messages_.pop_front();
+    }
+}
+} // namespace details
+} // namespace spdlog

include/spdlog/details/backtracer.h

@@ -0,0 +1,45 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/circular_q.h>
+
+#include <atomic>
+#include <mutex>
+#include <functional>
+
+// Store log messages in circular buffer.
+// Useful for storing debug data in case of error/warning happens.
+
+namespace spdlog {
+namespace details {
+class SPDLOG_API backtracer
+{
+    mutable std::mutex mutex_;
+    std::atomic<bool> enabled_{false};
+    circular_q<log_msg_buffer> messages_;
+
+public:
+    backtracer() = default;
+    backtracer(const backtracer &other);
+
+    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
+    backtracer &operator=(backtracer other);
+
+    void enable(size_t size);
+    void disable();
+    bool enabled() const;
+    void push_back(const log_msg &msg);
+
+    // pop all items in the q and apply the given fun on each of them.
+    void foreach_pop(std::function<void(const details::log_msg &)> fun);
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "backtracer-inl.h"
+#endif

include/spdlog/details/circular_q.h

@@ -1,57 +1,119 @@
-//
-// Copyright(c) 2018 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
-// cirucal q view of std::vector.
+// circular q view of std::vector.
 #pragma once
 
 #include <vector>
+#include <cassert>
 
 namespace spdlog {
 namespace details {
 template<typename T>
 class circular_q
 {
+    size_t max_items_ = 0;
+    typename std::vector<T>::size_type head_ = 0;
+    typename std::vector<T>::size_type tail_ = 0;
+    size_t overrun_counter_ = 0;
+    std::vector<T> v_;
+
 public:
-    using item_type = T;
+    using value_type = T;
+
+    // empty ctor - create a disabled queue with no elements allocated at all
+    circular_q() = default;
 
     explicit circular_q(size_t max_items)
         : max_items_(max_items + 1) // one item is reserved as marker for full q
         , v_(max_items_)
+    {}
+
+    circular_q(const circular_q &) = default;
+    circular_q &operator=(const circular_q &) = default;
+
+    // move cannot be default,
+    // since we need to reset head_, tail_, etc to zero in the moved object
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
     {
+        copy_moveable(std::move(other));
+    }
+
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+        return *this;
     }
 
     // push back, overrun (oldest) item if no room left
     void push_back(T &&item)
     {
-        v_[tail_] = std::move(item);
-        tail_ = (tail_ + 1) % max_items_;
-
-        if (tail_ == head_) // overrun last item if full
+        if (max_items_ > 0)
         {
-            head_ = (head_ + 1) % max_items_;
-            ++overrun_counter_;
+            v_[tail_] = std::move(item);
+            tail_ = (tail_ + 1) % max_items_;
+
+            if (tail_ == head_) // overrun last item if full
+            {
+                head_ = (head_ + 1) % max_items_;
+                ++overrun_counter_;
+            }
         }
     }
 
+    // Return reference to the front item.
+    // If there are no elements in the container, the behavior is undefined.
+    const T &front() const
+    {
+        return v_[head_];
+    }
+
+    T &front()
+    {
+        return v_[head_];
+    }
+
+    // Return number of elements actually stored
+    size_t size() const
+    {
+        if (tail_ >= head_)
+        {
+            return tail_ - head_;
+        }
+        else
+        {
+            return max_items_ - (head_ - tail_);
+        }
+    }
+
+    // Return const reference to item by index.
+    // If index is out of range 0…size()-1, the behavior is undefined.
+    const T &at(size_t i) const
+    {
+        assert(i < size());
+        return v_[(head_ + i) % max_items_];
+    }
+
     // Pop item from front.
     // If there are no elements in the container, the behavior is undefined.
-    void pop_front(T &popped_item)
+    void pop_front()
     {
-        popped_item = std::move(v_[head_]);
         head_ = (head_ + 1) % max_items_;
     }
 
-    bool empty()
+    bool empty() const
     {
         return tail_ == head_;
     }
 
-    bool full()
+    bool full() const
     {
         // head is ahead of the tail by 1
-        return ((tail_ + 1) % max_items_) == head_;
+        if (max_items_ > 0)
+        {
+            return ((tail_ + 1) % max_items_) == head_;
+        }
+        return false;
     }
 
     size_t overrun_counter() const
@@ -60,13 +122,20 @@ public:
     }
 
 private:
-    size_t max_items_;
-    typename std::vector<T>::size_type head_ = 0;
-    typename std::vector<T>::size_type tail_ = 0;
+    // copy from other&& and reset it to disabled state
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        max_items_ = other.max_items_;
+        head_ = other.head_;
+        tail_ = other.tail_;
+        overrun_counter_ = other.overrun_counter_;
+        v_ = std::move(other.v_);
 
-    std::vector<T> v_;
-
-    size_t overrun_counter_ = 0;
+        // put &&other in disabled, but valid state
+        other.max_items_ = 0;
+        other.head_ = other.tail_ = 0;
+        other.overrun_counter_ = 0;
+    }
 };
 } // namespace details
 } // namespace spdlog

include/spdlog/details/console_globals.h

@@ -1,42 +1,13 @@
-#pragma once
-//
-// Copyright(c) 2018 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
-#include "spdlog/details/null_mutex.h"
-#include <cstdio>
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
 #include <mutex>
 
 namespace spdlog {
 namespace details {
-struct console_stdout
-{
-    static std::FILE *stream()
-    {
-        return stdout;
-    }
-#ifdef _WIN32
-    static HANDLE handle()
-    {
-        return ::GetStdHandle(STD_OUTPUT_HANDLE);
-    }
-#endif
-};
-
-struct console_stderr
-{
-    static std::FILE *stream()
-    {
-        return stderr;
-    }
-#ifdef _WIN32
-    static HANDLE handle()
-    {
-        return ::GetStdHandle(STD_ERROR_HANDLE);
-    }
-#endif
-};
 
 struct console_mutex
 {

include/spdlog/details/file_helper-inl.h

@@ -0,0 +1,147 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/file_helper.h>
+#endif
+
+#include <spdlog/details/os.h>
+#include <spdlog/common.h>
+
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <string>
+#include <thread>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE file_helper::~file_helper()
+{
+    close();
+}
+
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
+{
+    close();
+    filename_ = fname;
+
+    auto *mode = SPDLOG_FILENAME_T("ab");
+    auto *trunc_mode = SPDLOG_FILENAME_T("wb");
+
+    for (int tries = 0; tries < open_tries_; ++tries)
+    {
+        // create containing folder if not exists already.
+        os::create_dir(os::dir_name(fname));
+        if (truncate)
+        {
+            // Truncate by opening-and-closing a tmp file in "wb" mode, always
+            // opening the actual log-we-write-to in "ab" mode, since that
+            // interacts more politely with eternal processes that might
+            // rotate/truncate the file underneath us.
+            std::FILE *tmp;
+            if (os::fopen_s(&tmp, fname, trunc_mode))
+            {
+                continue;
+            }
+            std::fclose(tmp);
+        }
+        if (!os::fopen_s(&fd_, fname, mode))
+        {
+            return;
+        }
+
+        details::os::sleep_for_millis(open_interval_);
+    }
+
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+}
+
+SPDLOG_INLINE void file_helper::reopen(bool truncate)
+{
+    if (filename_.empty())
+    {
+        throw_spdlog_ex("Failed re opening file - was not opened before");
+    }
+    this->open(filename_, truncate);
+}
+
+SPDLOG_INLINE void file_helper::flush()
+{
+    std::fflush(fd_);
+}
+
+SPDLOG_INLINE void file_helper::close()
+{
+    if (fd_ != nullptr)
+    {
+        std::fclose(fd_);
+        fd_ = nullptr;
+    }
+}
+
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
+{
+    size_t msg_size = buf.size();
+    auto data = buf.data();
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
+    {
+        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE size_t file_helper::size() const
+{
+    if (fd_ == nullptr)
+    {
+        throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
+    }
+    return os::filesize(fd_);
+}
+
+SPDLOG_INLINE const filename_t &file_helper::filename() const
+{
+    return filename_;
+}
+
+//
+// return file path and its extension:
+//
+// "mylog.txt" => ("mylog", ".txt")
+// "mylog" => ("mylog", "")
+// "mylog." => ("mylog.", "")
+// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+//
+// the starting dot in filenames is ignored (hidden files):
+//
+// ".mylog" => (".mylog". "")
+// "my_folder/.mylog" => ("my_folder/.mylog", "")
+// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+{
+    auto ext_index = fname.rfind('.');
+
+    // no valid extension found - return whole path and empty string as
+    // extension
+    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
+    auto folder_index = fname.find_last_of(details::os::folder_seps_filename);
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // finally - return a valid base and extension tuple
+    return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
+}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/file_helper.h

@@ -1,114 +1,34 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
-// Helper class for file sink
-// When failing to open a file, retry several times(5) with small delay between
-// the tries(10 ms)
-// Throw spdlog_ex exception on errors
-
-#include "../details/log_msg.h"
-#include "../details/os.h"
-
-#include <cerrno>
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
+#include <spdlog/common.h>
 #include <tuple>
 
 namespace spdlog {
 namespace details {
 
-class file_helper
+// Helper class for file sinks.
+// When failing to open a file, retry several times(5) with a delay interval(10 ms).
+// Throw spdlog_ex exception on errors.
+
+class SPDLOG_API file_helper
 {
-
 public:
-    const int open_tries = 5;
-    const int open_interval = 10;
-
     explicit file_helper() = default;
 
     file_helper(const file_helper &) = delete;
     file_helper &operator=(const file_helper &) = delete;
+    ~file_helper();
 
-    ~file_helper()
-    {
-        close();
-    }
-
-    void open(const filename_t &fname, bool truncate = false)
-    {
-        close();
-        auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
-        _filename = fname;
-        for (int tries = 0; tries < open_tries; ++tries)
-        {
-            if (!os::fopen_s(&fd_, fname, mode))
-            {
-                return;
-            }
-
-            details::os::sleep_for_millis(open_interval);
-        }
-
-        throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
-    }
-
-    void reopen(bool truncate)
-    {
-        if (_filename.empty())
-        {
-            throw spdlog_ex("Failed re opening file - was not opened before");
-        }
-        open(_filename, truncate);
-    }
-
-    void flush()
-    {
-        std::fflush(fd_);
-    }
-
-    void close()
-    {
-        if (fd_ != nullptr)
-        {
-            std::fclose(fd_);
-            fd_ = nullptr;
-        }
-    }
-
-    void write(const fmt::memory_buffer &buf)
-    {
-        size_t msg_size = buf.size();
-        auto data = buf.data();
-        if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
-        {
-            throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
-        }
-    }
-
-    size_t size() const
-    {
-        if (fd_ == nullptr)
-        {
-            throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
-        }
-        return os::filesize(fd_);
-    }
-
-    const filename_t &filename() const
-    {
-        return _filename;
-    }
-
-    static bool file_exists(const filename_t &fname)
-    {
-        return os::file_exists(fname);
-    }
+    void open(const filename_t &fname, bool truncate = false);
+    void reopen(bool truncate);
+    void flush();
+    void close();
+    void write(const memory_buf_t &buf);
+    size_t size() const;
+    const filename_t &filename() const;
 
     //
     // return file path and its extension:
@@ -123,31 +43,17 @@ public:
     // ".mylog" => (".mylog". "")
     // "my_folder/.mylog" => ("my_folder/.mylog", "")
     // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
-    static std::tuple<filename_t, filename_t> split_by_extenstion(const spdlog::filename_t &fname)
-    {
-        auto ext_index = fname.rfind('.');
-
-        // no valid extension found - return whole path and empty string as
-        // extension
-        if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
-        {
-            return std::make_tuple(fname, spdlog::filename_t());
-        }
-
-        // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
-        auto folder_index = fname.rfind(details::os::folder_sep);
-        if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
-        {
-            return std::make_tuple(fname, spdlog::filename_t());
-        }
-
-        // finally - return a valid base and extension tuple
-        return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
-    }
+    static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);
 
 private:
-    FILE *fd_{nullptr};
-    filename_t _filename;
+    const int open_tries_ = 5;
+    const unsigned int open_interval_ = 10;
+    std::FILE *fd_{nullptr};
+    filename_t filename_;
 };
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "file_helper-inl.h"
+#endif

include/spdlog/details/fmt_helper.h

@@ -1,125 +1,112 @@
-//
-// Created by gabi on 6/15/18.
-//
-
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
 #pragma once
 
-#include "chrono"
-#include "spdlog/fmt/fmt.h"
+#include <chrono>
+#include <type_traits>
+#include <iterator>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/common.h>
 
 // Some fmt helpers to efficiently format and pad ints and strings
 namespace spdlog {
 namespace details {
 namespace fmt_helper {
 
-template<size_t Buffer_Size>
-inline void append_str(const std::string &str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
 {
-    auto *str_ptr = str.data();
-    dest.append(str_ptr, str_ptr + str.size());
+    return spdlog::string_view_t{buf.data(), buf.size()};
 }
 
-template<size_t Buffer_Size>
-inline void append_c_str(const char *c_str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
 {
-    char ch;
-    while ((ch = *c_str) != '\0')
-    {
-        dest.push_back(ch);
-        ++c_str;
-    }
+    auto *buf_ptr = view.data();
+    dest.append(buf_ptr, buf_ptr + view.size());
 }
 
-template<size_t Buffer_Size1, size_t Buffer_Size2>
-inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest)
-{
-    auto *buf_ptr = buf.data();
-    dest.append(buf_ptr, buf_ptr + buf.size());
-}
-
-template<typename T, size_t Buffer_Size>
-inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
 {
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
 
-template<size_t Buffer_Size>
-inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+template<typename T>
+inline unsigned int count_digits(T n)
 {
-    if (n > 99)
-    {
-        append_int(n, dest);
-        return;
-    }
-    if (n > 9) // 10-99
-    {
-        dest.push_back('0' + static_cast<char>(n / 10));
-        dest.push_back('0' + static_cast<char>(n % 10));
-        return;
-    }
-    if (n >= 0) // 0-9
-    {
-        dest.push_back('0');
-        dest.push_back('0' + static_cast<char>(n));
-        return;
-    }
-    // negatives (unlikely, but just in case, let fmt deal with it)
-    fmt::format_to(dest, "{:02}", n);
+    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+    return static_cast<unsigned int>(fmt::
+// fmt 7.0.0 renamed the internal namespace to detail.
+// See: https://github.com/fmtlib/fmt/issues/1538
+#if FMT_VERSION < 70000
+            internal
+#else
+            detail
+#endif
+        ::count_digits(static_cast<count_type>(n)));
 }
 
-template<size_t Buffer_Size>
-inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad2(int n, memory_buf_t &dest)
 {
-    if (n > 999)
+    if (n >= 0 && n < 100) // 0-99
     {
-        append_int(n, dest);
-        return;
+        dest.push_back(static_cast<char>('0' + n / 10));
+        dest.push_back(static_cast<char>('0' + n % 10));
     }
-
-    if (n > 99) // 100-999
+    else // unlikely, but just in case, let fmt deal with it
     {
-        append_int(n / 100, dest);
-        pad2(n % 100, dest);
-        return;
+        fmt::format_to(std::back_inserter(dest), SPDLOG_FMT_RUNTIME("{:02}"), n);
     }
-    if (n > 9) // 10-99
-    {
-        dest.push_back('0');
-        dest.push_back('0' + static_cast<char>(n / 10));
-        dest.push_back('0' + static_cast<char>(n % 10));
-        return;
-    }
-    if (n >= 0)
-    {
-        dest.push_back('0');
-        dest.push_back('0');
-        dest.push_back('0' + static_cast<char>(n));
-        return;
-    }
-    // negatives (unlikely, but just in case let fmt deal with it)
-    fmt::format_to(dest, "{:03}", n);
 }
 
-template<size_t Buffer_Size>
-inline void pad6(size_t n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+template<typename T>
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
 {
-    if (n > 99999)
+    static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
+    for (auto digits = count_digits(n); digits < width; digits++)
+    {
+        dest.push_back('0');
+    }
+    append_int(n, dest);
+}
+
+template<typename T>
+inline void pad3(T n, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
+    if (n < 1000)
+    {
+        dest.push_back(static_cast<char>(n / 100 + '0'));
+        n = n % 100;
+        dest.push_back(static_cast<char>((n / 10) + '0'));
+        dest.push_back(static_cast<char>((n % 10) + '0'));
+    }
+    else
     {
         append_int(n, dest);
-        return;
     }
-    pad3(static_cast<int>(n / 1000), dest);
-    pad3(static_cast<int>(n % 1000), dest);
+}
+
+template<typename T>
+inline void pad6(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 6, dest);
+}
+
+template<typename T>
+inline void pad9(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 9, dest);
 }
 
 // return fraction of a second of the given time_point.
 // e.g.
 // fraction<std::milliseconds>(tp) -> will return the millis part of the second
 template<typename ToDuration>
-inline ToDuration time_fraction(const log_clock::time_point &tp)
+inline ToDuration time_fraction(log_clock::time_point tp)
 {
-    using namespace std::chrono;
+    using std::chrono::duration_cast;
+    using std::chrono::seconds;
     auto duration = tp.time_since_epoch();
     auto secs = duration_cast<seconds>(duration);
     return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);

include/spdlog/details/log_msg-inl.h

@@ -0,0 +1,37 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/log_msg.h>
+#endif
+
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
+    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : logger_name(a_logger_name)
+    , level(lvl)
+    , time(log_time)
+#ifndef SPDLOG_NO_THREAD_ID
+    , thread_id(os::thread_id())
+#endif
+    , source(loc)
+    , payload(msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(
+    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
+{}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/log_msg.h

@@ -1,48 +1,37 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
-#include "spdlog/common.h"
-#include "spdlog/details/os.h"
-
+#include <spdlog/common.h>
 #include <string>
-#include <utility>
 
 namespace spdlog {
 namespace details {
-struct log_msg
+struct SPDLOG_API log_msg
 {
     log_msg() = default;
+    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(const log_msg &other) = default;
+    log_msg &operator=(const log_msg &other) = default;
 
-    log_msg(const std::string *loggers_name, level::level_enum lvl)
-        : logger_name(loggers_name)
-        , level(lvl)
-#ifndef SPDLOG_NO_DATETIME
-        , time(os::now())
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
-        , thread_id(os::thread_id())
-#endif
-    {
-    }
-
-    log_msg(const log_msg &other) = delete;
-    log_msg(log_msg &&other) = delete;
-    log_msg &operator=(log_msg &&other) = delete;
-
-    const std::string *logger_name{nullptr};
-    level::level_enum level;
+    string_view_t logger_name;
+    level::level_enum level{level::off};
     log_clock::time_point time;
-    size_t thread_id;
-    fmt::memory_buffer raw;
-    size_t msg_id{0};
-    // info about wrapping the formatted text with color
+    size_t thread_id{0};
+
+    // wrapping the formatted text with color (updated by pattern_formatter).
     mutable size_t color_range_start{0};
     mutable size_t color_range_end{0};
+
+    source_loc source;
+    string_view_t payload;
 };
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "log_msg-inl.h"
+#endif

include/spdlog/details/log_msg_buffer-inl.h

@@ -0,0 +1,58 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/log_msg_buffer.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
+    : log_msg{orig_msg}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
+    : log_msg{other}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
+{
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+{
+    log_msg::operator=(other);
+    buffer.clear();
+    buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT
+{
+    log_msg::operator=(other);
+    buffer = std::move(other.buffer);
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE void log_msg_buffer::update_string_views()
+{
+    logger_name = string_view_t{buffer.data(), logger_name.size()};
+    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
+}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/log_msg_buffer.h

@@ -0,0 +1,33 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+
+namespace spdlog {
+namespace details {
+
+// Extend log_msg with internal buffer to store its payload.
+// This is needed since log_msg holds string_views that points to stack data.
+
+class SPDLOG_API log_msg_buffer : public log_msg
+{
+    memory_buf_t buffer;
+    void update_string_views();
+
+public:
+    log_msg_buffer() = default;
+    explicit log_msg_buffer(const log_msg &orig_msg);
+    log_msg_buffer(const log_msg_buffer &other);
+    log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+    log_msg_buffer &operator=(const log_msg_buffer &other);
+    log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "log_msg_buffer-inl.h"
+#endif

include/spdlog/details/logger_impl.h

@@ -1,345 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-// create logger with given name, sinks and the default pattern formatter
-// all other ctors will call this one
-template<typename It>
-inline spdlog::logger::logger(std::string logger_name, const It &begin, const It &end)
-    : name_(std::move(logger_name))
-    , sinks_(begin, end)
-    , level_(level::info)
-    , flush_level_(level::off)
-    , last_err_time_(0)
-    , msg_counter_(1) // message counter will start from 1. 0-message id will be
-                      // reserved for controll messages
-{
-    err_handler_ = [this](const std::string &msg) { this->default_err_handler_(msg); };
-}
-
-// ctor with sinks as init list
-inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list)
-    : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end())
-{
-}
-
-// ctor with single sink
-inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink)
-    : logger(std::move(logger_name), {std::move(single_sink)})
-{
-}
-
-inline spdlog::logger::~logger() = default;
-
-inline void spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter> f)
-{
-    for (auto &sink : sinks_)
-    {
-        sink->set_formatter(f->clone());
-    }
-}
-
-inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type)
-{
-    set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Args &... args)
-{
-    if (!should_log(lvl))
-    {
-        return;
-    }
-
-    try
-    {
-        details::log_msg log_msg(&name_, lvl);
-        fmt::format_to(log_msg.raw, fmt, args...);
-        sink_it_(log_msg);
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char *msg)
-{
-    if (!should_log(lvl))
-    {
-        return;
-    }
-    try
-    {
-        details::log_msg log_msg(&name_, lvl);
-        fmt::format_to(log_msg.raw, "{}", msg);
-        sink_it_(log_msg);
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename T>
-inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
-{
-    if (!should_log(lvl))
-    {
-        return;
-    }
-    try
-    {
-        details::log_msg log_msg(&name_, lvl);
-        fmt::format_to(log_msg.raw, "{}", msg);
-        sink_it_(log_msg);
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename... Args>
-inline void spdlog::logger::trace(const char *fmt, const Args &... args)
-{
-    log(level::trace, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::debug(const char *fmt, const Args &... args)
-{
-    log(level::debug, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::info(const char *fmt, const Args &... args)
-{
-    log(level::info, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::warn(const char *fmt, const Args &... args)
-{
-    log(level::warn, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::error(const char *fmt, const Args &... args)
-{
-    log(level::err, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::critical(const char *fmt, const Args &... args)
-{
-    log(level::critical, fmt, args...);
-}
-
-template<typename T>
-inline void spdlog::logger::trace(const T &msg)
-{
-    log(level::trace, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::debug(const T &msg)
-{
-    log(level::debug, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::info(const T &msg)
-{
-    log(level::info, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::warn(const T &msg)
-{
-    log(level::warn, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::error(const T &msg)
-{
-    log(level::err, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::critical(const T &msg)
-{
-    log(level::critical, msg);
-}
-
-#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-template<typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
-{
-    if (!should_log(lvl))
-    {
-        return;
-    }
-
-    decltype(wstring_converter_)::byte_string utf8_string;
-
-    try
-    {
-        {
-            std::lock_guard<std::mutex> lock(wstring_converter_mutex_);
-            utf8_string = wstring_converter_.to_bytes(fmt);
-        }
-        log(lvl, utf8_string.c_str(), args...);
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}
-
-template<typename... Args>
-inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args)
-{
-    log(level::trace, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args)
-{
-    log(level::debug, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args)
-{
-    log(level::info, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args)
-{
-    log(level::warn, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args)
-{
-    log(level::err, fmt, args...);
-}
-
-template<typename... Args>
-inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
-{
-    log(level::critical, fmt, args...);
-}
-
-#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-//
-// name and level
-//
-inline const std::string &spdlog::logger::name() const
-{
-    return name_;
-}
-
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
-{
-    level_.store(log_level);
-}
-
-inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
-{
-    err_handler_ = std::move(err_handler);
-}
-
-inline spdlog::log_err_handler spdlog::logger::error_handler()
-{
-    return err_handler_;
-}
-
-inline void spdlog::logger::flush()
-{
-    try
-    {
-        flush_();
-    }
-    SPDLOG_CATCH_AND_HANDLE
-}
-
-inline void spdlog::logger::flush_on(level::level_enum log_level)
-{
-    flush_level_.store(log_level);
-}
-
-inline bool spdlog::logger::should_flush_(const details::log_msg &msg)
-{
-    auto flush_level = flush_level_.load(std::memory_order_relaxed);
-    return (msg.level >= flush_level) && (msg.level != level::off);
-}
-
-inline spdlog::level::level_enum spdlog::logger::level() const
-{
-    return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
-{
-    return msg_level >= level_.load(std::memory_order_relaxed);
-}
-
-//
-// protected virtual called at end of each user log call (if enabled) by the
-// line_logger
-//
-inline void spdlog::logger::sink_it_(details::log_msg &msg)
-{
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-    incr_msg_counter_(msg);
-#endif
-    for (auto &sink : sinks_)
-    {
-        if (sink->should_log(msg.level))
-        {
-            sink->log(msg);
-        }
-    }
-
-    if (should_flush_(msg))
-    {
-        flush();
-    }
-}
-
-inline void spdlog::logger::flush_()
-{
-    for (auto &sink : sinks_)
-    {
-        sink->flush();
-    }
-}
-
-inline void spdlog::logger::default_err_handler_(const std::string &msg)
-{
-    auto now = time(nullptr);
-    if (now - last_err_time_ < 60)
-    {
-        return;
-    }
-    last_err_time_ = now;
-    auto tm_time = details::os::localtime(now);
-    char date_buf[100];
-    std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
-    fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
-}
-
-inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg)
-{
-    msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
-}
-
-inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const
-{
-    return sinks_;
-}
-
-inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
-{
-    return sinks_;
-}

include/spdlog/details/mpmc_blocking_q.h

@@ -1,9 +1,7 @@
-#pragma once
-
-//
-// Copyright(c) 2018 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
+
+#pragma once
 
 // multi producer-multi consumer blocking queue.
 // enqueue(..) - will block until room found to put the new message.
@@ -12,7 +10,7 @@
 // dequeue_for(..) - will block until the queue is not empty or timeout have
 // passed.
 
-#include "spdlog/details/circular_q.h"
+#include <spdlog/details/circular_q.h>
 
 #include <condition_variable>
 #include <mutex>
@@ -27,8 +25,7 @@ public:
     using item_type = T;
     explicit mpmc_blocking_queue(size_t max_items)
         : q_(max_items)
-    {
-    }
+    {}
 
 #ifndef __MINGW32__
     // try to enqueue and block if no room left
@@ -62,7 +59,8 @@ public:
             {
                 return false;
             }
-            q_.pop_front(popped_item);
+            popped_item = std::move(q_.front());
+            q_.pop_front();
         }
         pop_cv_.notify_one();
         return true;
@@ -98,7 +96,8 @@ public:
         {
             return false;
         }
-        q_.pop_front(popped_item);
+        popped_item = std::move(q_.front());
+        q_.pop_front();
         pop_cv_.notify_one();
         return true;
     }
@@ -111,6 +110,12 @@ public:
         return q_.overrun_counter();
     }
 
+    size_t size()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.size();
+    }
+
 private:
     std::mutex queue_mutex_;
     std::condition_variable push_cv_;

include/spdlog/details/null_mutex.h

@@ -1,20 +1,19 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
 #include <atomic>
+#include <utility>
 // null, no cost dummy "mutex" and dummy "atomic" int
 
 namespace spdlog {
 namespace details {
 struct null_mutex
 {
-    void lock() {}
-    void unlock() {}
-    bool try_lock()
+    void lock() const {}
+    void unlock() const {}
+    bool try_lock() const
     {
         return true;
     }
@@ -25,19 +24,24 @@ struct null_atomic_int
     int value;
     null_atomic_int() = default;
 
-    explicit null_atomic_int(int val)
-        : value(val)
-    {
-    }
+    explicit null_atomic_int(int new_value)
+        : value(new_value)
+    {}
 
-    int load(std::memory_order) const
+    int load(std::memory_order = std::memory_order_relaxed) const
     {
         return value;
     }
 
-    void store(int val)
+    void store(int new_value, std::memory_order = std::memory_order_relaxed)
     {
-        value = val;
+        value = new_value;
+    }
+
+    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        std::swap(new_value, value);
+        return new_value; // return value before the call
     }
 };
 

include/spdlog/details/os-inl.h

@@ -0,0 +1,599 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/os.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <thread>
+#include <array>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#    include <io.h>      // _get_osfhandle and _isatty support
+#    include <process.h> //  _get_pid support
+#    include <spdlog/details/windows_include.h>
+
+#    ifdef __MINGW32__
+#        include <share.h>
+#    endif
+
+#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+#        include <limits>
+#    endif
+
+#    include <direct.h> // for _mkdir/_wmkdir
+
+#else // unix
+
+#    include <fcntl.h>
+#    include <unistd.h>
+
+#    ifdef __linux__
+#        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+
+#    elif defined(_AIX)
+#        include <pthread.h> // for pthread_getthreadid_np
+
+#    elif defined(__DragonFly__) || defined(__FreeBSD__)
+#        include <pthread_np.h> // for pthread_getthreadid_np
+
+#    elif defined(__NetBSD__)
+#        include <lwp.h> // for _lwp_self
+
+#    elif defined(__sun)
+#        include <thread.h> // for thr_self
+#    endif
+
+#endif // unix
+
+#ifndef __has_feature          // Clang - feature checking macros.
+#    define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
+{
+
+#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
+    timespec ts;
+    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
+#else
+    return log_clock::now();
+#endif
+}
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::localtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::localtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return localtime(now_t);
+}
+
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::gmtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::gmtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return gmtime(now_t);
+}
+
+// fopen_s on non windows for writing
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#    else
+    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#    endif
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
+    if (*fp != nullptr)
+    {
+        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        {
+            ::fclose(*fp);
+            *fp = nullptr;
+        }
+    }
+#    endif
+#else // unix
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
+    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
+    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1)
+    {
+        return false;
+    }
+    *fp = ::fdopen(fd, mode.c_str());
+    if (*fp == nullptr)
+    {
+        ::close(fd);
+    }
+#    else
+    *fp = ::fopen((filename.c_str()), mode.c_str());
+#    endif
+#endif
+
+    return *fp == nullptr;
+}
+
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wremove(filename.c_str());
+#else
+    return std::remove(filename.c_str());
+#endif
+}
+
+SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+    return path_exists(filename) ? remove(filename) : 0;
+}
+
+SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wrename(filename1.c_str(), filename2.c_str());
+#else
+    return std::rename(filename1.c_str(), filename2.c_str());
+#endif
+}
+
+// Return true if path exists (file or directory)
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = ::GetFileAttributesW(filename.c_str());
+#    else
+    auto attribs = ::GetFileAttributesA(filename.c_str());
+#    endif
+    return attribs != INVALID_FILE_ATTRIBUTES;
+#else // common linux/unix all have the stat system call
+    struct stat buffer;
+    return (::stat(filename.c_str(), &buffer) == 0);
+#endif
+}
+
+#ifdef _MSC_VER
+// avoid warning about unreachable statement at the end of filesize()
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif
+
+// Return file size according to open FILE* object
+SPDLOG_INLINE size_t filesize(FILE *f)
+{
+    if (f == nullptr)
+    {
+        throw_spdlog_ex("Failed getting file size. fd is null");
+    }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    int fd = ::_fileno(f);
+#    if defined(_WIN64) // 64 bits
+    __int64 ret = ::_filelengthi64(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+
+#    else // windows 32 bits
+    long ret = ::_filelength(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+#    endif
+
+#else // unix
+// OpenBSD doesn't compile with :: before the fileno(..)
+#    if defined(__OpenBSD__)
+    int fd = fileno(f);
+#    else
+    int fd = ::fileno(f);
+#    endif
+// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
+#    if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    struct stat64 st;
+    if (::fstat64(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#    else // other unix or linux 32 bits or cygwin
+    struct stat st;
+    if (::fstat(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#    endif
+#endif
+    throw_spdlog_ex("Failed getting file size from fd", errno);
+    return 0; // will not be reached.
+}
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
+{
+
+#ifdef _WIN32
+#    if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetTimeZoneInformation(&tzinfo);
+#    else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
+#    endif
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw_spdlog_ex("Failed getting timezone info. ", errno);
+
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst)
+    {
+        offset -= tzinfo.DaylightBias;
+    }
+    else
+    {
+        offset -= tzinfo.StandardBias;
+    }
+    return offset;
+#else
+
+#    if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                // difference in day of year
+                localtm.tm_yday -
+                gmtm.tm_yday
+
+                // + intervening leap days
+                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                // + difference in years * 365 */
+                + (long int)(local_year - gmt_year) * 365);
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    auto offset_seconds = helper::calculate_gmt_offset(tm);
+#    else
+    auto offset_seconds = tm.tm_gmtoff;
+#    endif
+
+    return static_cast<int>(offset_seconds / 60);
+#endif
+}
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return static_cast<size_t>(::GetCurrentThreadId());
+#elif defined(__linux__)
+#    if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+#        define SYS_gettid __NR_gettid
+#    endif
+    return static_cast<size_t>(::syscall(SYS_gettid));
+#elif defined(_AIX) || defined(__DragonFly__) || defined(__FreeBSD__)
+    return static_cast<size_t>(::pthread_getthreadid_np());
+#elif defined(__NetBSD__)
+    return static_cast<size_t>(::_lwp_self());
+#elif defined(__OpenBSD__)
+    return static_cast<size_t>(::getthrid());
+#elif defined(__sun)
+    return static_cast<size_t>(::thr_self());
+#elif __APPLE__
+    uint64_t tid;
+    pthread_threadid_np(nullptr, &tid);
+    return static_cast<size_t>(tid);
+#else // Default to standard C++11 (other Unix)
+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+#endif
+}
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+{
+#if defined(SPDLOG_NO_TLS)
+    return _thread_id();
+#else // cache thread id in tls
+    static thread_local const size_t tid = _thread_id();
+    return tid;
+#endif
+}
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32)
+    ::Sleep(milliseconds);
+#else
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+#endif
+}
+
+// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    memory_buf_t buf;
+    wstr_to_utf8buf(filename, buf);
+    return fmt::to_string(buf);
+}
+#else
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    return filename;
+}
+#endif
+
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return static_cast<int>(::GetCurrentProcessId());
+#else
+    return static_cast<int>(::getpid());
+#endif
+}
+
+// Determine if the terminal supports colors
+// Based on: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return true;
+#else
+
+    static const bool result = []() {
+        const char *env_colorterm_p = std::getenv("COLORTERM");
+        if (env_colorterm_p != nullptr)
+        {
+            return true;
+        }
+
+        static constexpr std::array<const char *, 16> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
+            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
+
+        const char *env_term_p = std::getenv("TERM");
+        if (env_term_p == nullptr)
+        {
+            return false;
+        }
+
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
+    }();
+
+    return result;
+#endif
+}
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return ::_isatty(_fileno(file)) != 0;
+#else
+    return ::isatty(fileno(file)) != 0;
+#endif
+}
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
+{
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
+    {
+        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
+    }
+
+    int wstr_size = static_cast<int>(wstr.size());
+    if (wstr_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if ((wstr_size + 1) * 2 > result_size)
+    {
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+}
+
+SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
+{
+    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
+    {
+        throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");
+    }
+
+    int str_size = static_cast<int>(str.size());
+    if (str_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if (str_size + 1 > result_size)
+    {
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+}
+#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+
+// return true on success
+static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+{
+#ifdef _WIN32
+#    ifdef SPDLOG_WCHAR_FILENAMES
+    return ::_wmkdir(path.c_str()) == 0;
+#    else
+    return ::_mkdir(path.c_str()) == 0;
+#    endif
+#else
+    return ::mkdir(path.c_str(), mode_t(0755)) == 0;
+#endif
+}
+
+// create the given directory - and all directories leading to it
+// return true on success or if the directory already exists
+SPDLOG_INLINE bool create_dir(filename_t path)
+{
+    if (path_exists(path))
+    {
+        return true;
+    }
+
+    if (path.empty())
+    {
+        return false;
+    }
+
+    size_t search_offset = 0;
+    do
+    {
+        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
+        // treat the entire path as a folder if no folder separator not found
+        if (token_pos == filename_t::npos)
+        {
+            token_pos = path.size();
+        }
+
+        auto subdir = path.substr(0, token_pos);
+
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
+        {
+            return false; // return error if failed creating dir
+        }
+        search_offset = token_pos + 1;
+    } while (search_offset < path.size());
+
+    return true;
+}
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_INLINE filename_t dir_name(filename_t path)
+{
+    auto pos = path.find_last_of(folder_seps_filename);
+    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
+}
+
+std::string SPDLOG_INLINE getenv(const char *field)
+{
+
+#if defined(_MSC_VER)
+#    if defined(__cplusplus_winrt)
+    return std::string{}; // not supported under uwp
+#    else
+    size_t len = 0;
+    char buf[128];
+    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+    return ok ? buf : std::string{};
+#    endif
+#else // revert to getenv
+    char *buf = ::getenv(field);
+    return buf ? buf : std::string{};
+#endif
+}
+
+} // namespace os
+} // namespace details
+} // namespace spdlog

include/spdlog/details/os.h

@@ -1,432 +1,118 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
+
 #pragma once
 
-#include "../common.h"
-
-#include <algorithm>
-#include <chrono>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <functional>
-#include <string>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <thread>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX // prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <io.h>      // _get_osfhandle and _isatty support
-#include <process.h> //  _get_pid support
-#include <windows.h>
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#else // unix
-
-#include <fcntl.h>
-#include <unistd.h>
-
-#ifdef __linux__
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-
-#elif __FreeBSD__
-#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
-#endif
-
-#endif // unix
-
-#ifndef __has_feature      // Clang - feature checking macros.
-#define __has_feature(x) 0 // Compatibility with non-clang compilers.
-#endif
+#include <spdlog/common.h>
+#include <ctime> // std::time_t
 
 namespace spdlog {
 namespace details {
 namespace os {
 
-inline spdlog::log_clock::time_point now()
-{
+SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;
 
-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
-    timespec ts;
-    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
-    return std::chrono::time_point<log_clock, typename log_clock::duration>(
-        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
 
-#else
-    return log_clock::now();
-#endif
-}
-inline std::tm localtime(const std::time_t &time_tt)
-{
+SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;
 
-#ifdef _WIN32
-    std::tm tm;
-    localtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    localtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
+SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
 
-inline std::tm localtime()
-{
-    std::time_t now_t = time(nullptr);
-    return localtime(now_t);
-}
-
-inline std::tm gmtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    gmtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    gmtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm gmtime()
-{
-    std::time_t now_t = time(nullptr);
-    return gmtime(now_t);
-}
-inline bool operator==(const std::tm &tm1, const std::tm &tm2)
-{
-    return (tm1.tm_sec == tm2.tm_sec && tm1.tm_min == tm2.tm_min && tm1.tm_hour == tm2.tm_hour && tm1.tm_mday == tm2.tm_mday &&
-            tm1.tm_mon == tm2.tm_mon && tm1.tm_year == tm2.tm_year && tm1.tm_isdst == tm2.tm_isdst);
-}
-
-inline bool operator!=(const std::tm &tm1, const std::tm &tm2)
-{
-    return !(tm1 == tm2);
-}
+SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
 
 // eol definition
 #if !defined(SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
+#    ifdef _WIN32
+#        define SPDLOG_EOL "\r\n"
+#    else
+#        define SPDLOG_EOL "\n"
+#    endif
 #endif
 
 SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
 
 // folder separator
-#ifdef _WIN32
-SPDLOG_CONSTEXPR static const char folder_sep = '\\';
-#else
-SPDLOG_CONSTEXPR static const char folder_sep = '/';
+#if !defined(SPDLOG_FOLDER_SEPS)
+#    ifdef _WIN32
+#        define SPDLOG_FOLDER_SEPS "\\/"
+#    else
+#        define SPDLOG_FOLDER_SEPS "/"
+#    endif
 #endif
 
-inline void prevent_child_fd(FILE *f)
-{
-
-#ifdef _WIN32
-#if !defined(__cplusplus_winrt)
-    auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
-    if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
-        throw spdlog_ex("SetHandleInformation failed", errno);
-#endif
-#else
-    auto fd = fileno(f);
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
-    {
-        throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
-    }
-#endif
-}
+SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
 
 // fopen_s on non windows for writing
-inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#else
-    *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#endif
-#else // unix
-    *fp = fopen((filename.c_str()), mode.c_str());
-#endif
+SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
 
-#ifdef SPDLOG_PREVENT_CHILD_FD
-    if (*fp != nullptr)
-    {
-        prevent_child_fd(*fp);
-    }
-#endif
-    return *fp == nullptr;
-}
+// Remove filename. return 0 on success
+SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;
 
-inline int remove(const filename_t &filename)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wremove(filename.c_str());
-#else
-    return std::remove(filename.c_str());
-#endif
-}
+// Remove file if exists. return 0 on success
+// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)
+SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
 
-inline int rename(const filename_t &filename1, const filename_t &filename2)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wrename(filename1.c_str(), filename2.c_str());
-#else
-    return std::rename(filename1.c_str(), filename2.c_str());
-#endif
-}
+SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;
 
-// Return if file exists
-inline bool file_exists(const filename_t &filename)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    auto attribs = GetFileAttributesW(filename.c_str());
-#else
-    auto attribs = GetFileAttributesA(filename.c_str());
-#endif
-    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else // common linux/unix all have the stat system call
-    struct stat buffer;
-    return (stat(filename.c_str(), &buffer) == 0);
-#endif
-}
+// Return if file exists.
+SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
 
 // Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
-{
-    if (f == nullptr)
-    {
-        throw spdlog_ex("Failed getting file size. fd is null");
-    }
-#if defined(_WIN32) && !defined(__CYGWIN__)
-    int fd = _fileno(f);
-#if _WIN64 // 64 bits
-    struct _stat64 st;
-    if (_fstat64(fd, &st) == 0)
-    {
-        return st.st_size;
-    }
-
-#else // windows 32 bits
-    long ret = _filelength(fd);
-    if (ret >= 0)
-    {
-        return static_cast<size_t>(ret);
-    }
-#endif
-
-#else // unix
-    int fd = fileno(f);
-// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
-    struct stat64 st;
-    if (fstat64(fd, &st) == 0)
-    {
-        return static_cast<size_t>(st.st_size);
-    }
-#else // unix 32 bits or cygwin
-    struct stat st;
-
-    if (fstat(fd, &st) == 0)
-    {
-        return static_cast<size_t>(st.st_size);
-    }
-#endif
-#endif
-    throw spdlog_ex("Failed getting file size from fd", errno);
-}
+SPDLOG_API size_t filesize(FILE *f);
 
 // Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
-    TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetTimeZoneInformation(&tzinfo);
-#else
-    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
-    if (rv == TIME_ZONE_ID_INVALID)
-        throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
-
-    int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
-    {
-        offset -= tzinfo.DaylightBias;
-    }
-    else
-    {
-        offset -= tzinfo.StandardBias;
-    }
-    return offset;
-#else
-
-#if defined(sun) || defined(__sun) || defined(_AIX)
-    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper
-    {
-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
-        {
-            int local_year = localtm.tm_year + (1900 - 1);
-            int gmt_year = gmtm.tm_year + (1900 - 1);
-
-            long int days = (
-                // difference in day of year
-                localtm.tm_yday -
-                gmtm.tm_yday
-
-                // + intervening leap days
-                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
-                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
-
-                // + difference in years * 365 */
-                + (long int)(local_year - gmt_year) * 365);
-
-            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
-            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
-            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
-
-            return secs;
-        }
-    };
-
-    auto offset_seconds = helper::calculate_gmt_offset(tm);
-#else
-    auto offset_seconds = tm.tm_gmtoff;
-#endif
-
-    return static_cast<int>(offset_seconds / 60);
-#endif
-}
+SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());
 
 // Return current thread id as size_t
 // It exists because the std::this_thread::get_id() is much slower(especially
 // under VS 2013)
-inline size_t _thread_id()
-{
-#ifdef _WIN32
-    return static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#define SYS_gettid __NR_gettid
-#endif
-    return static_cast<size_t>(syscall(SYS_gettid));
-#elif __FreeBSD__
-    long tid;
-    thr_self(&tid);
-    return static_cast<size_t>(tid);
-#elif __APPLE__
-    uint64_t tid;
-    pthread_threadid_np(nullptr, &tid);
-    return static_cast<size_t>(tid);
-#else // Default to standard C++11 (other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-}
+SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;
 
 // Return current thread id as size_t (from thread local storage)
-inline size_t thread_id()
-{
-#if defined(SPDLOG_DISABLE_TID_CACHING) || (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) ||                       \
-    (defined(__clang__) && !__has_feature(cxx_thread_local))
-    return _thread_id();
-#else // cache thread id in tls
-    static thread_local const size_t tid = _thread_id();
-    return tid;
-#endif
-}
+SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;
 
 // This is avoid msvc issue in sleep_for that happens if the clock changes.
 // See https://github.com/gabime/spdlog/issues/609
-inline void sleep_for_millis(int milliseconds)
-{
-#if defined(_WIN32)
-    ::Sleep(milliseconds);
-#else
-    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
-#endif
-}
+SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT;
 
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#define SPDLOG_FILENAME_T(s) L##s
-inline std::string filename_to_str(const filename_t &filename)
-{
-    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
-    return c.to_bytes(filename);
-}
-#else
-#define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t &filename)
-{
-    return filename;
-}
-#endif
+SPDLOG_API std::string filename_to_str(const filename_t &filename);
 
-inline int pid()
-{
-
-#ifdef _WIN32
-    return static_cast<int>(::GetCurrentProcessId());
-#else
-    return static_cast<int>(::getpid());
-#endif
-}
+SPDLOG_API int pid() SPDLOG_NOEXCEPT;
 
 // Determine if the terminal supports colors
 // Source: https://github.com/agauniyal/rang/
-inline bool is_color_terminal()
-{
-#ifdef _WIN32
-    return true;
-#else
-    static constexpr const char *Terms[] = {
-        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"};
+SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;
 
-    const char *env_p = std::getenv("TERM");
-    if (env_p == nullptr)
-    {
-        return false;
-    }
-
-    static const bool result =
-        std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
-    return result;
-#endif
-}
-
-// Detrmine if the terminal attached
+// Determine if the terminal attached
 // Source: https://github.com/agauniyal/rang/
-inline bool in_terminal(FILE *file)
-{
+SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
 
-#ifdef _WIN32
-    return _isatty(_fileno(file)) != 0;
-#else
-    return isatty(fileno(file)) != 0;
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
+
+SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
 #endif
-}
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_API filename_t dir_name(filename_t path);
+
+// Create a dir from the given path.
+// Return true if succeeded or if this dir already exists.
+SPDLOG_API bool create_dir(filename_t path);
+
+// non thread safe, cross platform getenv/getenv_s
+// return empty string if field not found
+SPDLOG_API std::string getenv(const char *field);
+
 } // namespace os
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "os-inl.h"
+#endif

include/spdlog/details/pattern_formatter.h

@@ -1,772 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/formatter.h"
-
-#include <array>
-#include <chrono>
-#include <ctime>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog {
-namespace details {
-
-class flag_formatter
-{
-public:
-    virtual ~flag_formatter() = default;
-    virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////
-// name & level pattern appenders
-///////////////////////////////////////////////////////////////////////
-class name_formatter : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_str(*msg.logger_name, dest);
-    }
-};
-
-// log level appender
-class level_formatter : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(level::to_c_str(msg.level), dest);
-    }
-};
-
-// short log level appender
-class short_level_formatter : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(level::to_short_c_str(msg.level), dest);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////
-// Date time pattern appenders
-///////////////////////////////////////////////////////////////////////
-
-static const char *ampm(const tm &t)
-{
-    return t.tm_hour >= 12 ? "PM" : "AM";
-}
-
-static int to12h(const tm &t)
-{
-    return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
-}
-
-// Abbreviated weekday name
-static const char *days[]{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-class a_formatter : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(days[tm_time.tm_wday], dest);
-    }
-};
-
-// Full weekday name
-static const char *full_days[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
-class A_formatter : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(full_days[tm_time.tm_wday], dest);
-    }
-};
-
-// Abbreviated month
-static const char *months[]{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
-class b_formatter : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(months[tm_time.tm_mon], dest);
-    }
-};
-
-// Full month name
-static const char *full_months[]{
-    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
-class B_formatter : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(full_months[tm_time.tm_mon], dest);
-    }
-};
-
-// Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        // fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday],
-        // months[tm_time.tm_mon], tm_time.tm_mday);
-        // date
-        fmt_helper::append_str(days[tm_time.tm_wday], dest);
-        dest.push_back(' ');
-        fmt_helper::append_str(months[tm_time.tm_mon], dest);
-        dest.push_back(' ');
-        fmt_helper::append_int(tm_time.tm_mday, dest);
-        dest.push_back(' ');
-        // time
-
-        fmt_helper::pad2(tm_time.tm_hour, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_min, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_sec, dest);
-        dest.push_back(' ');
-        fmt_helper::append_int(tm_time.tm_year + 1900, dest);
-    }
-};
-
-// year - 2 digit
-class C_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_year % 100, dest);
-    }
-};
-
-// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_mon + 1, dest);
-        dest.push_back('/');
-        fmt_helper::pad2(tm_time.tm_mday, dest);
-        dest.push_back('/');
-        fmt_helper::pad2(tm_time.tm_year % 100, dest);
-    }
-};
-
-// year - 4 digit
-class Y_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_int(tm_time.tm_year + 1900, dest);
-    }
-};
-
-// month 1-12
-class m_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_mon + 1, dest);
-    }
-};
-
-// day of month 1-31
-class d_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_mday, dest);
-    }
-};
-
-// hours in 24 format 0-23
-class H_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_hour, dest);
-    }
-};
-
-// hours in 12 format 1-12
-class I_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(to12h(tm_time), dest);
-    }
-};
-
-// minutes 0-59
-class M_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_min, dest);
-    }
-};
-
-// seconds 0-59
-class S_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_sec, dest);
-    }
-};
-
-// milliseconds
-class e_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
-        fmt_helper::pad3(static_cast<int>(millis.count()), dest);
-    }
-};
-
-// microseconds
-class f_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
-        fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
-    }
-};
-
-// nanoseconds
-class F_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
-        fmt::format_to(dest, "{:09}", ns.count());
-    }
-};
-
-// seconds since epoch
-class E_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-        fmt_helper::append_int(seconds, dest);
-    }
-};
-
-// AM/PM
-class p_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_c_str(ampm(tm_time), dest);
-    }
-};
-
-// 12 hour clock 02:55:02 pm
-class r_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(to12h(tm_time), dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_min, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_sec, dest);
-        dest.push_back(' ');
-        fmt_helper::append_c_str(ampm(tm_time), dest);
-    }
-};
-
-// 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad2(tm_time.tm_hour, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_min, dest);
-    }
-};
-
-// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        // fmt::format_to(dest, "{:02}:{:02}:{:02}", tm_time.tm_hour,
-        // tm_time.tm_min, tm_time.tm_sec);
-        fmt_helper::pad2(tm_time.tm_hour, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_min, dest);
-        dest.push_back(':');
-        fmt_helper::pad2(tm_time.tm_sec, dest);
-    }
-};
-
-// ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter SPDLOG_FINAL : public flag_formatter
-{
-public:
-    const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
-
-    z_formatter() = default;
-    z_formatter(const z_formatter &) = delete;
-    z_formatter &operator=(const z_formatter &) = delete;
-
-    void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-#ifdef _WIN32
-        int total_minutes = get_cached_offset(msg, tm_time);
-#else
-        // No need to chache under gcc,
-        // it is very fast (already stored in tm.tm_gmtoff)
-        (void)(msg);
-        int total_minutes = os::utc_minutes_offset(tm_time);
-#endif
-        bool is_negative = total_minutes < 0;
-        if (is_negative)
-        {
-            total_minutes = -total_minutes;
-            dest.push_back('-');
-        }
-        else
-        {
-            dest.push_back('+');
-        }
-
-        fmt_helper::pad2(total_minutes / 60, dest); // hours
-        dest.push_back(':');
-        fmt_helper::pad2(total_minutes % 60, dest); // minutes
-    }
-
-private:
-    log_clock::time_point last_update_{std::chrono::seconds(0)};
-#ifdef _WIN32
-    int offset_minutes_{0};
-
-    int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
-    {
-        if (msg.time - last_update_ >= cache_refresh)
-        {
-            offset_minutes_ = os::utc_minutes_offset(tm_time);
-            last_update_ = msg.time;
-        }
-        return offset_minutes_;
-    }
-#endif
-};
-
-// Thread id
-class t_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad6(msg.thread_id, dest);
-    }
-};
-
-// Current pid
-class pid_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_int(details::os::pid(), dest);
-    }
-};
-
-// message counter formatter
-class i_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::pad6(msg.msg_id, dest);
-    }
-};
-
-class v_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_buf(msg.raw, dest);
-    }
-};
-
-class ch_formatter SPDLOG_FINAL : public flag_formatter
-{
-public:
-    explicit ch_formatter(char ch)
-        : ch_(ch)
-    {
-    }
-    void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        dest.push_back(ch_);
-    }
-
-private:
-    char ch_;
-};
-
-// aggregate user chars to display as is
-class aggregate_formatter SPDLOG_FINAL : public flag_formatter
-{
-public:
-    aggregate_formatter() = default;
-
-    void add_ch(char ch)
-    {
-        str_ += ch;
-    }
-    void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        fmt_helper::append_str(str_, dest);
-    }
-
-private:
-    std::string str_;
-};
-
-// mark the color range. expect it to be in the form of "%^colored text%$"
-class color_start_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        msg.color_range_start = dest.size();
-    }
-};
-class color_stop_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
-    {
-        msg.color_range_end = dest.size();
-    }
-};
-
-// Full info formatter
-// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter SPDLOG_FINAL : public flag_formatter
-{
-    void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
-    {
-        using namespace std::chrono;
-#ifndef SPDLOG_NO_DATETIME
-
-        // cache the date/time part for the next second.
-        auto duration = msg.time.time_since_epoch();
-        auto secs = duration_cast<seconds>(duration);
-
-        if (cache_timestamp_ != secs || cached_datetime_.size() == 0)
-        {
-            cached_datetime_.resize(0);
-            cached_datetime_.push_back('[');
-            fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
-            cached_datetime_.push_back('-');
-
-            fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
-            cached_datetime_.push_back('-');
-
-            fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
-            cached_datetime_.push_back(' ');
-
-            fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
-            cached_datetime_.push_back(':');
-
-            fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
-            cached_datetime_.push_back(':');
-
-            fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
-            cached_datetime_.push_back('.');
-
-            cache_timestamp_ = secs;
-        }
-        fmt_helper::append_buf(cached_datetime_, dest);
-
-        auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
-        fmt_helper::pad3(static_cast<int>(millis.count()), dest);
-        dest.push_back(']');
-        dest.push_back(' ');
-
-#else // no datetime needed
-        (void)tm_time;
-#endif
-
-#ifndef SPDLOG_NO_NAME
-        dest.push_back('[');
-        fmt_helper::append_str(*msg.logger_name, dest);
-        dest.push_back(']');
-        dest.push_back(' ');
-#endif
-
-        dest.push_back('[');
-        // wrap the level name with color
-        msg.color_range_start = dest.size();
-        fmt_helper::append_c_str(level::to_c_str(msg.level), dest);
-        msg.color_range_end = dest.size();
-        dest.push_back(']');
-        dest.push_back(' ');
-        fmt_helper::append_buf(msg.raw, dest);
-    }
-
-private:
-    std::chrono::seconds cache_timestamp_{0};
-    fmt::basic_memory_buffer<char, 128> cached_datetime_;
-};
-
-} // namespace details
-
-class pattern_formatter SPDLOG_FINAL : public formatter
-{
-public:
-    explicit pattern_formatter(
-        std::string pattern, pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol)
-        : pattern_(std::move(pattern))
-        , eol_(std::move(eol))
-        , pattern_time_type_(time_type)
-        , last_log_secs_(0)
-    {
-        std::memset(&cached_tm_, 0, sizeof(cached_tm_));
-        compile_pattern_(pattern_);
-    }
-
-    pattern_formatter(const pattern_formatter &other) = delete;
-    pattern_formatter &operator=(const pattern_formatter &other) = delete;
-
-    std::unique_ptr<formatter> clone() const override
-    {
-        return std::unique_ptr<formatter>(new pattern_formatter(pattern_, pattern_time_type_, eol_));
-    }
-
-    void format(const details::log_msg &msg, fmt::memory_buffer &dest) override
-    {
-#ifndef SPDLOG_NO_DATETIME
-        auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
-        if (secs != last_log_secs_)
-        {
-            cached_tm_ = get_time_(msg);
-            last_log_secs_ = secs;
-        }
-#endif
-        for (auto &f : formatters_)
-        {
-            f->format(msg, cached_tm_, dest);
-        }
-        // write eol
-        details::fmt_helper::append_str(eol_, dest);
-    }
-
-private:
-    std::string pattern_;
-    std::string eol_;
-    pattern_time_type pattern_time_type_;
-    std::tm cached_tm_;
-    std::chrono::seconds last_log_secs_;
-
-    std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
-
-    std::tm get_time_(const details::log_msg &msg)
-    {
-        if (pattern_time_type_ == pattern_time_type::local)
-        {
-            return details::os::localtime(log_clock::to_time_t(msg.time));
-        }
-        return details::os::gmtime(log_clock::to_time_t(msg.time));
-    }
-
-    void handle_flag_(char flag)
-    {
-        using flag_formatter_ptr = std::unique_ptr<details::flag_formatter>;
-        switch (flag)
-        {
-        // logger name
-        case 'n':
-            formatters_.push_back(flag_formatter_ptr(new details::name_formatter()));
-            break;
-
-        case 'l':
-            formatters_.push_back(flag_formatter_ptr(new details::level_formatter()));
-            break;
-
-        case 'L':
-            formatters_.push_back(flag_formatter_ptr(new details::short_level_formatter()));
-            break;
-
-        case ('t'):
-            formatters_.push_back(flag_formatter_ptr(new details::t_formatter()));
-            break;
-
-        case ('v'):
-            formatters_.push_back(flag_formatter_ptr(new details::v_formatter()));
-            break;
-
-        case ('a'):
-            formatters_.push_back(flag_formatter_ptr(new details::a_formatter()));
-            break;
-
-        case ('A'):
-            formatters_.push_back(flag_formatter_ptr(new details::A_formatter()));
-            break;
-
-        case ('b'):
-        case ('h'):
-            formatters_.push_back(flag_formatter_ptr(new details::b_formatter()));
-            break;
-
-        case ('B'):
-            formatters_.push_back(flag_formatter_ptr(new details::B_formatter()));
-            break;
-        case ('c'):
-            formatters_.push_back(flag_formatter_ptr(new details::c_formatter()));
-            break;
-
-        case ('C'):
-            formatters_.push_back(flag_formatter_ptr(new details::C_formatter()));
-            break;
-
-        case ('Y'):
-            formatters_.push_back(flag_formatter_ptr(new details::Y_formatter()));
-            break;
-
-        case ('D'):
-        case ('x'):
-            formatters_.push_back(flag_formatter_ptr(new details::D_formatter()));
-            break;
-
-        case ('m'):
-            formatters_.push_back(flag_formatter_ptr(new details::m_formatter()));
-            break;
-
-        case ('d'):
-            formatters_.push_back(flag_formatter_ptr(new details::d_formatter()));
-            break;
-
-        case ('H'):
-            formatters_.push_back(flag_formatter_ptr(new details::H_formatter()));
-            break;
-
-        case ('I'):
-            formatters_.push_back(flag_formatter_ptr(new details::I_formatter()));
-            break;
-
-        case ('M'):
-            formatters_.push_back(flag_formatter_ptr(new details::M_formatter()));
-            break;
-
-        case ('S'):
-            formatters_.push_back(flag_formatter_ptr(new details::S_formatter()));
-            break;
-
-        case ('e'):
-            formatters_.push_back(flag_formatter_ptr(new details::e_formatter()));
-            break;
-
-        case ('f'):
-            formatters_.push_back(flag_formatter_ptr(new details::f_formatter()));
-            break;
-        case ('F'):
-            formatters_.push_back(flag_formatter_ptr(new details::F_formatter()));
-            break;
-
-        case ('E'):
-            formatters_.push_back(flag_formatter_ptr(new details::E_formatter()));
-            break;
-
-        case ('p'):
-            formatters_.push_back(flag_formatter_ptr(new details::p_formatter()));
-            break;
-
-        case ('r'):
-            formatters_.push_back(flag_formatter_ptr(new details::r_formatter()));
-            break;
-
-        case ('R'):
-            formatters_.push_back(flag_formatter_ptr(new details::R_formatter()));
-            break;
-
-        case ('T'):
-        case ('X'):
-            formatters_.push_back(flag_formatter_ptr(new details::T_formatter()));
-            break;
-
-        case ('z'):
-            formatters_.push_back(flag_formatter_ptr(new details::z_formatter()));
-            break;
-
-        case ('+'):
-            formatters_.push_back(flag_formatter_ptr(new details::full_formatter()));
-            break;
-
-        case ('P'):
-            formatters_.push_back(flag_formatter_ptr(new details::pid_formatter()));
-            break;
-
-        case ('i'):
-            formatters_.push_back(flag_formatter_ptr(new details::i_formatter()));
-            break;
-
-        case ('^'):
-            formatters_.push_back(flag_formatter_ptr(new details::color_start_formatter()));
-            break;
-
-        case ('$'):
-            formatters_.push_back(flag_formatter_ptr(new details::color_stop_formatter()));
-            break;
-
-        default: // Unknown flag appears as is
-            formatters_.push_back(flag_formatter_ptr(new details::ch_formatter('%')));
-            formatters_.push_back(flag_formatter_ptr(new details::ch_formatter(flag)));
-            break;
-        }
-    }
-
-    void compile_pattern_(const std::string &pattern)
-    {
-        auto end = pattern.end();
-        std::unique_ptr<details::aggregate_formatter> user_chars;
-        formatters_.clear();
-        for (auto it = pattern.begin(); it != end; ++it)
-        {
-            if (*it == '%')
-            {
-                if (user_chars) // append user chars found so far
-                {
-                    formatters_.push_back(std::move(user_chars));
-                }
-                if (++it != end)
-                {
-                    handle_flag_(*it);
-                }
-                else
-                {
-                    break;
-                }
-            }
-            else // chars not following the % sign should be displayed as is
-            {
-                if (!user_chars)
-                {
-                    user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());
-                }
-                user_chars->add_ch(*it);
-            }
-        }
-        if (user_chars) // append raw chars found so far
-        {
-            formatters_.push_back(std::move(user_chars));
-        }
-    }
-};
-} // namespace spdlog

include/spdlog/details/periodic_worker-inl.h

@@ -0,0 +1,49 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/periodic_worker.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+{
+    active_ = (interval > std::chrono::seconds::zero());
+    if (!active_)
+    {
+        return;
+    }
+
+    worker_thread_ = std::thread([this, callback_fun, interval]() {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(this->mutex_);
+            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+            {
+                return; // active_ == false, so exit this thread
+            }
+            callback_fun();
+        }
+    });
+}
+
+// stop the worker thread and join it
+SPDLOG_INLINE periodic_worker::~periodic_worker()
+{
+    if (worker_thread_.joinable())
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            active_ = false;
+        }
+        cv_.notify_one();
+        worker_thread_.join();
+    }
+}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/periodic_worker.h

@@ -1,8 +1,5 @@
-
-//
-// Copyright(c) 2018 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
@@ -10,7 +7,7 @@
 //
 // RAII over the owned thread:
 //    creates the thread on construction.
-//    stops and joins the thread on destruction.
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
 
 #include <chrono>
 #include <condition_variable>
@@ -20,46 +17,14 @@
 namespace spdlog {
 namespace details {
 
-class periodic_worker
+class SPDLOG_API periodic_worker
 {
 public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
-    {
-        active_ = (interval > std::chrono::seconds::zero());
-        if (!active_)
-        {
-            return;
-        }
-
-        worker_thread_ = std::thread([this, callback_fun, interval]() {
-            for (;;)
-            {
-                std::unique_lock<std::mutex> lock(this->mutex_);
-                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
-                {
-                    return; // active_ == false, so exit this thread
-                }
-                callback_fun();
-            }
-        });
-    }
-
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
     periodic_worker(const periodic_worker &) = delete;
     periodic_worker &operator=(const periodic_worker &) = delete;
-
     // stop the worker thread and join it
-    ~periodic_worker()
-    {
-        if (worker_thread_.joinable())
-        {
-            {
-                std::lock_guard<std::mutex> lock(mutex_);
-                active_ = false;
-            }
-            cv_.notify_one();
-            worker_thread_.join();
-        }
-    }
+    ~periodic_worker();
 
 private:
     bool active_;
@@ -69,3 +34,7 @@ private:
 };
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "periodic_worker-inl.h"
+#endif

include/spdlog/details/registry-inl.h

@@ -0,0 +1,313 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/registry.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+#include <spdlog/logger.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+// support for the default stdout color logger
+#    ifdef _WIN32
+#        include <spdlog/sinks/wincolor_sink.h>
+#    else
+#        include <spdlog/sinks/ansicolor_sink.h>
+#    endif
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE registry::registry()
+    : formatter_(new pattern_formatter())
+{
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+#    ifdef _WIN32
+    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
+#    else
+    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
+#    endif
+
+    const char *default_logger_name = "";
+    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
+    loggers_[default_logger_name] = default_logger_;
+
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+}
+
+SPDLOG_INLINE registry::~registry() = default;
+
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    register_logger_(std::move(new_logger));
+}
+
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    new_logger->set_formatter(formatter_->clone());
+
+    if (err_handler_)
+    {
+        new_logger->set_error_handler(err_handler_);
+    }
+
+    // set new level according to previously configured level or default level
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+
+    new_logger->flush_on(flush_level_);
+
+    if (backtrace_n_messages_ > 0)
+    {
+        new_logger->enable_backtrace(backtrace_n_messages_);
+    }
+
+    if (automatic_registration_)
+    {
+        register_logger_(std::move(new_logger));
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto found = loggers_.find(logger_name);
+    return found == loggers_.end() ? nullptr : found->second;
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    return default_logger_;
+}
+
+// Return raw ptr to the default logger.
+// To be used directly by the spdlog default api (e.g. spdlog::info)
+// This make the default API faster, but cannot be used concurrently with set_default_logger().
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+SPDLOG_INLINE logger *registry::get_default_raw()
+{
+    return default_logger_.get();
+}
+
+// set default logger.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    // remove previous default logger from the map
+    if (default_logger_ != nullptr)
+    {
+        loggers_.erase(default_logger_->name());
+    }
+    if (new_default_logger != nullptr)
+    {
+        loggers_[new_default_logger->name()] = new_default_logger;
+    }
+    default_logger_ = std::move(new_default_logger);
+}
+
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    tp_ = std::move(tp);
+}
+
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    return tp_;
+}
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    formatter_ = std::move(formatter);
+    for (auto &l : loggers_)
+    {
+        l.second->set_formatter(formatter_->clone());
+    }
+}
+
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = n_messages;
+
+    for (auto &l : loggers_)
+    {
+        l.second->enable_backtrace(n_messages);
+    }
+}
+
+SPDLOG_INLINE void registry::disable_backtrace()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = 0;
+    for (auto &l : loggers_)
+    {
+        l.second->disable_backtrace();
+    }
+}
+
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_level(log_level);
+    }
+    global_log_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush_on(log_level);
+    }
+    flush_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
+{
+    std::lock_guard<std::mutex> lock(flusher_mutex_);
+    auto clbk = [this]() { this->flush_all(); };
+    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+}
+
+SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_error_handler(handler);
+    }
+    err_handler_ = std::move(handler);
+}
+
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        fun(l.second);
+    }
+}
+
+SPDLOG_INLINE void registry::flush_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush();
+    }
+}
+
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.erase(logger_name);
+    if (default_logger_ && default_logger_->name() == logger_name)
+    {
+        default_logger_.reset();
+    }
+}
+
+SPDLOG_INLINE void registry::drop_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.clear();
+    default_logger_.reset();
+}
+
+// clean all resources and threads started by the registry
+SPDLOG_INLINE void registry::shutdown()
+{
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        periodic_flusher_.reset();
+    }
+
+    drop_all();
+
+    {
+        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        tp_.reset();
+    }
+}
+
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+    return tp_mutex_;
+}
+
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    automatic_registration_ = automatic_registration;
+}
+
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    log_levels_ = std::move(levels);
+    auto global_level_requested = global_level != nullptr;
+    global_log_level_ = global_level_requested ? *global_level : global_log_level_;
+
+    for (auto &logger : loggers_)
+    {
+        auto logger_entry = log_levels_.find(logger.first);
+        if (logger_entry != log_levels_.end())
+        {
+            logger.second->set_level(logger_entry->second);
+        }
+        else if (global_level_requested)
+        {
+            logger.second->set_level(*global_level);
+        }
+    }
+}
+
+SPDLOG_INLINE registry &registry::instance()
+{
+    static registry s_instance;
+    return s_instance;
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
+{
+    if (loggers_.find(logger_name) != loggers_.end())
+    {
+        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
+    }
+}
+
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
+{
+    auto logger_name = new_logger->name();
+    throw_if_exists_(logger_name);
+    loggers_[logger_name] = std::move(new_logger);
+}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/registry.h

@@ -1,214 +1,115 @@
-//
-// Copyright(c) 2015 Gabi Melman.
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
 
 #pragma once
 
-// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an already existing name will be ignored
+// Loggers registry of unique name->logger pointer
+// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
 // If user requests a non existing logger, nullptr will be returned
 // This class is thread safe
 
-#include "spdlog/common.h"
-#include "spdlog/details/periodic_worker.h"
-#include "spdlog/logger.h"
+#include <spdlog/common.h>
 
 #include <chrono>
 #include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <mutex>
 
 namespace spdlog {
+class logger;
+
 namespace details {
 class thread_pool;
+class periodic_worker;
 
-class registry
+class SPDLOG_API registry
 {
 public:
+    using log_levels = std::unordered_map<std::string, level::level_enum>;
     registry(const registry &) = delete;
     registry &operator=(const registry &) = delete;
 
-    void register_logger(std::shared_ptr<logger> new_logger)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        auto logger_name = new_logger->name();
-        throw_if_exists_(logger_name);
-        loggers_[logger_name] = std::move(new_logger);
-    }
+    void register_logger(std::shared_ptr<logger> new_logger);
+    void initialize_logger(std::shared_ptr<logger> new_logger);
+    std::shared_ptr<logger> get(const std::string &logger_name);
+    std::shared_ptr<logger> default_logger();
 
-    void register_and_init(std::shared_ptr<logger> new_logger)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        auto logger_name = new_logger->name();
-        throw_if_exists_(logger_name);
+    // Return raw ptr to the default logger.
+    // To be used directly by the spdlog default api (e.g. spdlog::info)
+    // This make the default API faster, but cannot be used concurrently with set_default_logger().
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+    logger *get_default_raw();
 
-        // set the global formatter pattern
-        new_logger->set_formatter(formatter_->clone());
+    // set default logger.
+    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+    void set_default_logger(std::shared_ptr<logger> new_default_logger);
 
-        if (err_handler_)
-        {
-            new_logger->set_error_handler(err_handler_);
-        }
+    void set_tp(std::shared_ptr<thread_pool> tp);
 
-        new_logger->set_level(level_);
-        new_logger->flush_on(flush_level_);
-
-        // add to registry
-        loggers_[logger_name] = std::move(new_logger);
-    }
-
-    std::shared_ptr<logger> get(const std::string &logger_name)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        auto found = loggers_.find(logger_name);
-        return found == loggers_.end() ? nullptr : found->second;
-    }
-
-    void set_tp(std::shared_ptr<thread_pool> tp)
-    {
-        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
-        tp_ = std::move(tp);
-    }
-
-    std::shared_ptr<thread_pool> get_tp()
-    {
-        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
-        return tp_;
-    }
+    std::shared_ptr<thread_pool> get_tp();
 
     // Set global formatter. Each sink in each logger will get a clone of this object
-    void set_formatter(std::unique_ptr<formatter> formatter)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        formatter_ = std::move(formatter);
-        for (auto &l : loggers_)
-        {
-            l.second->set_formatter(formatter_->clone());
-        }
-    }
+    void set_formatter(std::unique_ptr<formatter> formatter);
 
-    void set_level(level::level_enum log_level)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
-        {
-            l.second->set_level(log_level);
-        }
-        level_ = log_level;
-    }
+    void enable_backtrace(size_t n_messages);
 
-    void flush_on(level::level_enum log_level)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
-        {
-            l.second->flush_on(log_level);
-        }
-        flush_level_ = log_level;
-    }
+    void disable_backtrace();
 
-    void flush_every(std::chrono::seconds interval)
-    {
-        std::lock_guard<std::mutex> lock(flusher_mutex_);
-        std::function<void()> clbk = std::bind(&registry::flush_all, this);
-        periodic_flusher_.reset(new periodic_worker(clbk, interval));
-    }
+    void set_level(level::level_enum log_level);
 
-    void set_error_handler(log_err_handler handler)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
-        {
-            l.second->set_error_handler(handler);
-        }
-        err_handler_ = handler;
-    }
+    void flush_on(level::level_enum log_level);
 
-    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
-        {
-            fun(l.second);
-        }
-    }
+    void flush_every(std::chrono::seconds interval);
 
-    void flush_all()
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
-        {
-            l.second->flush();
-        }
-    }
+    void set_error_handler(err_handler handler);
 
-    void drop(const std::string &logger_name)
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        loggers_.erase(logger_name);
-    }
+    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
 
-    void drop_all()
-    {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        loggers_.clear();
-    }
+    void flush_all();
 
-    // clean all reasources and threads started by the registry
-    void shutdown()
-    {
-        {
-            std::lock_guard<std::mutex> lock(flusher_mutex_);
-            periodic_flusher_.reset();
-        }
+    void drop(const std::string &logger_name);
 
-        drop_all();
+    void drop_all();
 
-        {
-            std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
-            tp_.reset();
-        }
-    }
+    // clean all resources and threads started by the registry
+    void shutdown();
 
-    std::recursive_mutex &tp_mutex()
-    {
-        return tp_mutex_;
-    }
+    std::recursive_mutex &tp_mutex();
 
-    static registry &instance()
-    {
-        static registry s_instance;
-        return s_instance;
-    }
+    void set_automatic_registration(bool automatic_registration);
+
+    // set levels for all existing/future loggers. global_level can be null if should not set.
+    void set_levels(log_levels levels, level::level_enum *global_level);
+
+    static registry &instance();
 
 private:
-    registry()
-        : formatter_(new pattern_formatter("%+"))
-    {
-    }
-
-    ~registry() = default;
-
-    void throw_if_exists_(const std::string &logger_name)
-    {
-        if (loggers_.find(logger_name) != loggers_.end())
-        {
-            throw spdlog_ex("logger with name '" + logger_name + "' already exists");
-        }
-    }
+    registry();
+    ~registry();
 
+    void throw_if_exists_(const std::string &logger_name);
+    void register_logger_(std::shared_ptr<logger> new_logger);
+    bool set_level_from_cfg_(logger *logger);
     std::mutex logger_map_mutex_, flusher_mutex_;
     std::recursive_mutex tp_mutex_;
     std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
+    log_levels log_levels_;
     std::unique_ptr<formatter> formatter_;
-    level::level_enum level_ = level::info;
+    spdlog::level::level_enum global_log_level_ = level::info;
     level::level_enum flush_level_ = level::off;
-    log_err_handler err_handler_;
+    err_handler err_handler_;
     std::shared_ptr<thread_pool> tp_;
     std::unique_ptr<periodic_worker> periodic_flusher_;
+    std::shared_ptr<logger> default_logger_;
+    bool automatic_registration_ = true;
+    size_t backtrace_n_messages_ = 0;
 };
 
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "registry-inl.h"
+#endif

include/spdlog/details/synchronous_factory.h

@@ -0,0 +1,24 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "registry.h"
+
+namespace spdlog {
+
+// Default logger factory-  creates synchronous loggers
+class logger;
+
+struct synchronous_factory
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
+    {
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
+        details::registry::instance().initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+} // namespace spdlog

include/spdlog/details/tcp_client-windows.h

@@ -0,0 +1,175 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <winsock2.h>
+#include <windows.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    SOCKET socket_ = INVALID_SOCKET;
+
+    static bool winsock_initialized_()
+    {
+        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (s == INVALID_SOCKET)
+        {
+            return false;
+        }
+        else
+        {
+            closesocket(s);
+            return true;
+        }
+    }
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));
+    }
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != INVALID_SOCKET;
+    }
+
+    void close()
+    {
+        ::closesocket(socket_);
+        socket_ = INVALID_SOCKET;
+        WSACleanup();
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        // initialize winsock if needed
+        if (!winsock_initialized_())
+        {
+            init_winsock_();
+        }
+
+        if (is_connected())
+        {
+            close();
+        }
+        struct addrinfo hints
+        {};
+        ZeroMemory(&hints, sizeof(hints));
+
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        int last_error = 0;
+        if (rv != 0)
+        {
+            last_error = ::WSAGetLastError();
+            WSACleanup();
+            throw_winsock_error_("getaddrinfo failed", last_error);
+        }
+
+        // Try each address until we successfully connect(2).
+
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+            socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+            if (socket_ == INVALID_SOCKET)
+            {
+                last_error = ::WSAGetLastError();
+                WSACleanup();
+                continue;
+            }
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            {
+                break;
+            }
+            else
+            {
+                last_error = ::WSAGetLastError();
+                close();
+            }
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == INVALID_SOCKET)
+        {
+            WSACleanup();
+            throw_winsock_error_("connect failed", last_error);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+            const int send_flags = 0;
+            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR)
+            {
+                int last_error = ::WSAGetLastError();
+                close();
+                throw_winsock_error_("send failed", last_error);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog

include/spdlog/details/tcp_client.h

@@ -0,0 +1,146 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+#    error include tcp_client-windows.h instead
+#endif
+
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/tcp.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    int socket_ = -1;
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != -1;
+    }
+
+    void close()
+    {
+        if (is_connected())
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        close();
+        struct addrinfo hints
+        {};
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        if (rv != 0)
+        {
+            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));
+            throw_spdlog_ex(msg);
+        }
+
+        // Try each address until we successfully connect(2).
+        int last_errno = 0;
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+#if defined(SOCK_CLOEXEC)
+            const int flags = SOCK_CLOEXEC;
+#else
+            const int flags = 0;
+#endif
+            socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
+            if (socket_ == -1)
+            {
+                last_errno = errno;
+                continue;
+            }
+            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
+            if (rv == 0)
+            {
+                break;
+            }
+            last_errno = errno;
+            ::close(socket_);
+            socket_ = -1;
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == -1)
+        {
+            throw_spdlog_ex("::connect failed", last_errno);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+
+        // prevent sigpipe on systems where MSG_NOSIGNAL is not available
+#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+#endif
+
+#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+#    error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+#endif
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+#if defined(MSG_NOSIGNAL)
+            const int send_flags = MSG_NOSIGNAL;
+#else
+            const int send_flags = 0;
+#endif
+            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0)
+            {
+                close();
+                throw_spdlog_ex("write(2) failed", errno);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog

include/spdlog/details/thread_pool-inl.h

@@ -0,0 +1,129 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#    include <spdlog/details/thread_pool.h>
+#endif
+
+#include <spdlog/common.h>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+    : q_(q_max_items)
+{
+    if (threads_n == 0 || threads_n > 1000)
+    {
+        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+                        "range is 1-1000)");
+    }
+    for (size_t i = 0; i < threads_n; i++)
+    {
+        threads_.emplace_back([this, on_thread_start] {
+            on_thread_start();
+            this->thread_pool::worker_loop_();
+        });
+    }
+}
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
+    : thread_pool(q_max_items, threads_n, [] {})
+{}
+
+// message all threads to terminate gracefully join them
+SPDLOG_INLINE thread_pool::~thread_pool()
+{
+    SPDLOG_TRY
+    {
+        for (size_t i = 0; i < threads_.size(); i++)
+        {
+            post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
+        }
+
+        for (auto &t : threads_)
+        {
+            t.join();
+        }
+    }
+    SPDLOG_CATCH_STD
+}
+
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
+{
+    async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
+    post_async_msg_(std::move(async_m), overflow_policy);
+}
+
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+{
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+}
+
+size_t SPDLOG_INLINE thread_pool::overrun_counter()
+{
+    return q_.overrun_counter();
+}
+
+size_t SPDLOG_INLINE thread_pool::queue_size()
+{
+    return q_.size();
+}
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+{
+    if (overflow_policy == async_overflow_policy::block)
+    {
+        q_.enqueue(std::move(new_msg));
+    }
+    else
+    {
+        q_.enqueue_nowait(std::move(new_msg));
+    }
+}
+
+void SPDLOG_INLINE thread_pool::worker_loop_()
+{
+    while (process_next_msg_()) {}
+}
+
+// process next message in the queue
+// return true if this thread should still be active (while no terminate msg
+// was received)
+bool SPDLOG_INLINE thread_pool::process_next_msg_()
+{
+    async_msg incoming_async_msg;
+    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+    if (!dequeued)
+    {
+        return true;
+    }
+
+    switch (incoming_async_msg.msg_type)
+    {
+    case async_msg_type::log: {
+        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+        return true;
+    }
+    case async_msg_type::flush: {
+        incoming_async_msg.worker_ptr->backend_flush_();
+        return true;
+    }
+
+    case async_msg_type::terminate: {
+        return false;
+    }
+
+    default: {
+        assert(false);
+    }
+    }
+
+    return true;
+}
+
+} // namespace details
+} // namespace spdlog

include/spdlog/details/thread_pool.h

@@ -1,15 +1,21 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
 #pragma once
 
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/mpmc_blocking_q.h"
-#include "spdlog/details/os.h"
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/mpmc_blocking_q.h>
+#include <spdlog/details/os.h>
 
 #include <chrono>
 #include <memory>
 #include <thread>
 #include <vector>
+#include <functional>
 
 namespace spdlog {
+class async_logger;
+
 namespace details {
 
 using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
@@ -21,17 +27,12 @@ enum class async_msg_type
     terminate
 };
 
+#include <spdlog/details/log_msg_buffer.h>
 // Async msg to move to/from the queue
 // Movable only. should never be copied
-struct async_msg
+struct async_msg : log_msg_buffer
 {
-    async_msg_type msg_type;
-    level::level_enum level;
-    log_clock::time_point time;
-    size_t thread_id;
-    fmt::basic_memory_buffer<char, 176> raw;
-
-    size_t msg_id;
+    async_msg_type msg_type{async_msg_type::log};
     async_logger_ptr worker_ptr;
 
     async_msg() = default;
@@ -42,184 +43,79 @@ struct async_msg
 
 // support for vs2013 move
 #if defined(_MSC_VER) && _MSC_VER <= 1800
-    async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type),
-                                                   level(other.level),
-                                                   time(other.time),
-                                                   thread_id(other.thread_id),
-                                                   raw(move(other.raw)),
-                                                   msg_id(other.msg_id),
-                                                   worker_ptr(std::move(other.worker_ptr))
-    {
-    }
+    async_msg(async_msg &&other)
+        : log_msg_buffer(std::move(other))
+        , msg_type(other.msg_type)
+        , worker_ptr(std::move(other.worker_ptr))
+    {}
 
-    async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT
+    async_msg &operator=(async_msg &&other)
     {
+        *static_cast<log_msg_buffer *>(this) = std::move(other);
         msg_type = other.msg_type;
-        level = other.level;
-        time = other.time;
-        thread_id = other.thread_id;
-        raw = std::move(other.raw);
-        msg_id = other.msg_id;
         worker_ptr = std::move(other.worker_ptr);
         return *this;
     }
 #else // (_MSC_VER) && _MSC_VER <= 1800
-    async_msg(async_msg &&other) = default;
-    async_msg &operator=(async_msg &&other) = default;
+    async_msg(async_msg &&) = default;
+    async_msg &operator=(async_msg &&) = default;
 #endif
 
     // construct from log_msg with given type
-    async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &&m)
-        : msg_type(the_type)
-        , level(m.level)
-        , time(m.time)
-        , thread_id(m.thread_id)
-        , msg_id(m.msg_id)
-        , worker_ptr(std::forward<async_logger_ptr>(worker))
-    {
-        fmt_helper::append_buf(m.raw, raw);
-    }
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
+        : log_msg_buffer{m}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
 
     async_msg(async_logger_ptr &&worker, async_msg_type the_type)
-        : async_msg(std::forward<async_logger_ptr>(worker), the_type, details::log_msg())
-    {
-    }
+        : log_msg_buffer{}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
 
     explicit async_msg(async_msg_type the_type)
-        : async_msg(nullptr, the_type, details::log_msg())
-    {
-    }
-
-    // copy into log_msg
-    void to_log_msg(log_msg &msg)
-    {
-        msg.logger_name = &worker_ptr->name();
-        msg.level = level;
-        msg.time = time;
-        msg.thread_id = thread_id;
-        fmt_helper::append_buf(raw, msg.raw);
-        msg.msg_id = msg_id;
-        msg.color_range_start = 0;
-        msg.color_range_end = 0;
-    }
+        : async_msg{nullptr, the_type}
+    {}
 };
 
-class thread_pool
+class SPDLOG_API thread_pool
 {
 public:
     using item_type = async_msg;
     using q_type = details::mpmc_blocking_queue<item_type>;
 
-    thread_pool(size_t q_max_items, size_t threads_n)
-        : q_(q_max_items)
-    {
-        // std::cout << "thread_pool()  q_size_bytes: " << q_size_bytes <<
-        // "\tthreads_n: " << threads_n << std::endl;
-        if (threads_n == 0 || threads_n > 1000)
-        {
-            throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
-                            "range is 1-1000)");
-        }
-        for (size_t i = 0; i < threads_n; i++)
-        {
-            threads_.emplace_back(&thread_pool::worker_loop_, this);
-        }
-    }
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
+    thread_pool(size_t q_max_items, size_t threads_n);
 
     // message all threads to terminate gracefully join them
-    ~thread_pool()
-    {
-        try
-        {
-            for (size_t i = 0; i < threads_.size(); i++)
-            {
-                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
-            }
+    ~thread_pool();
 
-            for (auto &t : threads_)
-            {
-                t.join();
-            }
-        }
-        catch (...)
-        {
-        }
-    }
+    thread_pool(const thread_pool &) = delete;
+    thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy)
-    {
-        async_msg async_m(std::forward<async_logger_ptr>(worker_ptr), async_msg_type::log, std::forward<log_msg>(msg));
-        post_async_msg_(std::move(async_m), overflow_policy);
-    }
-
-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
-    {
-        post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
-    }
-
-    size_t overrun_counter()
-    {
-        return q_.overrun_counter();
-    }
+    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    size_t overrun_counter();
+    size_t queue_size();
 
 private:
     q_type q_;
 
     std::vector<std::thread> threads_;
 
-    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
-    {
-        if (overflow_policy == async_overflow_policy::block)
-        {
-            q_.enqueue(std::move(new_msg));
-        }
-        else
-        {
-            q_.enqueue_nowait(std::move(new_msg));
-        }
-    }
-
-    void worker_loop_()
-    {
-        while (process_next_msg_()) {};
-    }
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
+    void worker_loop_();
 
     // process next message in the queue
     // return true if this thread should still be active (while no terminate msg
     // was received)
-    bool process_next_msg_()
-    {
-        async_msg incoming_async_msg;
-        bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
-        if (!dequeued)
-        {
-            return true;
-        }
-
-        switch (incoming_async_msg.msg_type)
-        {
-        case async_msg_type::flush:
-        {
-            incoming_async_msg.worker_ptr->backend_flush_();
-            return true;
-        }
-
-        case async_msg_type::terminate:
-        {
-            return false;
-        }
-
-        default:
-        {
-            log_msg msg;
-            incoming_async_msg.to_log_msg(msg);
-            incoming_async_msg.worker_ptr->backend_log_(msg);
-            return true;
-        }
-        }
-        return true; // should not be reached
-    }
+    bool process_next_msg_();
 };
 
 } // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#    include "thread_pool-inl.h"
+#endif

include/spdlog/details/windows_include.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef NOMINMAX
+#    define NOMINMAX // prevent windows redefining min/max
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>

include/spdlog/fmt/bin_to_hex.h

@@ -0,0 +1,216 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <cctype>
+
+//
+// Support for logging binary data as hex
+// format flags, any combination of the followng:
+// {:X} - print in uppercase.
+// {:s} - don't separate each byte with space.
+// {:p} - don't print the position on each line start.
+// {:n} - don't split the output to lines.
+// {:a} - show ASCII if :n is not set
+
+//
+// Examples:
+//
+// std::vector<char> v(200, 0x0b);
+// logger->info("Some buffer {}", spdlog::to_hex(v));
+// char buf[128];
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16));
+
+namespace spdlog {
+namespace details {
+
+template<typename It>
+class dump_info
+{
+public:
+    dump_info(It range_begin, It range_end, size_t size_per_line)
+        : begin_(range_begin)
+        , end_(range_end)
+        , size_per_line_(size_per_line)
+    {}
+
+    It begin() const
+    {
+        return begin_;
+    }
+    It end() const
+    {
+        return end_;
+    }
+    size_t size_per_line() const
+    {
+        return size_per_line_;
+    }
+
+private:
+    It begin_, end_;
+    size_t size_per_line_;
+};
+} // namespace details
+
+// create a dump_info that wraps the given container
+template<typename Container>
+inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32)
+{
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+    using Iter = typename Container::const_iterator;
+    return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
+}
+
+// create dump_info from ranges
+template<typename It>
+inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
+{
+    return details::dump_info<It>(range_begin, range_end, size_per_line);
+}
+
+} // namespace spdlog
+
+namespace fmt {
+
+template<typename T>
+struct formatter<spdlog::details::dump_info<T>>
+{
+    const char delimiter = ' ';
+    bool put_newlines = true;
+    bool put_delimiters = true;
+    bool use_uppercase = false;
+    bool put_positions = true; // position on start of each line
+    bool show_ascii = false;
+
+    // parse the format string flags
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = ctx.begin();
+        while (it != ctx.end() && *it != '}')
+        {
+            switch (*it)
+            {
+            case 'X':
+                use_uppercase = true;
+                break;
+            case 's':
+                put_delimiters = false;
+                break;
+            case 'p':
+                put_positions = false;
+                break;
+            case 'n':
+                put_newlines = false;
+                show_ascii = false;
+                break;
+            case 'a':
+                if (put_newlines)
+                {
+                    show_ascii = true;
+                }
+                break;
+            }
+
+            ++it;
+        }
+        return it;
+    }
+
+    // format the given bytes range as hex
+    template<typename FormatContext, typename Container>
+    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
+        SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
+        const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
+
+#if FMT_VERSION < 60000
+        auto inserter = ctx.begin();
+#else
+        auto inserter = ctx.out();
+#endif
+
+        int size_per_line = static_cast<int>(the_range.size_per_line());
+        auto start_of_line = the_range.begin();
+        for (auto i = the_range.begin(); i != the_range.end(); i++)
+        {
+            auto ch = static_cast<unsigned char>(*i);
+
+            if (put_newlines && (i == the_range.begin() || i - start_of_line >= size_per_line))
+            {
+                if (show_ascii && i != the_range.begin())
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    for (auto j = start_of_line; j < i; j++)
+                    {
+                        auto pc = static_cast<unsigned char>(*j);
+                        *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+                    }
+                }
+
+                put_newline(inserter, static_cast<size_t>(i - the_range.begin()));
+
+                // put first byte without delimiter in front of it
+                *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+                *inserter++ = hex_chars[ch & 0x0f];
+                start_of_line = i;
+                continue;
+            }
+
+            if (put_delimiters)
+            {
+                *inserter++ = delimiter;
+            }
+
+            *inserter++ = hex_chars[(ch >> 4) & 0x0f];
+            *inserter++ = hex_chars[ch & 0x0f];
+        }
+        if (show_ascii) // add ascii to last line
+        {
+            if (the_range.end() - the_range.begin() > size_per_line)
+            {
+                auto blank_num = size_per_line - (the_range.end() - start_of_line);
+                while (blank_num-- > 0)
+                {
+                    *inserter++ = delimiter;
+                    *inserter++ = delimiter;
+                    if (put_delimiters)
+                    {
+                        *inserter++ = delimiter;
+                    }
+                }
+            }
+            *inserter++ = delimiter;
+            *inserter++ = delimiter;
+            for (auto j = start_of_line; j != the_range.end(); j++)
+            {
+                auto pc = static_cast<unsigned char>(*j);
+                *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
+            }
+        }
+        return inserter;
+    }
+
+    // put newline(and position header)
+    template<typename It>
+    void put_newline(It inserter, std::size_t pos)
+    {
+#ifdef _WIN32
+        *inserter++ = '\r';
+#endif
+        *inserter++ = '\n';
+
+        if (put_positions)
+        {
+            fmt::format_to(inserter, "{:04X}: ", pos);
+        }
+    }
+};
+} // namespace fmt

include/spdlog/fmt/bundled/LICENSE.rst

@@ -1,23 +0,0 @@
-Copyright (c) 2012 - 2016, Victor Zverovich
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

include/spdlog/fmt/bundled/args.h

@@ -0,0 +1,232 @@
+// Formatting library for C++ - dynamic format arguments
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> const T& unwrap(const T& v) { return v; }
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> const T& push(const Arg& arg) {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<detail::is_string<T>::value &&
+                                        !has_formatter<T, Context>::value &&
+                                        !detail::is_reference_wrapper<T>::value,
+                                    std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  unsigned long long get_types() const {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  const basic_format_arg<Context>* data() const {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /** Erase all elements from the store */
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "Set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_

include/spdlog/fmt/bundled/color.h

@@ -0,0 +1,627 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+// __declspec(deprecated) is broken in some MSVC versions.
+#if FMT_MSC_VER
+#  define FMT_DEPRECATED_NONMSVC
+#else
+#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
+#endif
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  italic = 1 << 1,
+  underline = 1 << 2,
+  strikethrough = 1 << 3
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
+                                                           value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
+                                                                     value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems(em) {}
+
+  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs |= rhs;
+  }
+
+  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
+      const text_style& rhs) {
+    return and_assign(rhs);
+  }
+
+  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
+  operator&(text_style lhs, const text_style& rhs) {
+    return lhs.and_assign(rhs);
+  }
+
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           detail::color_type text_color) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  // DEPRECATED!
+  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
+      FMT_NOEXCEPT;
+
+  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
+      FMT_NOEXCEPT;
+
+  detail::color_type foreground_color;
+  detail::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+  return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
+  return text_style(false, background);
+}
+
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
+                                          emphasis rhs) FMT_NOEXCEPT {
+  return text_style(lhs) | rhs;
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
+                                  const char* esc) FMT_NOEXCEPT {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (!text_color.is_rgb) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value.term_color;
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value.rgb_color);
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+    uint8_t em_codes[4] = {};
+    uint8_t em_bits = static_cast<uint8_t>(em);
+    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
+    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
+    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
+    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+      em_codes[3] = 9;
+
+    size_t index = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+
+  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ private:
+  Char buffer[7u + 3u * 4u + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) FMT_NOEXCEPT {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    detail::color_type foreground) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+    detail::color_type background) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char>
+inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputs(chars, stream);
+}
+
+template <>
+inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputws(chars, stream);
+}
+
+template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+  fputs(L"\x1b[0m", stream);
+}
+
+template <typename Char>
+inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
+  auto reset_color = string_view("\x1b[0m");
+  buffer.append(reset_color.begin(), reset_color.end());
+}
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background = detail::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
+}
+
+FMT_END_DETAIL_NAMESPACE
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE* f, const text_style& ts, const S& format,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  detail::fputs(buf.data(), f);
+}
+
+/**
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+/**
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
+  return fmt::vformat(ts, to_string_view(format_str),
+                      fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+OutputIt vformat_to(
+    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf);
+}
+
+/**
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template <typename OutputIt, typename S, typename... Args,
+          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
+              detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, to_string_view(format_str),
+                    fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_

include/spdlog/fmt/bundled/colors.h

@@ -1,257 +0,0 @@
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for rgb color output.
-
-#ifndef FMT_COLORS_H_
-#define FMT_COLORS_H_
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-// rgb is a struct for red, green and blue colors.
-// We use rgb as name because some editors will show it as color direct in the
-// editor.
-struct rgb
-{
-    FMT_CONSTEXPR_DECL rgb()
-        : r(0)
-        , g(0)
-        , b(0)
-    {
-    }
-    FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
-        : r(r_)
-        , g(g_)
-        , b(b_)
-    {
-    }
-    FMT_CONSTEXPR_DECL rgb(uint32_t hex)
-        : r((hex >> 16) & 0xFF)
-        , g((hex >> 8) & 0xFF)
-        , b((hex)&0xFF)
-    {
-    }
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-};
-
-namespace internal {
-
-FMT_CONSTEXPR inline void to_esc(uint8_t c, char out[], int offset)
-{
-    out[offset + 0] = static_cast<char>('0' + c / 100);
-    out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
-    out[offset + 2] = static_cast<char>('0' + c % 10);
-}
-
-} // namespace internal
-
-FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args)
-{
-    char escape_fd[] = "\x1b[38;2;000;000;000m";
-    static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m";
-    internal::to_esc(fd.r, escape_fd, 7);
-    internal::to_esc(fd.g, escape_fd, 11);
-    internal::to_esc(fd.b, escape_fd, 15);
-
-    std::fputs(escape_fd, stdout);
-    vprint(format, args);
-    std::fputs(RESET_COLOR, stdout);
-}
-
-FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args)
-{
-    char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
-    char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
-    static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m";
-    internal::to_esc(fd.r, escape_fd, 7);
-    internal::to_esc(fd.g, escape_fd, 11);
-    internal::to_esc(fd.b, escape_fd, 15);
-
-    internal::to_esc(bg.r, escape_bg, 7);
-    internal::to_esc(bg.g, escape_bg, 11);
-    internal::to_esc(bg.b, escape_bg, 15);
-
-    std::fputs(escape_fd, stdout);
-    std::fputs(escape_bg, stdout);
-    vprint(format, args);
-    std::fputs(RESET_COLOR, stdout);
-}
-
-template<typename... Args>
-inline void print_rgb(rgb fd, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, format_str, make_format_args(args...));
-}
-
-// rgb foreground color
-template<typename... Args>
-inline void print(rgb fd, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, format_str, make_format_args(args...));
-}
-
-// rgb foreground color and background color
-template<typename... Args>
-inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, bg, format_str, make_format_args(args...));
-}
-
-enum class color : uint32_t
-{
-    alice_blue = 0xF0F8FF,              // rgb(240,248,255)
-    antique_white = 0xFAEBD7,           // rgb(250,235,215)
-    aqua = 0x00FFFF,                    // rgb(0,255,255)
-    aquamarine = 0x7FFFD4,              // rgb(127,255,212)
-    azure = 0xF0FFFF,                   // rgb(240,255,255)
-    beige = 0xF5F5DC,                   // rgb(245,245,220)
-    bisque = 0xFFE4C4,                  // rgb(255,228,196)
-    black = 0x000000,                   // rgb(0,0,0)
-    blanched_almond = 0xFFEBCD,         // rgb(255,235,205)
-    blue = 0x0000FF,                    // rgb(0,0,255)
-    blue_violet = 0x8A2BE2,             // rgb(138,43,226)
-    brown = 0xA52A2A,                   // rgb(165,42,42)
-    burly_wood = 0xDEB887,              // rgb(222,184,135)
-    cadet_blue = 0x5F9EA0,              // rgb(95,158,160)
-    chartreuse = 0x7FFF00,              // rgb(127,255,0)
-    chocolate = 0xD2691E,               // rgb(210,105,30)
-    coral = 0xFF7F50,                   // rgb(255,127,80)
-    cornflower_blue = 0x6495ED,         // rgb(100,149,237)
-    cornsilk = 0xFFF8DC,                // rgb(255,248,220)
-    crimson = 0xDC143C,                 // rgb(220,20,60)
-    cyan = 0x00FFFF,                    // rgb(0,255,255)
-    dark_blue = 0x00008B,               // rgb(0,0,139)
-    dark_cyan = 0x008B8B,               // rgb(0,139,139)
-    dark_golden_rod = 0xB8860B,         // rgb(184,134,11)
-    dark_gray = 0xA9A9A9,               // rgb(169,169,169)
-    dark_green = 0x006400,              // rgb(0,100,0)
-    dark_khaki = 0xBDB76B,              // rgb(189,183,107)
-    dark_magenta = 0x8B008B,            // rgb(139,0,139)
-    dark_olive_green = 0x556B2F,        // rgb(85,107,47)
-    dark_orange = 0xFF8C00,             // rgb(255,140,0)
-    dark_orchid = 0x9932CC,             // rgb(153,50,204)
-    dark_red = 0x8B0000,                // rgb(139,0,0)
-    dark_salmon = 0xE9967A,             // rgb(233,150,122)
-    dark_sea_green = 0x8FBC8F,          // rgb(143,188,143)
-    dark_slate_blue = 0x483D8B,         // rgb(72,61,139)
-    dark_slate_gray = 0x2F4F4F,         // rgb(47,79,79)
-    dark_turquoise = 0x00CED1,          // rgb(0,206,209)
-    dark_violet = 0x9400D3,             // rgb(148,0,211)
-    deep_pink = 0xFF1493,               // rgb(255,20,147)
-    deep_sky_blue = 0x00BFFF,           // rgb(0,191,255)
-    dim_gray = 0x696969,                // rgb(105,105,105)
-    dodger_blue = 0x1E90FF,             // rgb(30,144,255)
-    fire_brick = 0xB22222,              // rgb(178,34,34)
-    floral_white = 0xFFFAF0,            // rgb(255,250,240)
-    forest_green = 0x228B22,            // rgb(34,139,34)
-    fuchsia = 0xFF00FF,                 // rgb(255,0,255)
-    gainsboro = 0xDCDCDC,               // rgb(220,220,220)
-    ghost_white = 0xF8F8FF,             // rgb(248,248,255)
-    gold = 0xFFD700,                    // rgb(255,215,0)
-    golden_rod = 0xDAA520,              // rgb(218,165,32)
-    gray = 0x808080,                    // rgb(128,128,128)
-    green = 0x008000,                   // rgb(0,128,0)
-    green_yellow = 0xADFF2F,            // rgb(173,255,47)
-    honey_dew = 0xF0FFF0,               // rgb(240,255,240)
-    hot_pink = 0xFF69B4,                // rgb(255,105,180)
-    indian_red = 0xCD5C5C,              // rgb(205,92,92)
-    indigo = 0x4B0082,                  // rgb(75,0,130)
-    ivory = 0xFFFFF0,                   // rgb(255,255,240)
-    khaki = 0xF0E68C,                   // rgb(240,230,140)
-    lavender = 0xE6E6FA,                // rgb(230,230,250)
-    lavender_blush = 0xFFF0F5,          // rgb(255,240,245)
-    lawn_green = 0x7CFC00,              // rgb(124,252,0)
-    lemon_chiffon = 0xFFFACD,           // rgb(255,250,205)
-    light_blue = 0xADD8E6,              // rgb(173,216,230)
-    light_coral = 0xF08080,             // rgb(240,128,128)
-    light_cyan = 0xE0FFFF,              // rgb(224,255,255)
-    light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
-    light_gray = 0xD3D3D3,              // rgb(211,211,211)
-    light_green = 0x90EE90,             // rgb(144,238,144)
-    light_pink = 0xFFB6C1,              // rgb(255,182,193)
-    light_salmon = 0xFFA07A,            // rgb(255,160,122)
-    light_sea_green = 0x20B2AA,         // rgb(32,178,170)
-    light_sky_blue = 0x87CEFA,          // rgb(135,206,250)
-    light_slate_gray = 0x778899,        // rgb(119,136,153)
-    light_steel_blue = 0xB0C4DE,        // rgb(176,196,222)
-    light_yellow = 0xFFFFE0,            // rgb(255,255,224)
-    lime = 0x00FF00,                    // rgb(0,255,0)
-    lime_green = 0x32CD32,              // rgb(50,205,50)
-    linen = 0xFAF0E6,                   // rgb(250,240,230)
-    magenta = 0xFF00FF,                 // rgb(255,0,255)
-    maroon = 0x800000,                  // rgb(128,0,0)
-    medium_aqua_marine = 0x66CDAA,      // rgb(102,205,170)
-    medium_blue = 0x0000CD,             // rgb(0,0,205)
-    medium_orchid = 0xBA55D3,           // rgb(186,85,211)
-    medium_purple = 0x9370DB,           // rgb(147,112,219)
-    medium_sea_green = 0x3CB371,        // rgb(60,179,113)
-    medium_slate_blue = 0x7B68EE,       // rgb(123,104,238)
-    medium_spring_green = 0x00FA9A,     // rgb(0,250,154)
-    medium_turquoise = 0x48D1CC,        // rgb(72,209,204)
-    medium_violet_red = 0xC71585,       // rgb(199,21,133)
-    midnight_blue = 0x191970,           // rgb(25,25,112)
-    mint_cream = 0xF5FFFA,              // rgb(245,255,250)
-    misty_rose = 0xFFE4E1,              // rgb(255,228,225)
-    moccasin = 0xFFE4B5,                // rgb(255,228,181)
-    navajo_white = 0xFFDEAD,            // rgb(255,222,173)
-    navy = 0x000080,                    // rgb(0,0,128)
-    old_lace = 0xFDF5E6,                // rgb(253,245,230)
-    olive = 0x808000,                   // rgb(128,128,0)
-    olive_drab = 0x6B8E23,              // rgb(107,142,35)
-    orange = 0xFFA500,                  // rgb(255,165,0)
-    orange_red = 0xFF4500,              // rgb(255,69,0)
-    orchid = 0xDA70D6,                  // rgb(218,112,214)
-    pale_golden_rod = 0xEEE8AA,         // rgb(238,232,170)
-    pale_green = 0x98FB98,              // rgb(152,251,152)
-    pale_turquoise = 0xAFEEEE,          // rgb(175,238,238)
-    pale_violet_red = 0xDB7093,         // rgb(219,112,147)
-    papaya_whip = 0xFFEFD5,             // rgb(255,239,213)
-    peach_puff = 0xFFDAB9,              // rgb(255,218,185)
-    peru = 0xCD853F,                    // rgb(205,133,63)
-    pink = 0xFFC0CB,                    // rgb(255,192,203)
-    plum = 0xDDA0DD,                    // rgb(221,160,221)
-    powder_blue = 0xB0E0E6,             // rgb(176,224,230)
-    purple = 0x800080,                  // rgb(128,0,128)
-    rebecca_purple = 0x663399,          // rgb(102,51,153)
-    red = 0xFF0000,                     // rgb(255,0,0)
-    rosy_brown = 0xBC8F8F,              // rgb(188,143,143)
-    royal_blue = 0x4169E1,              // rgb(65,105,225)
-    saddle_brown = 0x8B4513,            // rgb(139,69,19)
-    salmon = 0xFA8072,                  // rgb(250,128,114)
-    sandy_brown = 0xF4A460,             // rgb(244,164,96)
-    sea_green = 0x2E8B57,               // rgb(46,139,87)
-    sea_shell = 0xFFF5EE,               // rgb(255,245,238)
-    sienna = 0xA0522D,                  // rgb(160,82,45)
-    silver = 0xC0C0C0,                  // rgb(192,192,192)
-    sky_blue = 0x87CEEB,                // rgb(135,206,235)
-    slate_blue = 0x6A5ACD,              // rgb(106,90,205)
-    slate_gray = 0x708090,              // rgb(112,128,144)
-    snow = 0xFFFAFA,                    // rgb(255,250,250)
-    spring_green = 0x00FF7F,            // rgb(0,255,127)
-    steel_blue = 0x4682B4,              // rgb(70,130,180)
-    tan = 0xD2B48C,                     // rgb(210,180,140)
-    teal = 0x008080,                    // rgb(0,128,128)
-    thistle = 0xD8BFD8,                 // rgb(216,191,216)
-    tomato = 0xFF6347,                  // rgb(255,99,71)
-    turquoise = 0x40E0D0,               // rgb(64,224,208)
-    violet = 0xEE82EE,                  // rgb(238,130,238)
-    wheat = 0xF5DEB3,                   // rgb(245,222,179)
-    white = 0xFFFFFF,                   // rgb(255,255,255)
-    white_smoke = 0xF5F5F5,             // rgb(245,245,245)
-    yellow = 0xFFFF00,                  // rgb(255,255,0)
-    yellow_green = 0x9ACD32,            // rgb(154,205,50)
-};                                      // enum class colors
-
-FMT_END_NAMESPACE
-
-#endif // FMT_COLORS_H_

include/spdlog/fmt/bundled/compile.h

@@ -0,0 +1,639 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+  size_t count_;
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+
+  struct value_type {
+    template <typename T> void operator=(const T&) {}
+  };
+
+  counting_iterator() : count_(0) {}
+
+  size_t count() const { return count_; }
+
+  counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
+  counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  friend counting_iterator operator+(counting_iterator it, difference_type n) {
+    it.count_ += static_cast<size_t>(n);
+    return it;
+  }
+
+  value_type operator*() const { return {}; }
+};
+
+template <typename Char, typename InputIt>
+inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                  counting_iterator it) {
+  return it + (end - begin);
+}
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  size_t limit_;
+  size_t count_ = 0;
+
+  truncating_iterator_base() : out_(), limit_(0) {}
+
+  truncating_iterator_base(OutputIt out, size_t limit)
+      : out_(out), limit_(limit) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type =
+      truncating_iterator_base;  // Mark iterator as checked.
+
+  OutputIt base() const { return out_; }
+  size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+/**
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
+ */
+#ifdef __cpp_if_constexpr
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
+template <typename T, typename... Tail>
+const T& first(const T& value, const Tail&...) {
+  return value;
+}
+
+#ifdef __cpp_if_constexpr
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get([[maybe_unused]] const T& first,
+                          [[maybe_unused]] const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return get<N - 1>(rest...);
+}
+
+template <typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name,
+                                    type_list<Args...>) {
+  return get_arg_index_by_name<Args...>(name);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, data);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char> struct code_unit {
+  Char value;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, value);
+  }
+};
+
+// This ensures that the argument type is convertible to `const T&`.
+template <typename T, int N, typename... Args>
+constexpr const T& get_arg_checked(const Args&... args) {
+  const auto& arg = get<N>(args...);
+  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
+    return arg.value;
+  } else {
+    return arg;
+  }
+}
+
+template <typename Char>
+struct is_compiled_format<code_unit<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    return write<Char>(out, get_arg_checked<T, N>(args...));
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+// A replacement field that refers to argument with name.
+template <typename Char> struct runtime_named_field {
+  using char_type = Char;
+  basic_string_view<Char> name;
+
+  template <typename OutputIt, typename T>
+  constexpr static bool try_format_argument(
+      OutputIt& out,
+      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
+    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
+      if (arg_name == arg.name) {
+        out = write<Char>(out, arg.value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    bool found = (try_format_argument(out, name, args) || ...);
+    if (!found) {
+      throw format_error("argument with specified name is not found");
+    }
+    return out;
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N and has format specifiers.
+template <typename Char, typename T, int N> struct spec_field {
+  using char_type = Char;
+  formatter<T, Char> fmt;
+
+  template <typename OutputIt, typename... Args>
+  constexpr FMT_INLINE OutputIt format(OutputIt out,
+                                       const Args&... args) const {
+    const auto& vargs =
+        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
+    basic_format_context<OutputIt, Char> ctx(out, vargs);
+    return fmt.format(get_arg_checked<T, N>(args...), ctx);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+template <typename T, typename Char> struct parse_specs_result {
+  formatter<T, Char> fmt;
+  size_t end;
+  int next_arg_id;
+};
+
+constexpr int manual_indexing_id = -1;
+
+template <typename T, typename Char>
+constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
+                                                  size_t pos, int next_arg_id) {
+  str.remove_prefix(pos);
+  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
+  auto f = formatter<T, Char>();
+  auto end = f.parse(ctx);
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template <typename Char> struct arg_id_handler {
+  arg_ref<Char> arg_id;
+
+  constexpr int operator()() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int operator()(int id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int operator()(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+
+  constexpr void on_error(const char* message) { throw format_error(message); }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  arg_ref<Char> arg_id;
+  const Char* arg_id_end;
+};
+
+template <int ID, typename Char>
+constexpr auto parse_arg_id(const Char* begin, const Char* end) {
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+}
+
+template <typename T, typename Enable = void> struct field_type {
+  using type = remove_cvref_t<T>;
+};
+
+template <typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
+          typename S>
+constexpr auto parse_replacement_field_then_tail(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+  if constexpr (c == '}') {
+    return parse_tail<Args, END_POS + 1, NEXT_ID>(
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
+  } else if constexpr (c == ':') {
+    constexpr auto result = parse_specs<typename field_type<T>::type>(
+        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+    return parse_tail<Args, result.end, result.next_arg_id>(
+        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+            result.fmt},
+        format_str);
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  if constexpr (str[POS] == '{') {
+    if constexpr (POS + 1 == str.size())
+      throw format_error("unmatched '{' in format string");
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
+      static_assert(ID != manual_indexing_id,
+                    "cannot switch from manual to automatic argument indexing");
+      constexpr auto next_id =
+          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
+                                               POS + 1, ID, next_id>(
+          format_str);
+    } else {
+      constexpr auto arg_id_result =
+          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+      constexpr char_type c =
+          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+      static_assert(c == '}' || c == ':', "missing '}' in format string");
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+        static_assert(
+            ID == manual_indexing_id || ID == 0,
+            "cannot switch from automatic to manual argument indexing");
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index != invalid_arg_index) {
+          constexpr auto next_id =
+              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+          return parse_replacement_field_then_tail<
+              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
+              arg_index, next_id>(format_str);
+        } else {
+          if constexpr (c == '}') {
+            return parse_tail<Args, arg_id_end_pos + 1, ID>(
+                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+                format_str);
+          } else if constexpr (c == ':') {
+            return unknown_format();  // no type info for specs parsing
+          }
+        }
+      }
+    }
+  } else if constexpr (str[POS] == '}') {
+    if constexpr (POS + 1 == str.size())
+      throw format_error("unmatched '}' in format string");
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    if constexpr (end - POS > 1) {
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                       format_str);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  if constexpr (str.size() == 0) {
+    return detail::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
+    return result;
+  }
+}
+#endif  // __cpp_if_constexpr
+}  // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+#ifdef __cpp_if_constexpr
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
+                                          const Args&... args) {
+  auto s = std::basic_string<Char>();
+  cf.format(std::back_inserter(s), args...);
+  return s;
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                                        const Args&... args) {
+  return cf.format(out, args...);
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
+                                                           Args&&... args) {
+  if constexpr (std::is_same<typename S::char_type, char>::value) {
+    constexpr auto str = basic_string_view<typename S::char_type>(S());
+    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
+      const auto& first = detail::first(args...);
+      if constexpr (detail::is_named_arg<
+                        remove_cvref_t<decltype(first)>>::value) {
+        return fmt::to_string(first.value);
+      } else {
+        return fmt::to_string(first);
+      }
+    }
+  }
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
+                  std::forward<Args>(args)...);
+  } else {
+    return format(compiled, std::forward<Args>(args)...);
+  }
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format_to(out,
+                     static_cast<basic_string_view<typename S::char_type>>(S()),
+                     std::forward<Args>(args)...);
+  } else {
+    return format_to(out, compiled, std::forward<Args>(args)...);
+  }
+}
+#endif
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const S& format_str, Args&&... args) {
+  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
+                      std::forward<Args>(args)...);
+  return {it.base(), it.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+size_t formatted_size(const S& format_str, const Args&... args) {
+  return format_to(detail::counting_iterator(), format_str, args...).count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+inline namespace literals {
+template <detail_exported::fixed_string Str>
+constexpr detail::udl_compiled_string<
+    remove_cvref_t<decltype(Str.data[0])>,
+    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
+operator""_cf() {
+  return {};
+}
+}  // namespace literals
+#endif
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_

include/spdlog/fmt/bundled/locale.h

@@ -1,27 +1,2 @@
-// Formatting library for C++ - locale support
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "format.h"
-#include <locale>
-
-namespace fmt {
-class locale
-{
-private:
-    std::locale locale_;
-
-public:
-    explicit locale(std::locale loc = std::locale())
-        : locale_(loc)
-    {
-    }
-    std::locale get()
-    {
-        return locale_;
-    }
-};
-} // namespace fmt
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead

include/spdlog/fmt/bundled/os.h

@@ -0,0 +1,515 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OS_H_
+#define FMT_OS_H_
+
+#include <cerrno>
+#include <clocale>  // locale_t
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>       // strtod_l
+#include <system_error>  // std::system_error
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#endif
+
+#include "format.h"
+
+// UWP doesn't provide _pipe.
+#if FMT_HAS_INCLUDE("winapifamily.h")
+#  include <winapifamily.h>
+#endif
+#if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                              \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>  // for O_RDONLY
+#  define FMT_USE_FCNTL 1
+#else
+#  define FMT_USE_FCNTL 0
+#endif
+
+#ifndef FMT_POSIX
+#  if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX(call) _##call
+#  else
+#    define FMT_POSIX(call) call
+#  endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+#  define FMT_SYSTEM(call) ::call
+#  ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX_CALL(call) ::_##call
+#  else
+#    define FMT_POSIX_CALL(call) ::call
+#  endif
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+#  define FMT_RETRY_VAL(result, expression, error_result) \
+    do {                                                  \
+      (result) = (expression);                            \
+    } while ((result) == (error_result) && errno == EINTR)
+#else
+#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template <typename Char> class basic_cstring_view {
+ private:
+  const Char* data_;
+
+ public:
+  /** Constructs a string reference object from a C string. */
+  basic_cstring_view(const Char* s) : data_(s) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char* c_str() const { return data_; }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
+#ifdef _WIN32
+FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  size_t size() const { return buffer_.size() - 1; }
+  const char* c_str() const { return &buffer_[0]; }
+  std::string str() const { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
+FMT_API void format_windows_error(buffer<char>& out, int error_code,
+                                  const char* message) FMT_NOEXCEPT;
+FMT_END_DETAIL_NAMESPACE
+
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+                                         format_args args);
+
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
+
+ **Example**::
+
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(args...));
+}
+
+// Reports a Windows error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_windows_error(int error_code,
+                                  const char* message) FMT_NOEXCEPT;
+#else
+inline const std::error_category& system_category() FMT_NOEXCEPT {
+  return std::system_category();
+}
+#endif  // _WIN32
+
+// std::system is not available on some platforms such as iOS (#2248).
+#ifdef __OSX__
+template <typename S, typename... Args, typename Char = char_t<S>>
+void say(const S& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  explicit buffered_file(FILE* f) : file_(f) {}
+
+ public:
+  buffered_file(const buffered_file&) = delete;
+  void operator=(const buffered_file&) = delete;
+
+  // Constructs a buffered_file object which doesn't represent any file.
+  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() FMT_NOEXCEPT;
+
+ public:
+  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  buffered_file& operator=(buffered_file&& other) {
+    close();
+    file_ = other.file_;
+    other.file_ = nullptr;
+    return *this;
+  }
+
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  FILE* get() const FMT_NOEXCEPT { return file_; }
+
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  FMT_API int(fileno)() const;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
+  }
+};
+
+#if FMT_USE_FCNTL
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with FMT_NOEXCEPT may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class file {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
+    RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
+    CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
+    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
+    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
+  };
+
+  // Constructs a file object which doesn't represent any file.
+  file() FMT_NOEXCEPT : fd_(-1) {}
+
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
+
+ public:
+  file(const file&) = delete;
+  void operator=(const file&) = delete;
+
+  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+
+  // Move assignment is not noexcept because close may throw.
+  file& operator=(file&& other) {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~file() FMT_NOEXCEPT;
+
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  FMT_API long long size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  FMT_API size_t read(void* buffer, size_t count);
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  FMT_API size_t write(const void* buffer, size_t count);
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  FMT_API static file dup(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  FMT_API static void pipe(file& read_end, file& write_end);
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  FMT_API buffered_file fdopen(const char* mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+struct buffer_size {
+  buffer_size() = default;
+  size_t value = 0;
+  buffer_size operator=(size_t val) const {
+    auto bs = buffer_size();
+    bs.value = val;
+    return bs;
+  }
+};
+
+struct ostream_params {
+  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
+  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
+
+  ostream_params() {}
+
+  template <typename... T>
+  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
+    oflag = new_oflag;
+  }
+
+  template <typename... T>
+  ostream_params(T... params, detail::buffer_size bs)
+      : ostream_params(params...) {
+    this->buffer_size = bs.value;
+  }
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+constexpr detail::buffer_size buffer_size;
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char> {
+ private:
+  file file_;
+
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size());
+    clear();
+  }
+
+  void grow(size_t) override;
+
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : file_(path, params.oflag) {
+    set(new char[params.buffer_size], params.buffer_size);
+  }
+
+ public:
+  ostream(ostream&& other)
+      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+        file_(std::move(other.file_)) {
+    other.clear();
+    other.set(nullptr, 0);
+  }
+  ~ostream() {
+    flush();
+    delete[] data();
+  }
+
+  template <typename... T>
+  friend ostream output_file(cstring_view path, T... params);
+
+  void close() {
+    flush();
+    file_.close();
+  }
+
+  /**
+    Formats ``args`` according to specifications in ``fmt`` and writes the
+    output to the file.
+   */
+  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
+  }
+};
+
+/**
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE`` by default)
+  * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
+ */
+template <typename... T>
+inline ostream output_file(cstring_view path, T... params) {
+  return {path, detail::ostream_params(params...)};
+}
+#endif  // FMT_USE_FCNTL
+
+#ifdef FMT_LOCALE
+// A "C" numeric locale.
+class locale {
+ private:
+#  ifdef _WIN32
+  using locale_t = _locale_t;
+
+  static void freelocale(locale_t loc) { _free_locale(loc); }
+
+  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
+    return _strtod_l(nptr, endptr, loc);
+  }
+#  endif
+
+  locale_t locale_;
+
+ public:
+  using type = locale_t;
+  locale(const locale&) = delete;
+  void operator=(const locale&) = delete;
+
+  locale() {
+#  ifndef _WIN32
+    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
+#  else
+    locale_ = _create_locale(LC_NUMERIC, "C");
+#  endif
+    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
+  }
+  ~locale() { freelocale(locale_); }
+
+  type get() const { return locale_; }
+
+  // Converts string to floating-point number and advances str past the end
+  // of the parsed input.
+  double strtod(const char*& str) const {
+    char* end = nullptr;
+    double result = strtod_l(str, &end, locale_);
+    str = end;
+    return result;
+  }
+};
+using Locale FMT_DEPRECATED_ALIAS = locale;
+#endif  // FMT_LOCALE
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_OS_H_

include/spdlog/fmt/bundled/ostream.h

@@ -1,6 +1,6 @@
 // Formatting library for C++ - std::ostream support
 //
-// Copyright (c) 2012 - 2016, Victor Zverovich
+// Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
 //
 // For the license information refer to format.h.
@@ -8,146 +8,158 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include "format.h"
 #include <ostream>
 
+#include "format.h"
+
 FMT_BEGIN_NAMESPACE
-namespace internal {
 
-template<class Char>
-class formatbuf : public std::basic_streambuf<Char>
-{
-private:
-    typedef typename std::basic_streambuf<Char>::int_type int_type;
-    typedef typename std::basic_streambuf<Char>::traits_type traits_type;
+template <typename Char> class basic_printf_parse_context;
+template <typename OutputIt, typename Char> class basic_printf_context;
 
-    basic_buffer<Char> &buffer_;
+namespace detail {
 
-public:
-    formatbuf(basic_buffer<Char> &buffer)
-        : buffer_(buffer)
-    {
-    }
+template <class Char> class formatbuf : public std::basic_streambuf<Char> {
+ private:
+  using int_type = typename std::basic_streambuf<Char>::int_type;
+  using traits_type = typename std::basic_streambuf<Char>::traits_type;
 
-protected:
-    // The put-area is actually always empty. This makes the implementation
-    // simpler and has the advantage that the streambuf and the buffer are always
-    // in sync and sputc never writes into uninitialized memory. The obvious
-    // disadvantage is that each call to sputc always results in a (virtual) call
-    // to overflow. There is no disadvantage here for sputn since this always
-    // results in a call to xsputn.
+  buffer<Char>& buffer_;
 
-    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
-    {
-        if (!traits_type::eq_int_type(ch, traits_type::eof()))
-            buffer_.push_back(static_cast<Char>(ch));
-        return ch;
-    }
+ public:
+  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
 
-    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
-    {
-        buffer_.append(s, s + count);
-        return count;
-    }
+ protected:
+  // The put-area is actually always empty. This makes the implementation
+  // simpler and has the advantage that the streambuf and the buffer are always
+  // in sync and sputc never writes into uninitialized memory. The obvious
+  // disadvantage is that each call to sputc always results in a (virtual) call
+  // to overflow. There is no disadvantage here for sputn since this always
+  // results in a call to xsputn.
+
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<Char>(ch));
+    return ch;
+  }
+
+  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
 };
 
-template<typename Char>
-struct test_stream : std::basic_ostream<Char>
-{
-private:
-    struct null;
-    // Hide all operator<< from std::basic_ostream<Char>.
-    void operator<<(null);
+struct converter {
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> converter(T);
 };
 
+template <typename Char> struct test_stream : std::basic_ostream<Char> {
+ private:
+  void_t<> operator<<(converter);
+};
+
+// Hide insertion operators for built-in types.
+template <typename Char, typename Traits>
+void_t<> operator<<(std::basic_ostream<Char, Traits>&, Char);
+template <typename Char, typename Traits>
+void_t<> operator<<(std::basic_ostream<Char, Traits>&, char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, signed char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, unsigned char);
+
 // Checks if T has a user-defined operator<< (e.g. not a member of
 // std::ostream).
-template<typename T, typename Char>
-class is_streamable
-{
-private:
-    template<typename U>
-    static decltype(internal::declval<test_stream<Char> &>() << internal::declval<U>(), std::true_type()) test(int);
+template <typename T, typename Char> class is_streamable {
+ private:
+  template <typename U>
+  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
+                                              << std::declval<U>()),
+                                     void_t<>>::value>
+  test(int);
 
-    template<typename>
-    static std::false_type test(...);
+  template <typename> static std::false_type test(...);
 
-    typedef decltype(test<T>(0)) result;
+  using result = decltype(test<T>(0));
 
-public:
-    // std::string operator<< is not considered user-defined because we handle
-    // strings
-    // specially.
-    static const bool value = result::value && !std::is_same<T, std::string>::value;
-};
+ public:
+  is_streamable() = default;
 
-// Disable conversion to int if T has an overloaded operator<< which is a free
-// function (not a member of std::ostream).
-template<typename T, typename Char>
-class convert_to_int<T, Char, true>
-{
-public:
-    static const bool value = convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+  static const bool value = result::value;
 };
 
 // Write the content of buf to os.
-template<typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
-{
-    const Char *data = buf.data();
-    typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
-    UnsignedStreamSize size = buf.size();
-    UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-    do
-    {
-        UnsignedStreamSize n = size <= max_size ? size : max_size;
-        os.write(data, static_cast<std::streamsize>(n));
-        data += n;
-        size -= n;
-    } while (size != 0);
+template <typename Char>
+void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
+  const Char* buf_data = buf.data();
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  unsigned_streamsize size = buf.size();
+  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+  do {
+    unsigned_streamsize n = size <= max_size ? size : max_size;
+    os.write(buf_data, static_cast<std::streamsize>(n));
+    buf_data += n;
+    size -= n;
+  } while (size != 0);
 }
 
-template<typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value)
-{
-    internal::formatbuf<Char> format_buf(buffer);
-    std::basic_ostream<Char> output(&format_buf);
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-    output << value;
-    buffer.resize(buffer.size());
+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  formatbuf<Char> format_buf(buf);
+  std::basic_ostream<Char> output(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  buf.try_resize(buf.size());
 }
 
-// Disable builtin formatting of enums and use operator<< instead.
-template<typename T>
-struct format_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type
-{
-};
-} // namespace internal
-
 // Formats an object of type T that has an overloaded ostream operator<<.
-template<typename T, typename Char>
-struct formatter<T, Char, typename std::enable_if<internal::is_streamable<T, Char>::value>::type> : formatter<basic_string_view<Char>, Char>
-{
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : private formatter<basic_string_view<Char>, Char> {
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    return formatter<basic_string_view<Char>, Char>::parse(ctx);
+  }
+  template <typename ParseCtx,
+            FMT_ENABLE_IF(std::is_same<
+                          ParseCtx, basic_printf_parse_context<Char>>::value)>
+  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 
-    template<typename Context>
-    auto format(const T &value, Context &ctx) -> decltype(ctx.out())
-    {
-        basic_memory_buffer<Char> buffer;
-        internal::format_value(buffer, value);
-        basic_string_view<Char> str(buffer.data(), buffer.size());
-        formatter<basic_string_view<Char>, Char>::format(str, ctx);
-        return ctx.out();
-    }
-};
-
-template<typename Char>
-inline void vprint(
-    std::basic_ostream<Char> &os, basic_string_view<Char> format_str, basic_format_args<typename buffer_context<Char>::type> args)
-{
+  template <typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
+      -> OutputIt {
     basic_memory_buffer<Char> buffer;
-    vformat_to(buffer, format_str, args);
-    internal::write(os, buffer);
+    format_value(buffer, value, ctx.locale());
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+  }
+  template <typename OutputIt>
+  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
+      -> OutputIt {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    return std::copy(buffer.begin(), buffer.end(), ctx.out());
+  }
+};
+}  // namespace detail
+
+FMT_MODULE_EXPORT
+template <typename Char>
+void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
 }
+
 /**
   \rst
   Prints formatted data to the stream *os*.
@@ -157,17 +169,13 @@ inline void vprint(
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-template<typename... Args>
-inline void print(std::ostream &os, string_view format_str, const Args &... args)
-{
-    vprint<char>(os, format_str, make_format_args<format_context>(args...));
-}
-
-template<typename... Args>
-inline void print(std::wostream &os, wstring_view format_str, const Args &... args)
-{
-    vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
+FMT_MODULE_EXPORT
+template <typename S, typename... Args,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+  vprint(os, to_string_view(format_str),
+         fmt::make_args_checked<Args...>(format_str, args...));
 }
 FMT_END_NAMESPACE
 
-#endif // FMT_OSTREAM_H_
+#endif  // FMT_OSTREAM_H_

include/spdlog/fmt/bundled/posix.h

@@ -1,484 +0,0 @@
-// A C++ interface to POSIX functions.
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_POSIX_H_
-#define FMT_POSIX_H_
-
-#if defined(__MINGW32__) || defined(__CYGWIN__)
-// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-#undef __STRICT_ANSI__
-#endif
-
-#include <errno.h>
-#include <fcntl.h>  // for O_RDONLY
-#include <locale.h> // for locale_t
-#include <stdio.h>
-#include <stdlib.h> // for strtod_l
-
-#include <cstddef>
-
-#if defined __APPLE__ || defined(__FreeBSD__)
-#include <xlocale.h> // for LC_NUMERIC_MASK on OS X
-#endif
-
-#include "format.h"
-
-#ifndef FMT_POSIX
-#if defined(_WIN32) && !defined(__MINGW32__)
-// Fix warnings about deprecated symbols.
-#define FMT_POSIX(call) _##call
-#else
-#define FMT_POSIX(call) call
-#endif
-#endif
-
-// Calls to system functions are wrapped in FMT_SYSTEM for testability.
-#ifdef FMT_SYSTEM
-#define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
-#else
-#define FMT_SYSTEM(call) call
-#ifdef _WIN32
-// Fix warnings about deprecated symbols.
-#define FMT_POSIX_CALL(call) ::_##call
-#else
-#define FMT_POSIX_CALL(call) ::call
-#endif
-#endif
-
-// Retries the expression while it evaluates to error_result and errno
-// equals to EINTR.
-#ifndef _WIN32
-#define FMT_RETRY_VAL(result, expression, error_result)                                                                                    \
-    do                                                                                                                                     \
-    {                                                                                                                                      \
-        result = (expression);                                                                                                             \
-    } while (result == error_result && errno == EINTR)
-#else
-#define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
-#endif
-
-#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
-
-FMT_BEGIN_NAMESPACE
-
-/**
-  \rst
-  A reference to a null-terminated string. It can be constructed from a C
-  string or ``std::string``.
-
-  You can use one of the following typedefs for common character types:
-
-  +---------------+-----------------------------+
-  | Type          | Definition                  |
-  +===============+=============================+
-  | cstring_view  | basic_cstring_view<char>    |
-  +---------------+-----------------------------+
-  | wcstring_view | basic_cstring_view<wchar_t> |
-  +---------------+-----------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(cstring_view format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
-template<typename Char>
-class basic_cstring_view
-{
-private:
-    const Char *data_;
-
-public:
-    /** Constructs a string reference object from a C string. */
-    basic_cstring_view(const Char *s)
-        : data_(s)
-    {
-    }
-
-    /**
-      \rst
-      Constructs a string reference from an ``std::string`` object.
-      \endrst
-     */
-    basic_cstring_view(const std::basic_string<Char> &s)
-        : data_(s.c_str())
-    {
-    }
-
-    /** Returns the pointer to a C string. */
-    const Char *c_str() const
-    {
-        return data_;
-    }
-};
-
-typedef basic_cstring_view<char> cstring_view;
-typedef basic_cstring_view<wchar_t> wcstring_view;
-
-// An error code.
-class error_code
-{
-private:
-    int value_;
-
-public:
-    explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
-
-    int get() const FMT_NOEXCEPT
-    {
-        return value_;
-    }
-};
-
-// A buffered file.
-class buffered_file
-{
-private:
-    FILE *file_;
-
-    friend class file;
-
-    explicit buffered_file(FILE *f)
-        : file_(f)
-    {
-    }
-
-public:
-    // Constructs a buffered_file object which doesn't represent any file.
-    buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
-
-    // Destroys the object closing the file it represents if any.
-    FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT;
-
-#if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        FILE *file;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-    buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
-
-    // A "move constructor" for moving from an lvalue.
-    buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_)
-    {
-        f.file_ = FMT_NULL;
-    }
-
-    // A "move assignment operator" for moving from a temporary.
-    buffered_file &operator=(Proxy p)
-    {
-        close();
-        file_ = p.file;
-        return *this;
-    }
-
-    // A "move assignment operator" for moving from an lvalue.
-    buffered_file &operator=(buffered_file &other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = FMT_NULL;
-        return *this;
-    }
-
-    // Returns a proxy object for moving from a temporary:
-    //   buffered_file file = buffered_file(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {file_};
-        file_ = FMT_NULL;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
-
-public:
-    buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_)
-    {
-        other.file_ = FMT_NULL;
-    }
-
-    buffered_file &operator=(buffered_file &&other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = FMT_NULL;
-        return *this;
-    }
-#endif
-
-    // Opens a file.
-    FMT_API buffered_file(cstring_view filename, cstring_view mode);
-
-    // Closes the file.
-    FMT_API void close();
-
-    // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
-    {
-        return file_;
-    }
-
-    // We place parentheses around fileno to workaround a bug in some versions
-    // of MinGW that define fileno as a macro.
-    FMT_API int(fileno)() const;
-
-    void vprint(string_view format_str, format_args args)
-    {
-        fmt::vprint(file_, format_str, args);
-    }
-
-    template<typename... Args>
-    inline void print(string_view format_str, const Args &... args)
-    {
-        vprint(format_str, make_format_args(args...));
-    }
-};
-
-// A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
-// fmt::system_error in case of failure. Note that some errors such as
-// closing the file multiple times will cause a crash on Windows rather
-// than an exception. You can get standard behavior by overriding the
-// invalid parameter handler with _set_invalid_parameter_handler.
-class file
-{
-private:
-    int fd_; // File descriptor.
-
-    // Constructs a file object with a given descriptor.
-    explicit file(int fd)
-        : fd_(fd)
-    {
-    }
-
-public:
-    // Possible values for the oflag argument to the constructor.
-    enum
-    {
-        RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
-        WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
-        RDWR = FMT_POSIX(O_RDWR)      // Open for reading and writing.
-    };
-
-    // Constructs a file object which doesn't represent any file.
-    file() FMT_NOEXCEPT : fd_(-1) {}
-
-    // Opens a file and constructs a file object representing this file.
-    FMT_API file(cstring_view path, int oflag);
-
-#if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        int fd;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-    file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
-
-    // A "move constructor" for moving from an lvalue.
-    file(file &other) FMT_NOEXCEPT : fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
-
-    // A "move assignment operator" for moving from a temporary.
-    file &operator=(Proxy p)
-    {
-        close();
-        fd_ = p.fd;
-        return *this;
-    }
-
-    // A "move assignment operator" for moving from an lvalue.
-    file &operator=(file &other)
-    {
-        close();
-        fd_ = other.fd_;
-        other.fd_ = -1;
-        return *this;
-    }
-
-    // Returns a proxy object for moving from a temporary:
-    //   file f = file(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {fd_};
-        fd_ = -1;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(file);
-
-public:
-    file(file &&other) FMT_NOEXCEPT : fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
-
-    file &operator=(file &&other)
-    {
-        close();
-        fd_ = other.fd_;
-        other.fd_ = -1;
-        return *this;
-    }
-#endif
-
-    // Destroys the object closing the file it represents if any.
-    FMT_API ~file() FMT_DTOR_NOEXCEPT;
-
-    // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
-    {
-        return fd_;
-    }
-
-    // Closes the file.
-    FMT_API void close();
-
-    // Returns the file size. The size has signed type for consistency with
-    // stat::st_size.
-    FMT_API long long size() const;
-
-    // Attempts to read count bytes from the file into the specified buffer.
-    FMT_API std::size_t read(void *buffer, std::size_t count);
-
-    // Attempts to write count bytes from the specified buffer to the file.
-    FMT_API std::size_t write(const void *buffer, std::size_t count);
-
-    // Duplicates a file descriptor with the dup function and returns
-    // the duplicate as a file object.
-    FMT_API static file dup(int fd);
-
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    FMT_API void dup2(int fd);
-
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
-
-    // Creates a pipe setting up read_end and write_end file objects for reading
-    // and writing respectively.
-    FMT_API static void pipe(file &read_end, file &write_end);
-
-    // Creates a buffered_file object associated with this file and detaches
-    // this file object from the file.
-    FMT_API buffered_file fdopen(const char *mode);
-};
-
-// Returns the memory page size.
-long getpagesize();
-
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
-#define FMT_LOCALE
-#endif
-
-#ifdef FMT_LOCALE
-// A "C" numeric locale.
-class Locale
-{
-private:
-#ifdef _MSC_VER
-    typedef _locale_t locale_t;
-
-    enum
-    {
-        LC_NUMERIC_MASK = LC_NUMERIC
-    };
-
-    static locale_t newlocale(int category_mask, const char *locale, locale_t)
-    {
-        return _create_locale(category_mask, locale);
-    }
-
-    static void freelocale(locale_t locale)
-    {
-        _free_locale(locale);
-    }
-
-    static double strtod_l(const char *nptr, char **endptr, _locale_t locale)
-    {
-        return _strtod_l(nptr, endptr, locale);
-    }
-#endif
-
-    locale_t locale_;
-
-    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
-
-public:
-    typedef locale_t Type;
-
-    Locale()
-        : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
-    {
-        if (!locale_)
-            FMT_THROW(system_error(errno, "cannot create locale"));
-    }
-    ~Locale()
-    {
-        freelocale(locale_);
-    }
-
-    Type get() const
-    {
-        return locale_;
-    }
-
-    // Converts string to floating-point number and advances str past the end
-    // of the parsed input.
-    double strtod(const char *&str) const
-    {
-        char *end = FMT_NULL;
-        double result = strtod_l(str, &end, locale_);
-        str = end;
-        return result;
-    }
-};
-#endif // FMT_LOCALE
-FMT_END_NAMESPACE
-
-#if !FMT_USE_RVALUE_REFERENCES
-namespace std {
-// For compatibility with C++98.
-inline fmt::buffered_file &move(fmt::buffered_file &f)
-{
-    return f;
-}
-inline fmt::file &move(fmt::file &f)
-{
-    return f;
-}
-} // namespace std
-#endif
-
-#endif // FMT_POSIX_H_

include/spdlog/fmt/bundled/ranges.h

@@ -1,4 +1,4 @@
-// Formatting library for C++ - the core API
+// Formatting library for C++ - experimental range support
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@@ -12,333 +12,457 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
 
-#include "format.h"
+#include <initializer_list>
 #include <type_traits>
 
-// output only up to N items from the range.
-#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
-#endif
+#include "format.h"
 
 FMT_BEGIN_NAMESPACE
 
-template<typename Char>
-struct formatting_base
-{
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return ctx.begin();
-    }
+template <typename Char, typename Enable = void> struct formatting_range {
+#ifdef FMT_DEPRECATED_BRACED_RANGES
+  Char prefix = '{';
+  Char postfix = '}';
+#else
+  Char prefix = '[';
+  Char postfix = ']';
+#endif
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 };
 
-template<typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char>
-{
-    static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the
-                                                                                                    // range.
-    Char prefix;
-    Char delimiter;
-    Char postfix;
-    formatting_range()
-        : prefix('{')
-        , delimiter(',')
-        , postfix('}')
-    {
-    }
-    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+template <typename Char, typename Enable = void> struct formatting_tuple {
+  Char prefix = '(';
+  Char postfix = ')';
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 };
 
-template<typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char>
-{
-    Char prefix;
-    Char delimiter;
-    Char postfix;
-    formatting_tuple()
-        : prefix('(')
-        , delimiter(',')
-        , postfix(')')
-    {
-    }
-    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
-};
+namespace detail {
 
-namespace internal {
-
-template<typename RangeT, typename OutputIterator>
-void copy(const RangeT &range, OutputIterator out)
-{
-    for (auto it = range.begin(), end = range.end(); it != end; ++it)
-        *out++ = *it;
+template <typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
 }
 
-template<typename OutputIterator>
-void copy(const char *str, OutputIterator out)
-{
-    const char *p_curr = str;
-    while (*p_curr)
-    {
-        *out++ = *p_curr++;
-    }
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
 }
 
-template<typename OutputIterator>
-void copy(char ch, OutputIterator out)
-{
-    *out++ = ch;
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
 }
 
 /// Return true value if T has std::string interface, like std::string_view.
-template<typename T>
-class is_like_std_string
-{
-    template<typename U>
-    static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int());
-    template<typename>
-    static void check(...);
+template <typename T> class is_std_string_like {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
 
-public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
-template<typename... Ts>
-struct conditional_helper
-{
-};
+template <typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
 
-template<typename T, typename _ = void>
-struct is_range_ : std::false_type
-{
-};
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template<typename T>
-struct is_range_<T, typename std::conditional<false,
-                        conditional_helper<decltype(internal::declval<T>().begin()), decltype(internal::declval<T>().end())>, void>::type>
-    : std::true_type
-{
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
+// C array overload
+template <typename T, std::size_t N>
+auto range_begin(const T (&arr)[N]) -> const T* {
+  return arr;
+}
+template <typename T, std::size_t N>
+auto range_end(const T (&arr)[N]) -> const T* {
+  return arr + N;
+}
+
+template <typename T, typename Enable = void>
+struct has_member_fn_begin_end_t : std::false_type {};
+
+template <typename T>
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
+                                           decltype(std::declval<T>().end())>>
+    : std::true_type {};
+
+// Member function overload
+template <typename T>
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+template <typename T>
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+
+// ADL overload. Only participates in overload resolution if member functions
+// are not found.
+template <typename T>
+auto range_begin(T&& rng)
+    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                   decltype(begin(static_cast<T&&>(rng)))> {
+  return begin(static_cast<T&&>(rng));
+}
+template <typename T>
+auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                                       decltype(end(static_cast<T&&>(rng)))> {
+  return end(static_cast<T&&>(rng));
+}
+
+template <typename T, typename Enable = void>
+struct has_const_begin_end : std::false_type {};
+template <typename T, typename Enable = void>
+struct has_mutable_begin_end : std::false_type {};
+
+template <typename T>
+struct has_const_begin_end<
+    T, void_t<decltype(detail::range_begin(
+                  std::declval<const remove_cvref_t<T>&>())),
+              decltype(detail::range_begin(
+                  std::declval<const remove_cvref_t<T>&>()))>>
+    : std::true_type {};
+
+template <typename T>
+struct has_mutable_begin_end<
+    T, void_t<decltype(detail::range_begin(std::declval<T>())),
+              decltype(detail::range_begin(std::declval<T>())),
+              enable_if_t<std::is_copy_constructible<T>::value>>>
+    : std::true_type {};
+
+template <typename T>
+struct is_range_<T, void>
+    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
+                                    has_mutable_begin_end<T>::value)> {};
+
+template <typename T, typename Enable = void> struct range_to_view;
+template <typename T>
+struct range_to_view<T, enable_if_t<has_const_begin_end<T>::value>> {
+  struct view_t {
+    const T* m_range_ptr;
+
+    auto begin() const FMT_DECLTYPE_RETURN(detail::range_begin(*m_range_ptr));
+    auto end() const FMT_DECLTYPE_RETURN(detail::range_end(*m_range_ptr));
+  };
+  static auto view(const T& range) -> view_t { return {&range}; }
 };
+
+template <typename T>
+struct range_to_view<T, enable_if_t<!has_const_begin_end<T>::value &&
+                                    has_mutable_begin_end<T>::value>> {
+  struct view_t {
+    T m_range_copy;
+
+    auto begin() FMT_DECLTYPE_RETURN(detail::range_begin(m_range_copy));
+    auto end() FMT_DECLTYPE_RETURN(detail::range_end(m_range_copy));
+  };
+  static auto view(const T& range) -> view_t { return {range}; }
+};
+#  undef FMT_DECLTYPE_RETURN
 #endif
 
 /// tuple_size and tuple_element check.
-template<typename T>
-class is_tuple_like_
-{
-    template<typename U>
-    static auto check(U *p) -> decltype(std::tuple_size<U>::value, internal::declval<typename std::tuple_element<0, U>::type>(), int());
-    template<typename>
-    static void check(...);
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename> static void check(...);
 
-public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template<typename T, T... N>
+template <typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
-template<std::size_t... N>
-using index_sequence = std::index_sequence<N...>;
-template<std::size_t N>
-using make_index_sequence = std::make_index_sequence<N>;
+template <size_t... N> using index_sequence = std::index_sequence<N...>;
+template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
 #else
-template<typename T, T... N>
-struct integer_sequence
-{
-    typedef T value_type;
+template <typename T, T... N> struct integer_sequence {
+  using value_type = T;
 
-    static FMT_CONSTEXPR std::size_t size()
-    {
-        return sizeof...(N);
-    }
+  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
 };
 
-template<std::size_t... N>
-using index_sequence = integer_sequence<std::size_t, N...>;
+template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
 
-template<typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
-{
-};
-template<typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
-{
-};
+template <typename T, size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
 
-template<std::size_t N>
-using make_index_sequence = make_integer_sequence<std::size_t, N>;
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
 #endif
 
-template<class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT
-{
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+template <typename Range>
+using value_type =
+    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;
+
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(is_std_string_like<typename std::decay<Arg>::type>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  *out++ = '"';
+  out = write<Char>(out, v);
+  *out++ = '"';
+  return out;
+}
+
+template <typename Char, typename OutputIt, typename Arg,
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v) {
+  *out++ = '\'';
+  *out++ = v;
+  *out++ = '\'';
+  return out;
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
+
+}  // namespace detail
+
+template <typename T> struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
+ private:
+  // C++11 generic lambda for format()
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, v);
+      ++i;
+    }
+    formatting_tuple<Char>& formatting;
+    size_t& i;
+    typename std::add_lvalue_reference<
+        decltype(std::declval<FormatContext>().out())>::type out;
+  };
+
+ public:
+  formatting_tuple<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    size_t i = 0;
+
+    detail::copy(formatting.prefix, out);
+    detail::for_each(values, format_each<FormatContext>{formatting, i, out});
+    detail::copy(formatting.postfix, out);
+
+    return ctx.out();
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<detail::std_string_view<Char>, T>::value;
+};
+
+template <typename T, typename Char>
+struct formatter<
+    T, Char,
+    enable_if_t<
+        fmt::is_range<T, Char>::value
+// Workaround a bug in MSVC 2017 and earlier.
+#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
+        && (has_formatter<detail::value_type<T>, format_context>::value ||
+            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
+#endif
+        >> {
+  formatting_range<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const T& values, FormatContext& ctx) {
+    auto out = detail::copy(formatting.prefix, ctx.out());
+    size_t i = 0;
+    auto view = detail::range_to_view<T>::view(values);
+    auto it = view.begin();
+    auto end = view.end();
+    for (; it != end; ++it) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, *it);
+      ++i;
+    }
+    return detail::copy(formatting.postfix, out);
+  }
+};
+
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple(t), sep{s} {}
+};
+
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+template <typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx) ->
+      typename FormatContext::iterator {
+    return format(value, ctx, detail::make_index_sequence<sizeof...(T)>{});
+  }
+
+ private:
+  template <typename FormatContext, size_t... N>
+  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+              detail::index_sequence<N...>) ->
+      typename FormatContext::iterator {
     using std::get;
-    // using free function get<I>(T) now.
-    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-    (void)_; // blocks warnings
-}
+    return format_args(value, ctx, get<N>(value.tuple)...);
+  }
 
-template<class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
-{
-    return {};
-}
+  template <typename FormatContext>
+  auto format_args(const tuple_join_view<Char, T...>&, FormatContext& ctx) ->
+      typename FormatContext::iterator {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
 
-template<class Tuple, class F>
-void for_each(Tuple &&tup, F &&f)
-{
-    const auto indexes = get_indexes(tup);
-    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-}
-
-template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
-    bool add_space, const Arg &, typename std::enable_if<!is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
-{
-    return add_space ? " {}" : "{}";
-}
-
-template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
-    bool add_space, const Arg &, typename std::enable_if<is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
-{
-    return add_space ? " \"{}\"" : "\"{}\"";
-}
-
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
-{
-    return add_space ? " \"{}\"" : "\"{}\"";
-}
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
-{
-    return add_space ? L" \"{}\"" : L"\"{}\"";
-}
-
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
-{
-    return add_space ? " '{}'" : "'{}'";
-}
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
-{
-    return add_space ? L" '{}'" : L"'{}'";
-}
-
-} // namespace internal
-
-template<typename T>
-struct is_tuple_like
-{
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+  template <typename FormatContext, typename Arg, typename... Args>
+  auto format_args(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+                   const Arg& arg, const Args&... args) ->
+      typename FormatContext::iterator {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out = base().format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
 };
 
-template<typename TupleT, typename Char>
-struct formatter<TupleT, Char, typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type>
-{
-private:
-    // C++11 generic lambda for format()
-    template<typename FormatContext>
-    struct format_each
-    {
-        template<typename T>
-        void operator()(const T &v)
-        {
-            if (i > 0)
-            {
-                if (formatting.add_prepostfix_space)
-                {
-                    *out++ = ' ';
-                }
-                internal::copy(formatting.delimiter, out);
-            }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
-            ++i;
-        }
+FMT_MODULE_EXPORT_BEGIN
 
-        formatting_tuple<Char> &formatting;
-        std::size_t &i;
-        typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
-    };
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
 
-public:
-    formatting_tuple<Char> formatting;
+  **Example**::
 
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return formatting.parse(ctx);
-    }
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
+  return {tuple, sep};
+}
 
-    template<typename FormatContext = format_context>
-    auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        auto out = ctx.out();
-        std::size_t i = 0;
-        internal::copy(formatting.prefix, out);
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
+  return {tuple, sep};
+}
 
-        internal::for_each(values, format_each<FormatContext>{formatting, i, out});
-        if (formatting.add_prepostfix_space)
-        {
-            *out++ = ' ';
-        }
-        internal::copy(formatting.postfix, out);
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
 
-        return ctx.out();
-    }
-};
+  **Example**::
 
-template<typename T>
-struct is_range
-{
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
-};
-
-template<typename RangeT, typename Char>
-struct formatter<RangeT, Char, typename std::enable_if<fmt::is_range<RangeT>::value>::type>
-{
-
-    formatting_range<Char> formatting;
-
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return formatting.parse(ctx);
-    }
-
-    template<typename FormatContext>
-    typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
-    {
-        auto out = ctx.out();
-        internal::copy(formatting.prefix, out);
-        std::size_t i = 0;
-        for (auto it = values.begin(), end = values.end(); it != end; ++it)
-        {
-            if (i > 0)
-            {
-                if (formatting.add_prepostfix_space)
-                {
-                    *out++ = ' ';
-                }
-                internal::copy(formatting.delimiter, out);
-            }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
-            if (++i > formatting.range_length_limit)
-            {
-                format_to(out, " ... <other elements>");
-                break;
-            }
-        }
-        if (formatting.add_prepostfix_space)
-        {
-            *out++ = ' ';
-        }
-        internal::copy(formatting.postfix, out);
-        return ctx.out();
-    }
-};
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template <typename T>
+auto join(std::initializer_list<T> list, string_view sep)
+    -> join_view<const T*, const T*> {
+  return join(std::begin(list), std::end(list), sep);
+}
 
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
-#endif // FMT_RANGES_H_
+#endif  // FMT_RANGES_H_

include/spdlog/fmt/bundled/time.h

@@ -1,199 +0,0 @@
-// Formatting library for C++ - time formatting
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_TIME_H_
-#define FMT_TIME_H_
-
-#include "format.h"
-#include <ctime>
-
-FMT_BEGIN_NAMESPACE
-
-namespace internal {
-inline null<> localtime_r(...)
-{
-    return null<>();
-}
-inline null<> localtime_s(...)
-{
-    return null<>();
-}
-inline null<> gmtime_r(...)
-{
-    return null<>();
-}
-inline null<> gmtime_s(...)
-{
-    return null<>();
-}
-} // namespace internal
-
-// Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time)
-{
-    struct dispatcher
-    {
-        std::time_t time_;
-        std::tm tm_;
-
-        dispatcher(std::time_t t)
-            : time_(t)
-        {
-        }
-
-        bool run()
-        {
-            using namespace fmt::internal;
-            return handle(localtime_r(&time_, &tm_));
-        }
-
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
-
-        bool handle(internal::null<>)
-        {
-            using namespace fmt::internal;
-            return fallback(localtime_s(&tm_, &time_));
-        }
-
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
-
-        bool fallback(internal::null<>)
-        {
-            using namespace fmt::internal;
-            std::tm *tm = std::localtime(&time_);
-            if (tm)
-                tm_ = *tm;
-            return tm != FMT_NULL;
-        }
-    };
-    dispatcher lt(time);
-    if (lt.run())
-        return lt.tm_;
-    // Too big time values may be unsupported.
-    FMT_THROW(format_error("time_t value out of range"));
-}
-
-// Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time)
-{
-    struct dispatcher
-    {
-        std::time_t time_;
-        std::tm tm_;
-
-        dispatcher(std::time_t t)
-            : time_(t)
-        {
-        }
-
-        bool run()
-        {
-            using namespace fmt::internal;
-            return handle(gmtime_r(&time_, &tm_));
-        }
-
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
-
-        bool handle(internal::null<>)
-        {
-            using namespace fmt::internal;
-            return fallback(gmtime_s(&tm_, &time_));
-        }
-
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
-
-        bool fallback(internal::null<>)
-        {
-            std::tm *tm = std::gmtime(&time_);
-            if (tm)
-                tm_ = *tm;
-            return tm != FMT_NULL;
-        }
-    };
-    dispatcher gt(time);
-    if (gt.run())
-        return gt.tm_;
-    // Too big time values may be unsupported.
-    FMT_THROW(format_error("time_t value out of range"));
-}
-
-namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
-{
-    return std::strftime(str, count, format, time);
-}
-
-inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time)
-{
-    return std::wcsftime(str, count, format, time);
-}
-} // namespace internal
-
-template<typename Char>
-struct formatter<std::tm, Char>
-{
-    template<typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        auto it = internal::null_terminating_iterator<Char>(ctx);
-        if (*it == ':')
-            ++it;
-        auto end = it;
-        while (*end && *end != '}')
-            ++end;
-        tm_format.reserve(end - it + 1);
-        using internal::pointer_from;
-        tm_format.append(pointer_from(it), pointer_from(end));
-        tm_format.push_back('\0');
-        return pointer_from(end);
-    }
-
-    template<typename FormatContext>
-    auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
-        std::size_t start = buf.size();
-        for (;;)
-        {
-            std::size_t size = buf.capacity() - start;
-            std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
-            if (count != 0)
-            {
-                buf.resize(start + count);
-                break;
-            }
-            if (size >= tm_format.size() * 256)
-            {
-                // If the buffer is 256 times larger than the format string, assume
-                // that `strftime` gives an empty result. There doesn't seem to be a
-                // better way to distinguish the two cases:
-                // https://github.com/fmtlib/fmt/issues/367
-                break;
-            }
-            const std::size_t MIN_GROWTH = 10;
-            buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-        }
-        return ctx.out();
-    }
-
-    basic_memory_buffer<Char> tm_format;
-};
-FMT_END_NAMESPACE
-
-#endif // FMT_TIME_H_

include/spdlog/fmt/bundled/xchar.h

@@ -0,0 +1,236 @@
+// Formatting library for C++ - optional wchar_t and exotic character support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_WCHAR_H_
+#define FMT_WCHAR_H_
+
+#include <cwchar>
+#include <tuple>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+}
+
+FMT_MODULE_EXPORT_BEGIN
+
+using wstring_view = basic_string_view<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+#endif
+
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+template <typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+    const Args&... args) {
+  return {args...};
+}
+
+inline namespace literals {
+constexpr auto operator"" _format(const wchar_t* s, size_t n)
+    -> detail::udl_formatter<wchar_t> {
+  return {{s, n}};
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
+  return {s};
+}
+#endif
+}  // namespace literals
+
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, wstring_view sep)
+    -> join_view<It, Sentinel, wchar_t> {
+  return {begin, end, sep};
+}
+
+template <typename Range>
+auto join(Range&& range, wstring_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+                 wchar_t> {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+template <typename T>
+auto join(std::initializer_list<T> list, wstring_view sep)
+    -> join_view<const T*, const T*, wchar_t> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
+}
+
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat(to_string_view(format_str), vargs);
+}
+
+template <typename Locale, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str), args);
+}
+
+template <typename Locale, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str),
+                         fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+auto vformat_to(OutputIt out, const S& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, to_string_view(format_str), args);
+  return detail::get_iterator(buf);
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to(out, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char, size_t SIZE,
+          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
+FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
+                              const S& format_str, Args&&... args) ->
+    typename buffer_context<Char>::iterator {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
+  return detail::buffer_appender<Char>(buf);
+}
+
+template <typename Locale, typename S, typename OutputIt, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_locale<Locale>::value&&
+                                detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(
+    OutputIt out, const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
+  return detail::get_iterator(buf);
+}
+
+template <
+    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename Char = char_t<S>,
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat_to(out, loc, to_string_view(format_str), vargs);
+}
+
+template <typename OutputIt, typename Char, typename... Args,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> format_to_n_result<OutputIt> {
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+                                                                           n);
+  detail::vformat_to(buf, format_str, args);
+  return {buf.out(), buf.count()};
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+                        const Args&... args) -> format_to_n_result<OutputIt> {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+  detail::counting_buffer<Char> buf;
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  detail::vformat_to(buf, to_string_view(fmt), vargs);
+  return buf.count();
+}
+
+inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
+  wmemory_buffer buffer;
+  detail::vformat_to(buffer, fmt, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+inline void vprint(wstring_view fmt, wformat_args args) {
+  vprint(stdout, fmt, args);
+}
+
+template <typename... T>
+void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  return vprint(f, wstring_view(fmt), make_wformat_args(args...));
+}
+
+template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
+  return vprint(wstring_view(fmt), make_wformat_args(args...));
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
+  return format(FMT_STRING(L"{}"), value);
+}
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_WCHAR_H_

include/spdlog/fmt/chrono.h

@@ -0,0 +1,20 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's chrono support
+//
+
+#if !defined(SPDLOG_FMT_EXTERNAL)
+#    ifdef SPDLOG_HEADER_ONLY
+#        ifndef FMT_HEADER_ONLY
+#            define FMT_HEADER_ONLY
+#        endif
+#    endif
+#    include <spdlog/fmt/bundled/chrono.h>
+#else
+#    include <fmt/chrono.h>
+#endif

include/spdlog/fmt/compile.h

@@ -0,0 +1,20 @@
+//
+// Copyright(c) 2016 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+//
+// include bundled or external copy of fmtlib's ostream support
+//
+
+#if !defined(SPDLOG_FMT_EXTERNAL)
+#    ifdef SPDLOG_HEADER_ONLY
+#        ifndef FMT_HEADER_ONLY
+#            define FMT_HEADER_ONLY
+#        endif
+#    endif
+#    include <spdlog/fmt/bundled/compile.h>
+#else
+#    include <fmt/compile.h>
+#endif

include/spdlog/fmt/fmt.h

@@ -11,15 +11,17 @@
 //
 
 #if !defined(SPDLOG_FMT_EXTERNAL)
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#ifndef FMT_USE_WINDOWS_H
-#define FMT_USE_WINDOWS_H 0
-#endif
-#include "bundled/core.h"
-#include "bundled/format.h"
-#else // external fmtlib
-#include <fmt/core.h>
-#include <fmt/format.h>
+#    if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
+#        define FMT_HEADER_ONLY
+#    endif
+#    ifndef FMT_USE_WINDOWS_H
+#        define FMT_USE_WINDOWS_H 0
+#    endif
+// enable the 'n' flag in for backward compatibility with fmt 6.x
+#    define FMT_DEPRECATED_N_SPECIFIER
+#    include <spdlog/fmt/bundled/core.h>
+#    include <spdlog/fmt/bundled/format.h>
+#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
+#    include <fmt/core.h>
+#    include <fmt/format.h>
 #endif