.clang-format

@@ -1,19 +1,109 @@
 ---
 Language:        Cpp
-BasedOnStyle:  Google
+# BasedOnStyle:  LLVM
 AccessModifierOffset: -4
-Standard:        c++17
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:     
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     140
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces:  false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
 IndentWidth:     4
-TabWidth:        4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
 UseTab:          Never
-ColumnLimit:     100
+IndentPPDirectives: AfterHash
-AlignAfterOpenBracket: Align
-BinPackParameters: false
-AlignEscapedNewlines: Left
-AlwaysBreakTemplateDeclarations: Yes
-PackConstructorInitializers: Never
-BreakConstructorInitializersBeforeComma: false
-IndentPPDirectives: BeforeHash
-SortIncludes:    Never
 ...
 

.clang-tidy

@@ -27,6 +27,7 @@ clang-analyzer-*,
 
 WarningsAsErrors: ''
 HeaderFilterRegex: '*spdlog/[^f].*'
+AnalyzeTemporaryDtors: false
 FormatStyle:     none
 
 CheckOptions:    

.git-blame-ignore-revs

@@ -1,6 +0,0 @@
-# clang-format
-1a0bfc7a89f2d58e22605a4dc7e18a9a555b65aa
-95c226e9c92928e20ccdac0d060e7241859e282b
-9d52261185b5f2c454c381d626ec5c84d7b195f4
-4b2a8219d5d1b40062d030441adde7d1fb0d4f84
-0a53eafe18d983c7c8ba4cadd02d0cc7f7308f28

.github/workflows/ci.yml

@@ -1,39 +1,34 @@
-name: linux
+name: ci
 
 on: [push, pull_request]
 
-permissions:
-  contents: read
-
 jobs:
-  # -----------------------------------------------------------------------
+  build_linux:
-  # Linux build matrix
-  # -----------------------------------------------------------------------
-  build:
     runs-on: ubuntu-latest
     defaults:
       run:
         shell: bash
     strategy:
-      fail-fast: false
       matrix:
         config:
+          - { compiler: gcc, version: 4.9, build_type: Release, cppstd: 11, examples: OFF, asan: OFF }
           - { compiler: gcc, version: 7, build_type: Release, cppstd: 11 }
           - { compiler: gcc, version: 9, build_type: Release, cppstd: 17 }
           - { compiler: gcc, version: 11, build_type: Debug, cppstd: 20 }
           - { compiler: gcc, version: 12, build_type: Release, cppstd: 20 }
-          - { compiler: gcc, version: 12, build_type: Debug, cppstd: 20, asan: ON }
+          - { compiler: clang, version: 3.5, build_type: Release, cppstd: 11, asan: OFF }
-          - { compiler: clang, version: 12, build_type: Debug, cppstd: 17 }
+          - { compiler: clang, version: 10, build_type: Release, cppstd: 11 }
-          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, tsan: ON }
+          - { compiler: clang, version: 10, build_type: Debug, cppstd: 17, asan: OFF }
+          - { compiler: clang, version: 12, build_type: Debug, cppstd: 17, asan: OFF }
+          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, asan: OFF }
     container:
       image: ${{ matrix.config.compiler == 'clang' && 'teeks99/clang-ubuntu' || matrix.config.compiler }}:${{ matrix.config.version }}
-    name: "${{ matrix.config.compiler}} ${{ matrix.config.version }} (C++${{ matrix.config.cppstd }} ${{ matrix.config.build_type }} ${{ matrix.config.asan == 'ON' && 'ASAN' || '' }}${{ matrix.config.tsan == 'ON' && 'TSAN' || '' }})"
+    name: "${{ matrix.config.compiler}} ${{ matrix.config.version }} (C++${{ matrix.config.cppstd }}, ${{ matrix.config.build_type }})"
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - name: Setup
         run: |
-          apt-get update
+          apt-get update && apt-get install -y curl
-          apt-get install -y curl git pkg-config libsystemd-dev
           CMAKE_VERSION="3.24.2"
           curl -sSL https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-x86_64.sh -o install-cmake.sh
           chmod +x install-cmake.sh
@@ -41,8 +36,10 @@ jobs:
       - name: Setup Compiler
         if: matrix.config.compiler == 'clang'
         run: |
+          if [[ "${{ matrix.config.version }}" -ge 4 ]]; then
             scripts/ci_setup_clang.sh "${{ matrix.config.version }}"
             echo "CXXFLAGS=-stdlib=libc++" >> $GITHUB_ENV
+          fi
           echo "CC=clang-${{ matrix.config.version }}" >> $GITHUB_ENV
           echo "CXX=clang++-${{ matrix.config.version }}" >> $GITHUB_ENV
       - name: Build
@@ -57,19 +54,15 @@ jobs:
             -DSPDLOG_BUILD_BENCH=OFF \
             -DSPDLOG_BUILD_TESTS=ON \
             -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'OFF' }} \
+            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'ON' }}
-            -DSPDLOG_SANITIZE_THREAD=${{ matrix.config.tsan || 'OFF' }}
+          make -j2
-          make -j 4
+          ctest -j2 --output-on-failure
-          ctest -j 4 --output-on-failure
 
-  # -----------------------------------------------------------------------
-  # OS X build matrix
-  # -----------------------------------------------------------------------
   build_osx:
     runs-on: macOS-latest
     name: "OS X Clang (C++11, Release)"
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@main
       - name: Build
         run: |
           mkdir -p build && cd build
@@ -83,5 +76,6 @@ jobs:
             -DSPDLOG_BUILD_TESTS=ON \
             -DSPDLOG_BUILD_TESTS_HO=OFF \
             -DSPDLOG_SANITIZE_ADDRESS=OFF
-          make -j 4
+          make -j2
-          ctest -j 4 --output-on-failure
+          ctest -j2 --output-on-failure
+

.github/workflows/macos.yml

@@ -1,38 +0,0 @@
-name: macos
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: macOS-latest
-    name: "macOS Clang (C++11, Release)"
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-            - USE_STD_FORMAT: 'ON'
-              BUILD_EXAMPLE: 'OFF'
-            - USE_STD_FORMAT: 'OFF'
-              BUILD_EXAMPLE: 'ON'
-              
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build
-        run: |
-          mkdir -p build && cd build
-          cmake .. \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_CXX_STANDARD=11 \
-            -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} \
-            -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} \
-            -DSPDLOG_BUILD_WARNINGS=ON \
-            -DSPDLOG_BUILD_BENCH=OFF \
-            -DSPDLOG_BUILD_TESTS=ON \
-            -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} \
-            -DSPDLOG_SANITIZE_ADDRESS=OFF
-          make -j 4
-          ctest -j 4 --output-on-failure

.github/workflows/windows.yml

@@ -1,148 +0,0 @@
-name: windows
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'OFF'
-            USE_STD_FORMAT: 'ON'
-            CXX_STANDARD: 20
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'ON'
-            WCHAR_FILES: 'ON'
-            BUILD_EXAMPLE: 'OFF'
-            USE_STD_FORMAT: 'ON'
-            CXX_STANDARD: 20
-          - GENERATOR: "Visual Studio 17 2022"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 17
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}
-        shell: pwsh
-        run: |
-          mkdir build
-          cd build
-          cmake -G "${{ matrix.config.GENERATOR }}"  -A x64 `
-            -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `
-            -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `
-            -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `
-            -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `
-            -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_TESTS=ON `
-            -D SPDLOG_BUILD_TESTS_HO=OFF `
-            -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `
-            -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `
-            -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..
-
-      - name: Build
-        shell: pwsh
-        run: |
-          cd build
-          cmake --build  . --parallel --config ${{ matrix.config.BUILD_TYPE }}
-
-      - name: Run Tests
-        shell: pwsh
-        env:
-          PATH: ${{ env.PATH }};${{ github.workspace }}\build\_deps\catch2-build\src\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\build\${{ matrix.config.BUILD_TYPE }}
-        run: |
-          build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe
-
-  # -----------------------------------------------------------------------
-  # MSVC 2019 build matrix
-  # -----------------------------------------------------------------------
-  build_2019:
-    runs-on: windows-2019
-    strategy:
-      fail-fast: true
-      matrix:
-        config:
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 17
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 14
-          - GENERATOR: "Visual Studio 16 2019"
-            BUILD_TYPE: Release
-            BUILD_SHARED: 'ON'
-            FATAL_ERRORS: 'ON'
-            WCHAR: 'OFF'
-            WCHAR_FILES: 'OFF'
-            BUILD_EXAMPLE: 'ON'
-            USE_STD_FORMAT: 'OFF'
-            CXX_STANDARD: 11
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}
-        shell: pwsh
-        run: |
-          mkdir build
-          cd build
-          cmake -G "${{ matrix.config.GENERATOR }}"  -A x64 `
-            -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `
-            -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `
-            -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `
-            -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `
-            -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `
-            -D SPDLOG_BUILD_TESTS=ON `
-            -D SPDLOG_BUILD_TESTS_HO=OFF `
-            -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `
-            -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `
-            -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..
-
-      - name: Build
-        shell: pwsh
-        run: |
-          cd build
-          cmake --build  . --parallel --config ${{ matrix.config.BUILD_TYPE }}
-
-      - name: Run Tests
-        shell: pwsh
-        env:
-          PATH: ${{ env.PATH }};${{ github.workspace }}\build\_deps\catch2-build\src\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\build\${{ matrix.config.BUILD_TYPE }}
-        run: |
-          build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe

.gitignore

@@ -72,12 +72,9 @@ install_manifest.txt
 /tests/logs/*
 spdlogConfig.cmake
 spdlogConfigVersion.cmake
-compile_commands.json
 
 # idea
 .idea/
-.cache/
-.vscode/
 cmake-build-*/
 *.db
 *.ipch
@@ -93,6 +90,3 @@ cmake-build-*/
 # macos
 *.DS_store
 *.xcodeproj/
-/.vs
-/out/build
-/CMakeSettings.json

CMakeLists.txt

@@ -18,39 +18,40 @@ include(GNUInstallDirs)
 # ---------------------------------------------------------------------------------------
 # Set default build to release
 # ---------------------------------------------------------------------------------------
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif ()
+endif()
 
 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_USE_STD_FORMAT)
+if(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 20)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-elseif (NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 11)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif ()
+endif()
 
+# make sure __cplusplus is defined when using msvc and enable parallel build
+if(MSVC)
+    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus /MP")
+endif()
 
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS" OR CMAKE_SYSTEM_NAME MATCHES "MINGW")
+if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
     set(CMAKE_CXX_EXTENSIONS ON)
-endif ()
+endif()
 
 # ---------------------------------------------------------------------------------------
 # 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(NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
         set(SPDLOG_MASTER_PROJECT ON)
-    else ()
+    else()
         set(SPDLOG_MASTER_PROJECT OFF)
-    endif ()
+    endif()
-endif ()
+endif()
 
 option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)
 
@@ -76,54 +77,43 @@ option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/
 
 # sanitizer options
 option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
-option(SPDLOG_SANITIZE_THREAD "Enable thread sanitizer in tests" OFF)
-if (SPDLOG_SANITIZE_ADDRESS AND SPDLOG_SANITIZE_THREAD)
-    message(FATAL_ERROR "SPDLOG_SANITIZE_ADDRESS and SPDLOG_SANITIZE_THREAD are mutually exclusive")
-endif ()
 
 # warning options
 option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
 
 # install options
-option(SPDLOG_SYSTEM_INCLUDES "Include as system headers (skip for clang-tidy)." OFF)
 option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_USE_STD_FORMAT "Use std::format instead of fmt library." OFF)
+option(SPDLOG_USE_STD_FORMAT "Use std::format instead of fmt library. No compile-time format string checking." OFF)
 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)
+if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
     message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()
 
-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
     message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif ()
+endif()
 
-if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
+if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
     message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
-endif ()
+endif()
 
 # misc tweakme options
-if (WIN32)
+if(WIN32)
     option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
     option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-    option(SPDLOG_WCHAR_CONSOLE "Support wchar output to console" OFF)
+else()
-else ()
     set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
     set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
-    set(SPDLOG_WCHAR_CONSOLE OFF CACHE BOOL "non supported option" FORCE)
+endif()
-endif ()
 
-if (MSVC)
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    option(SPDLOG_MSVC_UTF8 "Enable/disable msvc /utf-8 flag required by fmt lib" ON)
-endif ()
-
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-else ()
+else()
     set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
-endif ()
+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)
@@ -133,20 +123,21 @@ option(
     "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)
-option(SPDLOG_FWRITE_UNLOCKED "Use the unlocked variant of fwrite. Leave this on unless your libc doesn't have it" ON)
 
 # clang-tidy
-option(SPDLOG_TIDY "run clang-tidy" OFF)
+if(${CMAKE_VERSION} VERSION_GREATER "3.5")
+    option(SPDLOG_TIDY "run clang-tidy" OFF)
+endif()
 
-if (SPDLOG_TIDY)
+if(SPDLOG_TIDY)
     set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
     set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
     message(STATUS "Enabled clang-tidy")
-endif ()
+endif()
 
-if (SPDLOG_BUILD_PIC)
+if(SPDLOG_BUILD_PIC)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
+endif()
 
 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
@@ -155,56 +146,43 @@ message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
 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_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
     list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
-endif ()
+endif()
 
-if (SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
+if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
-    if (WIN32)
+    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 ()
+    endif()
     add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
     target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    if(MSVC)
         target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
                                              /wd4275>)
-    endif ()
+    endif()
-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PRIVATE FMT_LIB_EXPORT PUBLIC FMT_SHARED)
+        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
-    endif ()
+    endif()
-else ()
+else()
     add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif ()
+endif()
 
 add_library(spdlog::spdlog ALIAS spdlog)
 
-set(SPDLOG_INCLUDES_LEVEL "")
-if (SPDLOG_SYSTEM_INCLUDES)
-    set(SPDLOG_INCLUDES_LEVEL "SYSTEM")
-endif ()
-
 target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
-target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+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)
 
-set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
+set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
-        ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
 set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
 
-if (COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
+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 ()
+endif()
-
-# sanitizer support
-if (SPDLOG_SANITIZE_ADDRESS)
-    spdlog_enable_addr_sanitizer(spdlog)
-elseif (SPDLOG_SANITIZE_THREAD)
-    spdlog_enable_thread_sanitizer(spdlog)
-endif ()
 
 # ---------------------------------------------------------------------------------------
 # Header only version
@@ -212,66 +190,47 @@ endif ()
 add_library(spdlog_header_only INTERFACE)
 add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
 
-target_include_directories(
+target_include_directories(spdlog_header_only INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-        spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} 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(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if (NOT TARGET fmt::fmt)
+    if(NOT TARGET fmt::fmt)
         find_package(fmt CONFIG REQUIRED)
-    endif ()
+    endif()
     target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
 
-    # use external fmt-header-only
+    # use external fmt-header-nly
-    if (SPDLOG_FMT_EXTERNAL_HO)
+    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
+    else() # use external compile fmt
         target_link_libraries(spdlog PUBLIC fmt::fmt)
         target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif ()
+    endif()
 
     set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif ()
+endif()
-
-# ---------------------------------------------------------------------------------------
-# Check if fwrite_unlocked/_fwrite_nolock is available
-# ---------------------------------------------------------------------------------------
-if (SPDLOG_FWRITE_UNLOCKED)
-    include(CheckSymbolExists)
-    if (WIN32)
-        check_symbol_exists(_fwrite_nolock "stdio.h" HAVE_FWRITE_UNLOCKED)
-    else ()
-        check_symbol_exists(fwrite_unlocked "stdio.h" HAVE_FWRITE_UNLOCKED)
-    endif ()
-    if (HAVE_FWRITE_UNLOCKED)
-        target_compile_definitions(spdlog PRIVATE SPDLOG_FWRITE_UNLOCKED)
-        target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FWRITE_UNLOCKED)
-    endif ()
-endif ()
 
 # ---------------------------------------------------------------------------------------
 # Add required libraries for Android CMake build
 # ---------------------------------------------------------------------------------------
-if (ANDROID)
+if(ANDROID)
     target_link_libraries(spdlog PUBLIC log)
     target_link_libraries(spdlog_header_only INTERFACE log)
-endif ()
+endif()
 
 # ---------------------------------------------------------------------------------------
 # Misc definitions according to tweak options
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
-set(SPDLOG_UTF8_TO_WCHAR_CONSOLE ${SPDLOG_WCHAR_CONSOLE})
+foreach(
-foreach (
     SPDLOG_OPTION
     SPDLOG_WCHAR_TO_UTF8_SUPPORT
-        SPDLOG_UTF8_TO_WCHAR_CONSOLE
     SPDLOG_WCHAR_FILENAMES
     SPDLOG_NO_EXCEPTIONS
     SPDLOG_CLOCK_COARSE
@@ -281,65 +240,48 @@ foreach (
     SPDLOG_NO_ATOMIC_LEVELS
     SPDLOG_DISABLE_DEFAULT_LOGGER
     SPDLOG_USE_STD_FORMAT)
-    if (${SPDLOG_OPTION})
+    if(${SPDLOG_OPTION})
         target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
         target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
-    endif ()
+    endif()
-endforeach ()
+endforeach()
 
-if (MSVC)
+if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
-    target_compile_options(spdlog PRIVATE "/Zc:__cplusplus")
-    target_compile_options(spdlog_header_only INTERFACE "/Zc:__cplusplus")
-    if (SPDLOG_MSVC_UTF8)
-        # fmtlib requires the /utf-8 flag when building with msvc.
-        # see https://github.com/fmtlib/fmt/pull/4159 on the purpose of the additional
-        # "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>"
-        target_compile_options(spdlog PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-        target_compile_options(spdlog_header_only INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
-    endif ()
-endif ()
-
-# ---------------------------------------------------------------------------------------
-# If exceptions are disabled, disable them in the bundled fmt as well
-# ---------------------------------------------------------------------------------------
-if (SPDLOG_NO_EXCEPTIONS)
-    if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PUBLIC FMT_USE_EXCEPTIONS=0)
-    endif ()
-    if (NOT MSVC)
     target_compile_options(spdlog PRIVATE -fno-exceptions)
-    else ()
+endif()
-        target_compile_options(spdlog PRIVATE /EHs-c-)
+
-        target_compile_definitions(spdlog PRIVATE _HAS_EXCEPTIONS=0)
+if(SPDLOG_USE_STD_FORMAT)
-    endif ()
+    set(CMAKE_CXX_STANDARD 20)
-endif ()
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
 # ---------------------------------------------------------------------------------------
 # Build binaries
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+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)
+    if(SPDLOG_BUILD_EXAMPLE_HO)
         spdlog_enable_warnings(example_header_only)
-    endif ()
+    endif()
-endif ()
+endif()
 
-if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
     message(STATUS "Generating tests")
     enable_testing()
     add_subdirectory(tests)
-endif ()
+endif()
 
-if (SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
     message(STATUS "Generating benchmarks")
     add_subdirectory(bench)
-endif ()
+endif()
 
 # ---------------------------------------------------------------------------------------
 # Install
 # ---------------------------------------------------------------------------------------
-if (SPDLOG_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")
@@ -360,24 +302,24 @@ if (SPDLOG_INSTALL)
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-    if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if(NOT SPDLOG_USE_STD_FORMAT AND 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 ()
+    endif()
 
     # ---------------------------------------------------------------------------------------
     # Install pkg-config file
     # ---------------------------------------------------------------------------------------
     if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
         set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
-    else ()
+    else()
         set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-    endif ()
+    endif()
     if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
         set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
-    else ()
+    else()
         set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-    endif ()
+    endif()
     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}")
@@ -387,12 +329,15 @@ if (SPDLOG_INSTALL)
     # ---------------------------------------------------------------------------------------
     # Install CMake config files
     # ---------------------------------------------------------------------------------------
-    export(TARGETS spdlog spdlog_header_only NAMESPACE spdlog::
+    export(
+      TARGETS spdlog
+      NAMESPACE spdlog::
       FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
     install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})
 
     include(CMakePackageConfigHelpers)
-    configure_package_config_file("${project_config_in}" "${project_config_out}" INSTALL_DESTINATION ${export_dest_dir})
+    configure_package_config_file("${project_config_in}" "${project_config_out}"
+        INSTALL_DESTINATION ${export_dest_dir})
 
     write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
     install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}")
@@ -401,4 +346,4 @@ if (SPDLOG_INSTALL)
     # Support creation of installable packages
     # ---------------------------------------------------------------------------------------
     include(cmake/spdlogCPack.cmake)
-endif ()
+endif()

INSTALL

@@ -1,27 +1,24 @@
-Header Only Version
+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
+
+Compiled library version:
 ==================================================================
 CMake:
-```  
   add_executable(example example.cpp)
   target_link_libraries(example spdlog::spdlog)
-```
 
-Or copy files src/*.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
+Or copy src/spdlog.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
-
-Important Information for Compilation:
-==================================================================
-* If you encounter compilation errors with gcc 4.8.x, please note that gcc 4.8.x does not fully support C++11. In such cases, consider upgrading your compiler or using a different version that fully supports C++11 standards
 
 Tested on:
 gcc 4.8.1 and above
 clang 3.5
 Visual Studio 2013
+
+
+
+

LICENSE

@@ -22,5 +22,5 @@ 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://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
+and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
 

README.md

@@ -1,31 +1,25 @@
 # spdlog
 
- 
+Very fast, header-only/compiled, C++ logging library. [![ci](https://github.com/gabime/spdlog/actions/workflows/ci.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/ci.yml)  [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
-[![ci](https://github.com/gabime/spdlog/actions/workflows/linux.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/linux.yml) 
-[![ci](https://github.com/gabime/spdlog/actions/workflows/windows.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/windows.yml) 
-[![ci](https://github.com/gabime/spdlog/actions/workflows/macos.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/macos.yml) 
-[![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
-
-Fast C++ logging library
-
 
 ## Install 
-#### Header-only version
+#### Header only version
-Copy the include [folder](include/spdlog) to your build tree and use a C++11 compiler.
+Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
 
 #### Compiled version (recommended - much faster compile times)
 ```console
 $ git clone https://github.com/gabime/spdlog.git
 $ cd spdlog && mkdir build && cd build
-$ cmake .. && cmake --build .
+$ cmake .. && make -j
 ```
-see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
+      
+   see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
 
 ## Platforms
-* Linux, FreeBSD, OpenBSD, Solaris, AIX
+ * Linux, FreeBSD, OpenBSD, Solaris, AIX
-* Windows (msvc 2013+, cygwin)
+ * Windows (msvc 2013+, cygwin)
-* macOS (clang 3.5+)
+ * macOS (clang 3.5+)
-* Android
+ * Android
 
 ## Package managers:
 * Debian: `sudo apt install libspdlog-dev`
@@ -36,9 +30,8 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
 * Gentoo: `emerge dev-libs/spdlog`
 * Arch Linux: `pacman -S spdlog`
 * openSUSE: `sudo zypper in spdlog-devel`
-* ALT Linux: `apt-get install libspdlog-devel`
 * vcpkg: `vcpkg install spdlog`
-* conan: `conan install --requires=spdlog/[*]`
+* conan: `spdlog/[>=1.4.1]`
 * conda: `conda install -c conda-forge spdlog`
 * build2: ```depends: spdlog ^1.8.2```
 
@@ -46,9 +39,9 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
 ## Features
 * Very fast (see [benchmarks](#benchmarks) below).
 * Headers only or compiled
-* Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
+* Feature rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Asynchronous mode (optional)
-* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
+* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Multi/Single threaded loggers.
 * Various log targets:
     * Rotating log files.
@@ -57,11 +50,10 @@ see example [CMakeLists.txt](example/CMakeLists.txt) on how to use.
     * syslog.
     * Windows event log.
     * Windows debugger (```OutputDebugString(..)```).
-  * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).
+    * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
-  * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets.
+* Log filtering - log levels can be modified in runtime as well as in compile time.
-* Log filtering - log levels can be modified at runtime as well as compile time.
+* Support for loading log levels from argv or from environment var.
-* Support for loading log levels from argv or environment var.
+* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display later on demand.
-* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
  
 ## Usage samples
 
@@ -87,8 +79,7 @@ int main()
     spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
     
     // Compile time log levels
-    // Note that this does not change the current log level, it will only
+    // define SPDLOG_ACTIVE_LEVEL to desired level
-    // remove (depending on SPDLOG_ACTIVE_LEVEL) the call on the release code.
     SPDLOG_TRACE("Some trace message with param {}", 42);
     SPDLOG_DEBUG("Some debug message");
 }
@@ -101,7 +92,7 @@ int main()
 #include "spdlog/sinks/stdout_color_sinks.h"
 void stdout_example()
 {
-    // create a color multi-threaded logger
+    // create color multi threaded logger
     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)");
@@ -130,7 +121,7 @@ void basic_logfile_example()
 #include "spdlog/sinks/rotating_file_sink.h"
 void rotating_example()
 {
-    // Create a file rotating logger with 5 MB size max and 3 rotated files
+    // Create a file rotating logger with 5mb size max and 3 rotated files
     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);
@@ -144,7 +135,7 @@ void rotating_example()
 #include "spdlog/sinks/daily_file_sink.h"
 void daily_example()
 {
-    // Create a daily logger - a new file is created every day at 2:30 am
+    // Create a daily logger - a new file is created every day on 2:30am
     auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
 }
 
@@ -154,10 +145,10 @@ void daily_example()
 #### Backtrace support
 ```c++
 // Debug messages can be stored in a ring buffer instead of being logged immediately.
-// This is useful to display debug logs only when needed (e.g. when an error happens).
+// This is useful in order to display debug logs only when really needed (e.g. when error happens).
-// When needed, call dump_backtrace() to dump them to your log.
+// When needed, call dump_backtrace() to see them.
 
-spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. 
+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++)
 {
@@ -165,6 +156,7 @@ for(int i = 0; i < 100; i++)
 }
 // e.g. if some error happened:
 spdlog::dump_backtrace(); // log them now! show the last 32 messages
+
 // or my_logger->dump_backtrace(32)..
 ```
 
@@ -172,7 +164,7 @@ spdlog::dump_backtrace(); // log them now! show the last 32 messages
 #### Periodic flush
 ```c++
 // periodically flush all *registered* loggers every 3 seconds:
-// warning: only use if all your loggers are thread-safe ("_mt" loggers)
+// warning: only use if all your loggers are thread safe ("_mt" loggers)
 spdlog::flush_every(std::chrono::seconds(3));
 
 ```
@@ -200,7 +192,7 @@ void stopwatch_example()
 // {: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 into lines.
+// {:n} - don't split the output to lines.
 // {:a} - show ASCII if :n is not set.
 
 #include "spdlog/fmt/bin_to_hex.h"
@@ -220,11 +212,11 @@ void binary_example()
 ```
 
 ---
-#### Logger with multi sinks - each with a different format and log level
+#### Logger with multi sinks - each with different format and log level
 ```c++
 
-// create a logger with 2 targets, with different log levels and formats.
+// 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.
+// the console will show only warnings or errors, while the file will log all.
 void multi_sink_example()
 {
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
@@ -241,27 +233,6 @@ void multi_sink_example()
 }
 ```
 
----
-#### User-defined callbacks about log events
-```c++
-
-// create a logger with a lambda function callback, the callback will be called
-// each time something is logged to the logger
-void callback_example()
-{
-    auto callback_sink = std::make_shared<spdlog::sinks::callback_sink_mt>([](const spdlog::details::log_msg &msg) {
-         // for example you can be notified by sending an email to yourself
-    });
-    callback_sink->set_level(spdlog::level::err);
-
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    spdlog::logger logger("custom_callback_logger", {console_sink, callback_sink});
-
-    logger.info("some info log");
-    logger.error("critical issue"); // will notify you
-}
-```
-
 ---
 #### Asynchronous logging
 ```c++
@@ -281,7 +252,6 @@ void async_example()
 ---
 #### Asynchronous logger with multi sinks  
 ```c++
-#include "spdlog/async.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 #include "spdlog/sinks/rotating_file_sink.h"
 
@@ -297,14 +267,14 @@ void multi_sink_example2()
 ```
  
 ---
-#### User-defined types
+#### User defined types
 ```c++
 template<>
 struct fmt::formatter<my_type> : fmt::formatter<std::string>
 {
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
     {
-        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
     }
 };
 
@@ -316,7 +286,7 @@ void user_defined_example()
 ```
 
 ---
-#### User-defined flags in the log pattern
+#### 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.
@@ -381,17 +351,14 @@ void android_example()
 ```
 
 ---
-#### Load log levels from the env variable or argv
+#### 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 specify the env variable name:
+    // or from command line:
-    // MYAPP_LEVEL=info,mylogger=trace && ./example
-    // spdlog::cfg::load_env_levels("MYAPP_LEVEL");
-    // or from the 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);
@@ -408,8 +375,8 @@ $ ./example
 ---
 #### Log file open/close event handlers
 ```c++
-// You can get callbacks from spdlog before/after a log file has been opened or closed. 
+// You can get callbacks from spdlog before/after log file has been opened or closed. 
-// This is useful for cleanup procedures or for adding something to the start/end of the log file.
+// This is useful for cleanup procedures or for adding someting the start/end of the log files.
 void file_events_example()
 {
     // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
@@ -433,41 +400,10 @@ void replace_default_logger_example()
 }
 ```
 
----
-#### Log to Qt with nice colors
-```c++
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/qt_sinks.h"
-MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
-{
-    setMinimumSize(640, 480);
-    auto log_widget = new QTextEdit(this);
-    setCentralWidget(log_widget);
-    int max_lines = 500; // keep the text widget to max 500 lines. remove old lines if needed.
-    auto logger = spdlog::qt_color_logger_mt("qt_logger", log_widget, max_lines);
-    logger->info("Some info message");
-}
-```
----
-
-#### Mapped Diagnostic Context
-```c++
-// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.
-// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.
-// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.
-#include "spdlog/mdc.h"
-void mdc_example()
-{
-    spdlog::mdc::put("key1", "value1");
-    spdlog::mdc::put("key2", "value2");
-    // if not using the default format, use the %& formatter to print mdc data
-    // spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [%&] %v");
-}
-```
 ---
 ## Benchmarks
 
-Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+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
 ```
@@ -519,8 +455,7 @@ Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-477
 ```
 
 ## Documentation
-
+Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
-Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages.
 
 ---
 

appveyor.yml

@@ -2,6 +2,42 @@ version: 1.0.{build}
 image: Visual Studio 2017
 environment:
   matrix:
+    - GENERATOR: '"Visual Studio 14 2015"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 14 2015"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 14 2015 Win64"'
+      BUILD_TYPE: Debug
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
+    - GENERATOR: '"Visual Studio 14 2015 Win64"'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
     - GENERATOR: '"Visual Studio 15 2017 Win64"'
       BUILD_TYPE: Debug
       BUILD_SHARED: 'OFF'
@@ -56,7 +92,7 @@ environment:
       WCHAR_FILES: 'OFF'
       BUILD_EXAMPLE: 'OFF'
       USE_STD_FORMAT: 'ON'
-      CXX_STANDARD: 20
+      CXX_STANDARD: 23 # std::format is only available with /std:c++latest at the moment.
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
     - GENERATOR: '"Visual Studio 17 2022" -A x64'
       BUILD_TYPE: Release
@@ -66,7 +102,7 @@ environment:
       WCHAR_FILES: 'ON'
       BUILD_EXAMPLE: 'OFF'
       USE_STD_FORMAT: 'ON'
-      CXX_STANDARD: 20
+      CXX_STANDARD: 23 # std::format is only available with /std:c++latest at the moment.
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
 build_script:
   - cmd: >-
@@ -83,7 +119,7 @@ build_script:
       cmake --build . --config %BUILD_TYPE%
 
 before_test:
-  - set PATH=%PATH%;C:\projects\spdlog\build\_deps\catch2-build\src\%BUILD_TYPE%;C:\projects\spdlog\build\%BUILD_TYPE%
+  - 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,6 +1,6 @@
 # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.10)
 project(spdlog_bench CXX)
 
 if(NOT TARGET spdlog)
@@ -12,6 +12,7 @@ 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)
@@ -21,6 +22,9 @@ if(NOT benchmark_FOUND)
         # Do not build and run googlebenchmark tests
         FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0)
         FetchContent_MakeAvailable(googlebenchmark)
+    else()
+        message(FATAL_ERROR "GoogleBenchmark is missing. Use CMake >= 3.11 or download it")
+    endif()
 endif()
 
 add_executable(bench bench.cpp)

bench/async_bench.cpp

@@ -11,11 +11,11 @@
 #include "spdlog/sinks/basic_file_sink.h"
 
 #if defined(SPDLOG_USE_STD_FORMAT)
-    #include <format>
+#    include <format>
 #elif defined(SPDLOG_FMT_EXTERNAL)
-    #include <fmt/format.h>
+#    include <fmt/format.h>
 #else
-    #include "spdlog/fmt/bundled/format.h"
+#    include "spdlog/fmt/bundled/format.h"
 #endif
 
 #include "utils.h"
@@ -34,69 +34,81 @@ 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(push)
-    #pragma warning(disable : 4996)  // disable fopen warning under msvc
+#    pragma warning(disable : 4996) // disable fopen warning under msvc
 #endif                              // _MSC_VER
 
-int count_lines(const char *filename) {
+int count_lines(const char *filename)
+{
     int counter = 0;
     auto *infile = fopen(filename, "r");
     int ch;
-    while (EOF != (ch = getc(infile))) {
+    while (EOF != (ch = getc(infile)))
-        if ('\n' == ch) counter++;
+    {
+        if ('\n' == ch)
+            counter++;
     }
     fclose(infile);
 
     return counter;
 }
 
-void verify_file(const char *filename, int expected_count) {
+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) {
+    if (count != expected_count)
-        spdlog::error("Test failed. {} has {} lines instead of {}", filename, 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)
+#    pragma warning(pop)
 #endif
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
+
     int howmany = 1000000;
     int queue_size = std::min(howmany + 2, 8192);
     int threads = 10;
     int iters = 3;
 
-    try {
+    try
+    {
         spdlog::set_pattern("[%^%l%$] %v");
-        if (argc == 1) {
+        if (argc == 1)
+        {
             spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
             return 0;
         }
 
-        if (argc > 1) howmany = atoi(argv[1]);
+        if (argc > 1)
-        if (argc > 2) threads = atoi(argv[2]);
+            howmany = atoi(argv[1]);
-        if (argc > 3) {
+        if (argc > 2)
+            threads = atoi(argv[2]);
+        if (argc > 3)
+        {
             queue_size = atoi(argv[3]);
-            if (queue_size > 500000) {
+            if (queue_size > 500000)
+            {
                 spdlog::error("Max queue size allowed: 500,000");
                 exit(1);
             }
         }
 
-        if (argc > 4) iters = atoi(argv[4]);
+        if (argc > 4)
+            iters = atoi(argv[4]);
 
         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,
+        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
-                     (queue_size * slot_size) / 1024);
         spdlog::info("Total iters  : {:L}", iters);
         spdlog::info("-------------------------------------------------");
 
@@ -105,11 +117,11 @@ int main(int argc, char *argv[]) {
         spdlog::info("*********************************");
         spdlog::info("Queue Overflow Policy: block");
         spdlog::info("*********************************");
-        for (int i = 0; i < iters; i++) {
+        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>(
+            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
-                "async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
             bench_mt(howmany, std::move(logger), threads);
             // verify_file(filename, howmany);
         }
@@ -120,16 +132,18 @@ int main(int argc, char *argv[]) {
         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++) {
+        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),
+                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::overrun_oldest);
-                                               async_overflow_policy::overrun_oldest);
             bench_mt(howmany, std::move(logger), threads);
         }
         spdlog::shutdown();
-    } catch (std::exception &ex) {
+    }
+    catch (std::exception &ex)
+    {
         std::cerr << "Error: " << ex.what() << std::endl;
         perror("Last error");
         return 1;
@@ -137,30 +151,34 @@ int main(int argc, char *argv[]) {
     return 0;
 }
 
-void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany) {
+void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany)
-    for (int i = 0; i < howmany; i++) {
+{
+    for (int i = 0; i < howmany; i++)
+    {
         logger->info("Hello logger: msg number {}", i);
     }
 }
 
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count) {
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count)
+{
     using std::chrono::high_resolution_clock;
     vector<std::thread> threads;
     auto start = high_resolution_clock::now();
 
     int msgs_per_thread = howmany / thread_count;
     int msgs_per_thread_mod = howmany % thread_count;
-    for (int t = 0; t < thread_count; ++t) {
+    for (int t = 0; t < thread_count; ++t)
+    {
         if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(
+            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
-                std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
         else
             threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
     }
 
-    for (auto &t : threads) {
+    for (auto &t : threads)
+    {
         t.join();
-    }
+    };
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();

bench/bench.cpp

@@ -13,11 +13,11 @@
 #include "spdlog/sinks/rotating_file_sink.h"
 
 #if defined(SPDLOG_USE_STD_FORMAT)
-    #include <format>
+#    include <format>
 #elif defined(SPDLOG_FMT_EXTERNAL)
-    #include <fmt/format.h>
+#    include <fmt/locale.h>
 #else
-    #include "spdlog/fmt/bundled/format.h"
+#    include "spdlog/fmt/bundled/format.h"
 #endif
 
 #include "utils.h"
@@ -37,25 +37,22 @@ 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) {
+void bench_threaded_logging(size_t threads, int iters)
+{
     spdlog::info("**************************************************************");
-    spdlog::info(spdlog::fmt_lib::format(
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
-        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 =
+    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
-        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,
+    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
-                                                  rotating_files);
     bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt(
+    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
-        "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);
 
@@ -76,25 +73,22 @@ void bench_threaded_logging(size_t threads, int iters) {
     bench(iters, empty_logger_tracing);
 }
 
-void bench_single_threaded(int iters) {
+void bench_single_threaded(int iters)
+{
     spdlog::info("**************************************************************");
-    spdlog::info(
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
-        spdlog::fmt_lib::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 =
+    auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
-        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,
+    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
-                                                  rotating_files);
     bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st(
+    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
-        "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));
 
@@ -116,54 +110,63 @@ void bench_single_threaded(int iters) {
     bench(iters, empty_logger_tracing);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     spdlog::set_automatic_registration(false);
     spdlog::default_logger()->set_pattern("[%^%l%$] %v");
     int iters = 250000;
     size_t threads = 4;
-    try {
+    try
-        if (argc > 1) {
+    {
+
+        if (argc > 1)
+        {
             iters = std::stoi(argv[1]);
         }
-        if (argc > 2) {
+        if (argc > 2)
+        {
             threads = std::stoul(argv[2]);
         }
 
-        if (threads > max_threads) {
+        if (threads > max_threads)
-            throw std::runtime_error(
+        {
-                spdlog::fmt_lib::format("Number of threads exceeds maximum({})", max_threads));
+            throw std::runtime_error(spdlog::fmt_lib::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) {
+    }
+    catch (std::exception &ex)
+    {
         spdlog::error(ex.what());
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
-void bench(int howmany, std::shared_ptr<spdlog::logger> log) {
+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;
 
     auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i) {
+    for (auto i = 0; i < howmany; ++i)
+    {
         log->info("Hello logger: msg number {}", i);
     }
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
 
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
+    spdlog::info(spdlog::fmt_lib::format(
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
+        std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
-                                         delta_d, size_t(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t 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;
@@ -171,23 +174,25 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_co
     std::vector<std::thread> threads;
     threads.reserve(thread_count);
     auto start = high_resolution_clock::now();
-    for (size_t t = 0; t < thread_count; ++t) {
+    for (size_t t = 0; t < thread_count; ++t)
+    {
         threads.emplace_back([&]() {
-            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++) {
+            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++)
+            {
                 log->info("Hello logger: msg number {}", j);
             }
         });
     }
 
-    for (auto &t : threads) {
+    for (auto &t : threads)
+    {
         t.join();
-    }
+    };
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
+    spdlog::info(spdlog::fmt_lib::format(
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
+        std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
-                                         delta_d, size_t(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 
@@ -210,8 +215,7 @@ void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
     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 /
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
-delta_d));
 }
 
 void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
@@ -220,12 +224,11 @@ void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
     using std::chrono::duration;
     using std::chrono::duration_cast;
 
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-metus cursus " "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
-volutpat mi, eu consequat sem " "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
-non dapibus eros. Donec fringilla dui sed " "augue pretium, nec scelerisque est maximus. Nullam
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
-convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
 
     auto orig_default = spdlog::default_logger();
     spdlog::set_default_logger(log);
@@ -239,8 +242,7 @@ odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
     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 /
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / delta_d));
-delta_d));
 }
 
 */

bench/formatter-bench.cpp

@@ -8,28 +8,31 @@
 #include "spdlog/spdlog.h"
 #include "spdlog/pattern_formatter.h"
 
-void bench_formatter(benchmark::State &state, std::string pattern) {
+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 =
+    const char *text = "Hello. This is some message with length of 80                                   ";
-        "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) {
+    for (auto _ : state)
+    {
         dest.clear();
         formatter->format(msg, dest);
         benchmark::DoNotOptimize(dest);
     }
 }
 
-void bench_formatters() {
+void bench_formatters()
+{
     // basic patterns(single flag)
     std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
     std::vector<std::string> basic_patterns;
-    for (auto &flag : all_flags) {
+    for (auto &flag : all_flags)
+    {
         auto pattern = std::string("%") + flag;
         benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
 
@@ -47,23 +50,29 @@ void bench_formatters() {
         "[%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) {
+    for (auto &pattern : patterns)
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)
+    {
-            ->Iterations(2500000);
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)->Iterations(2500000);
     }
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
+
     spdlog::set_pattern("[%^%l%$] %v");
-    if (argc != 2) {
+    if (argc != 2)
+    {
         spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
         exit(1);
     }
 
     std::string pattern = argv[1];
-    if (pattern == "all") {
+    if (pattern == "all")
+    {
         bench_formatters();
-    } else {
+    }
+    else
+    {
         benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
     }
     benchmark::Initialize(&argc, argv);

bench/latency.cpp

@@ -16,72 +16,65 @@
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
 
-void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
+void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-    const char *msg =
+{
-        "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+    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, "
+                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
-        "eu consequat sem "
+                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
-        "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec "
+                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
-        "fringilla dui sed "
+                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-        "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.";
 
-    for (auto _ : state) {
+    for (auto _ : state)
+    {
         logger->info(msg);
     }
 }
 
-void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
+void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
     int i = 0;
-    for (auto _ : state) {
+    for (auto _ : state)
+    {
         logger->info("Hello logger: msg number {}...............", ++i);
     }
 }
-void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
+
-    spdlog::set_default_logger(std::move(logger));
+void bench_logger_fmt_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+{
     int i = 0;
-    for (auto _ : state) {
+    for (auto _ : state)
-        spdlog::info("Hello logger: msg number {}...............", ++i);
+    {
+        logger->info(FMT_STRING("Hello logger: msg number {}..............."), ++i);
     }
 }
 
-void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
+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) {
+    for (auto _ : state)
+    {
         SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
-    }
-}
-
-void bench_disabled_macro_global_logger(benchmark::State &state,
-                                        std::shared_ptr<spdlog::logger> logger) {
-    spdlog::set_default_logger(std::move(logger));
-    int i = 0;
-    benchmark::DoNotOptimize(i);       // prevent unused warnings
-    benchmark::DoNotOptimize(logger);  // prevent unused warnings
-    for (auto _ : state) {
         SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
     }
 }
 
 #ifdef __linux__
-void bench_dev_null() {
+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))
+    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
-        ->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))
+    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
-        ->UseRealTime();
     spdlog::drop("/dev/null_mt");
 }
 #endif // __linux__
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     using spdlog::sinks::null_sink_mt;
     using spdlog::sinks::null_sink_st;
 
@@ -92,108 +85,77 @@ int main(int argc, char *argv[]) {
     auto full_bench = argc > 1 && std::string(argv[1]) == "full";
 
     // disabled loggers
-    auto disabled_logger =
+    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        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-compile-time (global logger)",
-                                 bench_disabled_macro_global_logger, disabled_logger);
     benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime (global logger)", bench_global_logger,
-                                 disabled_logger);
     // with backtrace of 64
-    auto tracing_disabled_logger =
+    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        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,
+    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
-                                 tracing_disabled_logger);
 
-    auto null_logger_st =
+    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_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 (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_st (global logger)", bench_global_logger,
+    benchmark::RegisterBenchmark("null_sink_FMT_STRING", bench_logger_fmt_string, null_logger_st);
-                                 null_logger_st);
     // with backtrace of 64
-    auto tracing_null_logger_st =
+    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_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__
+#ifdef __linux
     bench_dev_null();
 #endif // __linux__
 
-    if (full_bench) {
+    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 =
+        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-            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,
+        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
-                                     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",
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
-                                                      file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
-        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(
+        auto tracing_rotating_st =
-            "tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size,
+            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
-            rotating_files);
+        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
-        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 =
+        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-            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();
-        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 =
+        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_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();
-        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))
+        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
-            ->Threads(n_threads)
-            ->UseRealTime();
         spdlog::drop("basic_mt");
 
         // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log",
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
-                                                      file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
-        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))
+        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
-            ->Threads(n_threads)
-            ->UseRealTime();
         spdlog::drop("daily_mt");
     }
 
@@ -201,19 +163,13 @@ int main(int argc, char *argv[]) {
     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),
+        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-        spdlog::async_overflow_policy::overrun_oldest);
+    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)
-        ->Threads(n_threads)
-        ->UseRealTime();
 
     auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
-        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp),
+        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-        spdlog::async_overflow_policy::overrun_oldest);
     async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)
+    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
-        ->Threads(n_threads)
-        ->UseRealTime();
 
     benchmark::Initialize(&argc, argv);
     benchmark::RunSpecifiedBenchmarks();

bench/utils.h

@@ -11,8 +11,9 @@
 
 namespace utils {
 
-template <typename T>
+template<typename T>
-inline std::string format(const T &value) {
+inline std::string format(const T &value)
+{
     static std::locale loc("");
     std::stringstream ss;
     ss.imbue(loc);
@@ -20,8 +21,9 @@ inline std::string format(const T &value) {
     return ss.str();
 }
 
-template <>
+template<>
-inline std::string format(const double &value) {
+inline std::string format(const double &value)
+{
     static std::locale loc("");
     std::stringstream ss;
     ss.imbue(loc);

cmake/utils.cmake

@@ -49,7 +49,7 @@ function(spdlog_enable_warnings target_name)
 endfunction()
 
 # Enable address sanitizer (gcc/clang only)
-function(spdlog_enable_addr_sanitizer target_name)
+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()
@@ -58,16 +58,5 @@ function(spdlog_enable_addr_sanitizer target_name)
     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)
+    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
-endfunction()
-
-# Enable thread sanitizer (gcc/clang only)
-function(spdlog_enable_thread_sanitizer target_name)
-    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
-    endif()
-    message(STATUS "Thread sanitizer enabled")
-    target_compile_options(${target_name} PRIVATE -fsanitize=thread)
-    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
-    target_link_libraries(${target_name} PRIVATE -fsanitize=thread)
 endfunction()

example/CMakeLists.txt

@@ -1,6 +1,6 @@
 # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.10)
 project(spdlog_examples CXX)
 
 if(NOT TARGET spdlog)
@@ -12,7 +12,7 @@ endif()
 # Example of using pre-compiled library
 # ---------------------------------------------------------------------------------------
 add_executable(example example.cpp)
-target_link_libraries(example PRIVATE spdlog::spdlog $<$<BOOL:${MINGW}>:ws2_32>)
+target_link_libraries(example PRIVATE spdlog::spdlog)
 
 # ---------------------------------------------------------------------------------------
 # Example of using header-only library

example/example.cpp

@@ -12,7 +12,6 @@ void stdout_logger_example();
 void basic_example();
 void rotating_example();
 void daily_example();
-void callback_example();
 void async_example();
 void binary_example();
 void vector_example();
@@ -26,18 +25,17 @@ void udp_example();
 void custom_flags_example();
 void file_events_example();
 void replace_default_logger_example();
-void mdc_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 *[]) {
+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::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-                 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);
@@ -61,18 +59,19 @@ int main(int, char *[]) {
     // 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++) {
+    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 {
+    try
+    {
         stdout_logger_example();
         basic_example();
         rotating_example();
         daily_example();
-        callback_example();
         async_example();
         binary_example();
         vector_example();
@@ -85,7 +84,6 @@ int main(int, char *[]) {
         custom_flags_example();
         file_events_example();
         replace_default_logger_example();
-        mdc_example();
 
         // Flush all *registered* loggers using a worker thread every 3 seconds.
         // note: registered loggers *must* be thread safe for this to work correctly!
@@ -100,7 +98,8 @@ int main(int, char *[]) {
     }
 
     // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
-    catch (const spdlog::spdlog_ex &ex) {
+    catch (const spdlog::spdlog_ex &ex)
+    {
         std::printf("Log initialization failed: %s\n", ex.what());
         return 1;
     }
@@ -108,7 +107,8 @@ int main(int, char *[]) {
 
 #include "spdlog/sinks/stdout_color_sinks.h"
 // or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
-void stdout_logger_example() {
+void stdout_logger_example()
+{
     // Create color multi threaded logger.
     auto console = spdlog::stdout_color_mt("console");
     // or for stderr:
@@ -116,41 +116,32 @@ void stdout_logger_example() {
 }
 
 #include "spdlog/sinks/basic_file_sink.h"
-void basic_example() {
+void basic_example()
+{
     // Create basic file logger (not rotated).
     auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt", true);
 }
 
 #include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example() {
+void rotating_example()
+{
     // Create a file rotating logger with 5mb size max and 3 rotated files.
-    auto rotating_logger =
+    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-        spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
 }
 
 #include "spdlog/sinks/daily_file_sink.h"
-void daily_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);
 }
 
-#include "spdlog/sinks/callback_sink.h"
-void callback_example() {
-    // Create the logger
-    auto logger = spdlog::callback_logger_mt("custom_callback_logger",
-                                             [](const spdlog::details::log_msg & /*msg*/) {
-                                                 // do what you need to do with msg
-                                             });
-}
-
 #include "spdlog/cfg/env.h"
-void load_levels_example() {
+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 specify the env variable name:
-    // MYAPP_LEVEL=info,mylogger=trace && ./example
-    // spdlog::cfg::load_env_levels("MYAPP_LEVEL");
     // or from command line:
     // ./example SPDLOG_LEVEL=info,mylogger=trace
     // #include "spdlog/cfg/argv.h" // for loading levels from argv
@@ -158,17 +149,16 @@ void load_levels_example() {
 }
 
 #include "spdlog/async.h"
-void async_example() {
+void async_example()
+{
     // 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 =
+    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-        spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
     // alternatively:
-    // auto async_file =
+    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
-    // spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger",
-    // "logs/async_log.txt");
 
-    for (int i = 1; i < 101; ++i) {
+    for (int i = 1; i < 101; ++i)
+    {
         async_file->info("Async message #{}", i);
     }
 }
@@ -182,16 +172,16 @@ void async_example() {
 // {:p} - don't print the position on each line start.
 // {:n} - don't split the output to lines.
 
-#if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)
+#include "spdlog/fmt/bin_to_hex.h"
-    #include "spdlog/fmt/bin_to_hex.h"
+void binary_example()
-void binary_example() {
+{
-    std::vector<char> buf;
+    std::vector<char> buf(80);
-    for (int i = 0; i < 80; i++) {
+    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::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-                 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));
@@ -199,16 +189,12 @@ void binary_example() {
     // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
     // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
 }
-#else
-void binary_example() {
-    // not supported with std::format yet
-}
-#endif
 
 // Log a vector of numbers
 #ifndef SPDLOG_USE_STD_FORMAT
-    #include "spdlog/fmt/ranges.h"
+#    include "spdlog/fmt/ranges.h"
-void vector_example() {
+void vector_example()
+{
     std::vector<int> vec = {1, 2, 3};
     spdlog::info("Vector example: {}", vec);
 }
@@ -221,7 +207,8 @@ void vector_example() {}
 
 // Compile time log levels.
 // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
-void trace_example() {
+void trace_example()
+{
     // trace from default logger
     SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
     // debug from default logger
@@ -235,14 +222,16 @@ void trace_example() {
 // stopwatch example
 #include "spdlog/stopwatch.h"
 #include <thread>
-void stopwatch_example() {
+void stopwatch_example()
+{
     spdlog::stopwatch sw;
     std::this_thread::sleep_for(std::chrono::milliseconds(123));
     spdlog::info("Stopwatch: {} seconds", sw);
 }
 
 #include "spdlog/sinks/udp_sink.h"
-void udp_example() {
+void udp_example()
+{
     spdlog::sinks::udp_sink_config cfg("127.0.0.1", 11091);
     auto my_logger = spdlog::udp_logger_mt("udplog", cfg);
     my_logger->set_level(spdlog::level::debug);
@@ -250,13 +239,13 @@ void udp_example() {
 }
 
 // A logger with multiple sinks (stdout and file) - each with a different format and log level.
-void multi_sink_example() {
+void multi_sink_example()
+{
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
     console_sink->set_level(spdlog::level::warn);
     console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
 
-    auto file_sink =
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-        std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
     file_sink->set_level(spdlog::level::trace);
 
     spdlog::logger logger("multi_sink", {console_sink, file_sink});
@@ -266,43 +255,51 @@ void multi_sink_example() {
 }
 
 // User defined types logging
-struct my_type {
+struct my_type
+{
     int i = 0;
     explicit my_type(int i)
-        : i(i){}
+        : i(i){};
 };
 
 #ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib
-template <>
+template<>
-struct fmt::formatter<my_type> : fmt::formatter<std::string> {
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
+{
-        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
     }
 };
 
 #else // when using std::format
-template <>
+template<>
-struct std::formatter<my_type> : std::formatter<std::string> {
+struct std::formatter<my_type> : std::formatter<std::string>
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
+{
-        return std::format_to(ctx.out(), "[my_type i={}]", my.i);
+    auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
+    {
+        return format_to(ctx.out(), "[my_type i={}]", my.i);
     }
 };
 #endif
 
-void user_defined_example() { spdlog::info("user defined type: {}", my_type(14)); }
+void user_defined_example()
+{
+    spdlog::info("user defined type: {}", my_type(14));
+}
 
 // Custom error handler. Will be triggered on log failure.
-void err_handler_example() {
+void err_handler_example()
+{
     // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) {
+    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
-        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() {
+void syslog_example()
+{
     std::string ident = "spdlog-example";
     auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
     syslog_logger->warn("This is warning that will end up in syslog.");
@@ -311,8 +308,9 @@ void syslog_example() {
 
 // Android example.
 #if defined(__ANDROID__)
-    #include "spdlog/sinks/android_sink.h"
+#    include "spdlog/sinks/android_sink.h"
-void android_example() {
+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.");
@@ -322,34 +320,36 @@ void android_example() {
 // 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 {
+class my_formatter_flag : public spdlog::custom_flag_formatter
+{
 public:
-    void format(const spdlog::details::log_msg &,
+    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-                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 {
+    std::unique_ptr<custom_flag_formatter> clone() const override
+    {
         return spdlog::details::make_unique<my_formatter_flag>();
     }
 };
 
-void custom_flags_example() {
+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");
-    // set the new formatter using spdlog::set_formatter(formatter) or
+    // set the new formatter using spdlog::set_formatter(formatter) or logger->set_formatter(formatter)
-    // logger->set_formatter(formatter) spdlog::set_formatter(std::move(formatter));
+    // spdlog::set_formatter(std::move(formatter));
 }
 
-void file_events_example() {
+void file_events_example()
+{
     // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
     spdlog::file_event_handlers handlers;
-    handlers.before_open = [](spdlog::filename_t filename) {
+    handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); };
-        spdlog::info("Before opening {}", filename);
-    };
     handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) {
         spdlog::info("After opening {}", filename);
         fputs("After opening\n", fstream);
@@ -358,21 +358,18 @@ void file_events_example() {
         spdlog::info("Before closing {}", filename);
         fputs("Before closing\n", fstream);
     };
-    handlers.after_close = [](spdlog::filename_t filename) {
+    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
-        spdlog::info("After closing {}", filename);
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/events-sample.txt", true, handlers);
-    };
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/events-sample.txt",
-                                                                         true, handlers);
     spdlog::logger my_logger("some_logger", file_sink);
     my_logger.info("Some log line");
 }
 
-void replace_default_logger_example() {
+void replace_default_logger_example()
+{
     // store the old logger so we don't break other examples.
     auto old_logger = spdlog::default_logger();
 
-    auto new_logger =
+    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-        spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
     spdlog::set_default_logger(new_logger);
     spdlog::set_level(spdlog::level::info);
     spdlog::debug("This message should not be displayed!");
@@ -381,23 +378,3 @@ void replace_default_logger_example() {
 
     spdlog::set_default_logger(old_logger);
 }
-
-// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.
-// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.
-// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.
-
-#ifndef SPDLOG_NO_TLS
-    #include "spdlog/mdc.h"
-void mdc_example()
-{
-    spdlog::mdc::put("key1", "value1");
-    spdlog::mdc::put("key2", "value2");
-    // if not using the default format, you can use the %& formatter to print mdc data as well
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [%&] %v");
-    spdlog::info("Some log message with context");
-}
-#else
-void mdc_example() {
-    // if TLS feature is disabled
-}
-#endif

include/spdlog/async.h

@@ -18,9 +18,9 @@
 #include <spdlog/details/registry.h>
 #include <spdlog/details/thread_pool.h>
 
-#include <functional>
 #include <memory>
 #include <mutex>
+#include <functional>
 
 namespace spdlog {
 
@@ -31,10 +31,12 @@ static const size_t default_async_q_size = 8192;
 // async logger factory - creates async loggers backed with thread pool.
 // if a global thread pool doesn't already exist, create it with default queue
 // size of 8192 items and single thread.
-template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-struct async_factory_impl {
+struct async_factory_impl
-    template <typename Sink, typename... SinkArgs>
+{
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
+    template<typename Sink, typename... SinkArgs>
+    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..
@@ -42,14 +44,14 @@ struct async_factory_impl {
         auto &mutex = registry_inst.tp_mutex();
         std::lock_guard<std::recursive_mutex> tp_lock(mutex);
         auto tp = registry_inst.get_tp();
-        if (tp == nullptr) {
+        if (tp == nullptr)
+        {
             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>(std::move(logger_name), std::move(sink),
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
-                                                         std::move(tp), OverflowPolicy);
         registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
@@ -58,43 +60,40 @@ struct async_factory_impl {
 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>
+template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
-                                                    SinkArgs &&...sink_args) {
+{
-    return async_factory::create<Sink>(std::move(logger_name),
+    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
-                                       std::forward<SinkArgs>(sink_args)...);
 }
 
-template <typename Sink, typename... SinkArgs>
+template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
-                                                       SinkArgs &&...sink_args) {
+{
-    return async_factory_nonblock::create<Sink>(std::move(logger_name),
+    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
-                                                std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
-inline void init_thread_pool(size_t q_size,
+inline void init_thread_pool(
-                             size_t thread_count,
+    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
-                             std::function<void()> on_thread_start,
+{
-                             std::function<void()> on_thread_stop) {
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop);
-    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
-                                                     on_thread_stop);
     details::registry::instance().set_tp(std::move(tp));
 }
 
-inline void init_thread_pool(size_t q_size,
+inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
-                             size_t thread_count,
+{
-                             std::function<void()> on_thread_start) {
     init_thread_pool(q_size, thread_count, on_thread_start, [] {});
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count) {
+inline void init_thread_pool(size_t q_size, size_t thread_count)
+{
     init_thread_pool(
         q_size, thread_count, [] {}, [] {});
 }
 
 // get the global thread pool.
-inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
+{
     return details::registry::instance().get_tp();
 }
 } // namespace spdlog

include/spdlog/async_logger-inl.h

@@ -4,80 +4,88 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/async_logger.h>
+#    include <spdlog/async_logger.h>
 #endif
 
-#include <spdlog/details/thread_pool.h>
 #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,
+SPDLOG_INLINE spdlog::async_logger::async_logger(
-                                                 sinks_init_list sinks_list,
+    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-                                                 std::weak_ptr<details::thread_pool> tp,
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
-                                                 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,
+SPDLOG_INLINE spdlog::async_logger::async_logger(
-                                                 sink_ptr single_sink,
+    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-                                                 std::weak_ptr<details::thread_pool> tp,
+    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
-                                                 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){
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
-    SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
         pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
-}
+    }
-else {
+    else
+    {
         throw_spdlog_ex("async log: thread pool doesn't exist anymore");
-}
+    }
-}
-SPDLOG_LOGGER_CATCH(msg.source)
 }
 
 // send flush request to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::flush_(){
+SPDLOG_INLINE void spdlog::async_logger::flush_()
-    SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
         pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-}
+    }
-else {
+    else
+    {
         throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
-}
+    }
-}
-SPDLOG_LOGGER_CATCH(source_loc())
 }
 
 //
 // 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) {
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
-    for (auto &sink : sinks_) {
+{
-        if (sink->should_log(msg.level)) {
+    for (auto &sink : sinks_)
-            SPDLOG_TRY { sink->log(msg); }
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
 
-    if (should_flush_(msg)) {
+    if (should_flush_(msg))
+    {
         backend_flush_();
     }
 }
 
-SPDLOG_INLINE void spdlog::async_logger::backend_flush_() {
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
-    for (auto &sink : sinks_) {
+{
-        SPDLOG_TRY { sink->flush(); }
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }
 
-SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) {
+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

@@ -19,40 +19,34 @@
 namespace spdlog {
 
 // Async overflow policy - block by default.
-enum class async_overflow_policy {
+enum class async_overflow_policy
+{
     block,         // Block until message can be enqueued
-    overrun_oldest,  // Discard oldest message in the queue if full when trying to
+    overrun_oldest // Discard oldest message in the queue if full when trying to
                    // add new item.
-    discard_new      // Discard new message if the queue is full when trying to add new item.
 };
 
 namespace details {
 class thread_pool;
 }
 
-class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>,
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
-                                      public logger {
+{
     friend class details::thread_pool;
 
 public:
-    template <typename It>
+    template<typename It>
-    async_logger(std::string logger_name,
+    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
-                 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),
+        : logger(std::move(logger_name), begin, end)
-          thread_pool_(std::move(tp)),
+        , thread_pool_(std::move(tp))
-          overflow_policy_(overflow_policy) {}
+        , overflow_policy_(overflow_policy)
+    {}
 
-    async_logger(std::string logger_name,
+    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
-                 sinks_init_list sinks_list,
-                 std::weak_ptr<details::thread_pool> tp,
         async_overflow_policy overflow_policy = async_overflow_policy::block);
 
-    async_logger(std::string logger_name,
+    async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
-                 sink_ptr single_sink,
-                 std::weak_ptr<details::thread_pool> tp,
         async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     std::shared_ptr<logger> clone(std::string new_name) override;
@@ -70,5 +64,5 @@ private:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "async_logger-inl.h"
+#    include "async_logger-inl.h"
 #endif

include/spdlog/cfg/argv.h

@@ -21,18 +21,22 @@ 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) {
+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++) {
+    for (int i = 1; i < argc; i++)
+    {
         std::string arg = argv[i];
-        if (arg.find(spdlog_level_prefix) == 0) {
+        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) {
+inline void load_argv_levels(int argc, char **argv)
+{
     load_argv_levels(argc, const_cast<const char **>(argv));
 }
 

include/spdlog/cfg/env.h

@@ -3,8 +3,8 @@
 
 #pragma once
 #include <spdlog/cfg/helpers.h>
-#include <spdlog/details/os.h>
 #include <spdlog/details/registry.h>
+#include <spdlog/details/os.h>
 
 //
 // Init levels and patterns from env variables SPDLOG_LEVEL
@@ -25,9 +25,11 @@
 
 namespace spdlog {
 namespace cfg {
-inline void load_env_levels(const char* var = "SPDLOG_LEVEL") {
+inline void load_env_levels()
-    auto env_val = details::os::getenv(var);
+{
-    if (!env_val.empty()) {
+    auto env_val = details::os::getenv("SPDLOG_LEVEL");
+    if (!env_val.empty())
+    {
         helpers::load_levels(env_val);
     }
 }

include/spdlog/cfg/helpers-inl.h

@@ -4,32 +4,33 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/cfg/helpers.h>
+#    include <spdlog/cfg/helpers.h>
 #endif
 
+#include <spdlog/spdlog.h>
 #include <spdlog/details/os.h>
 #include <spdlog/details/registry.h>
-#include <spdlog/spdlog.h>
 
 #include <algorithm>
-#include <sstream>
 #include <string>
 #include <utility>
+#include <sstream>
 
 namespace spdlog {
 namespace cfg {
 namespace helpers {
 
 // inplace convert to lowercase
-inline std::string &to_lower_(std::string &str) {
+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);
+    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) {
+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));
@@ -43,12 +44,16 @@ inline std::string &trim_(std::string &str) {
 // "key=" => ("key", "")
 // "val" => ("", "val")
 
-inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {
+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) {
+    if (n == std::string::npos)
+    {
         v = str;
-    } else {
+    }
+    else
+    {
         k = str.substr(0, n);
         v = str.substr(n + 1);
     }
@@ -57,12 +62,15 @@ inline std::pair<std::string, std::string> extract_kv_(char sep, const std::stri
 
 // 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) {
+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, ',')) {
+    while (std::getline(token_stream, token, ','))
-        if (token.empty()) {
+    {
+        if (token.empty())
+        {
             continue;
         }
         auto kv = extract_kv_('=', token);
@@ -71,8 +79,10 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
     return rv;
 }
 
-SPDLOG_INLINE void load_levels(const std::string &input) {
+SPDLOG_INLINE void load_levels(const std::string &input)
-    if (input.empty() || input.size() > 512) {
+{
+    if (input.empty() || input.size() > 512)
+    {
         return;
     }
 
@@ -81,25 +91,28 @@ SPDLOG_INLINE void load_levels(const std::string &input) {
     level::level_enum global_level = level::info;
     bool global_level_found = false;
 
-    for (auto &name_level : key_vals) {
+    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") {
+        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 {
+        }
+        else
+        {
             levels[logger_name] = level;
         }
     }
 
-    details::registry::instance().set_levels(std::move(levels),
+    details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
-                                             global_level_found ? &global_level : nullptr);
 }
 
 } // namespace helpers

include/spdlog/cfg/helpers.h

@@ -25,5 +25,5 @@ SPDLOG_API void load_levels(const std::string &txt);
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "helpers-inl.h"
+#    include "helpers-inl.h"
 #endif // SPDLOG_HEADER_ONLY

include/spdlog/common-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/common.h>
+#    include <spdlog/common.h>
 #endif
 
 #include <algorithm>
@@ -20,24 +20,29 @@ constexpr
 
 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 {
+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 {
+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 {
+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") {
+    if (name == "warn")
+    {
         return level::warn;
     }
-    if (name == "err") {
+    if (name == "err")
+    {
         return level::err;
     }
     return level::off;
@@ -45,9 +50,11 @@ SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG
 } // namespace level
 
 SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
-    : msg_(std::move(msg)) {}
+    : msg_(std::move(msg))
+{}
 
-SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {
+SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
+{
 #ifdef SPDLOG_USE_STD_FORMAT
     msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();
 #else
@@ -57,12 +64,19 @@ SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {
 #endif
 }
 
-SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); }
+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_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))); }
+SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
+{
+    SPDLOG_THROW(spdlog_ex(std::move(msg)));
+}
 
 } // namespace spdlog

include/spdlog/common.h

@@ -3,121 +3,106 @@
 
 #pragma once
 
-#include <spdlog/details/null_mutex.h>
 #include <spdlog/tweakme.h>
+#include <spdlog/details/null_mutex.h>
 
 #include <atomic>
 #include <chrono>
-#include <cstdio>
-#include <exception>
-#include <functional>
 #include <initializer_list>
 #include <memory>
+#include <exception>
 #include <string>
 #include <type_traits>
+#include <functional>
+#include <cstdio>
 
 #ifdef SPDLOG_USE_STD_FORMAT
-    #include <version>
+#    include <string_view>
-    #if __cpp_lib_format >= 202207L
-        #include <format>
-    #else
-        #include <string_view>
-    #endif
 #endif
 
 #ifdef SPDLOG_COMPILED_LIB
-    #undef SPDLOG_HEADER_ONLY
+#    undef SPDLOG_HEADER_ONLY
-    #if defined(SPDLOG_SHARED_LIB)
+#    if defined(SPDLOG_SHARED_LIB)
-        #if defined(_WIN32)
+#        if defined(_WIN32)
-            #ifdef spdlog_EXPORTS
+#            ifdef spdlog_EXPORTS
-                #define SPDLOG_API __declspec(dllexport)
+#                define SPDLOG_API __declspec(dllexport)
-            #else  // !spdlog_EXPORTS
+#            else // !spdlog_EXPORTS
-                #define SPDLOG_API __declspec(dllimport)
+#                define SPDLOG_API __declspec(dllimport)
-            #endif
+#            endif
-        #else  // !defined(_WIN32)
+#        else // !defined(_WIN32)
-            #define SPDLOG_API __attribute__((visibility("default")))
+#            define SPDLOG_API __attribute__((visibility("default")))
-        #endif
+#        endif
-    #else  // !defined(SPDLOG_SHARED_LIB)
+#    else // !defined(SPDLOG_SHARED_LIB)
-        #define SPDLOG_API
+#        define SPDLOG_API
-    #endif
+#    endif
-    #define SPDLOG_INLINE
+#    define SPDLOG_INLINE
 #else // !defined(SPDLOG_COMPILED_LIB)
-    #define SPDLOG_API
+#    define SPDLOG_API
-    #define SPDLOG_HEADER_ONLY
+#    define SPDLOG_HEADER_ONLY
-    #define SPDLOG_INLINE inline
+#    define SPDLOG_INLINE inline
 #endif // #ifdef SPDLOG_COMPILED_LIB
 
 #include <spdlog/fmt/fmt.h>
 
-#if !defined(SPDLOG_USE_STD_FORMAT) && \
+#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
-    FMT_VERSION >= 80000  // backward compatibility with fmt versions older than 8
+#    define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
-    #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+#    define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
-    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#        include <spdlog/fmt/xchar.h>
-        #include <spdlog/fmt/xchar.h>
+#    endif
-    #endif
 #else
-    #define SPDLOG_FMT_RUNTIME(format_string) format_string
+#    define SPDLOG_FMT_RUNTIME(format_string) format_string
-    #define SPDLOG_FMT_STRING(format_string) format_string
+#    define SPDLOG_FMT_STRING(format_string) format_string
 #endif
 
 // visual studio up to 2013 does not support noexcept nor constexpr
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
-    #define SPDLOG_NOEXCEPT _NOEXCEPT
+#    define SPDLOG_NOEXCEPT _NOEXCEPT
-    #define SPDLOG_CONSTEXPR
+#    define SPDLOG_CONSTEXPR
+#    define SPDLOG_CONSTEXPR_FUNC
 #else
-    #define SPDLOG_NOEXCEPT noexcept
+#    define SPDLOG_NOEXCEPT noexcept
-    #define SPDLOG_CONSTEXPR constexpr
+#    define SPDLOG_CONSTEXPR constexpr
-#endif
+#    if __cplusplus >= 201402L
-
+#        define SPDLOG_CONSTEXPR_FUNC constexpr
-// If building with std::format, can just use constexpr, otherwise if building with fmt
+#    else
-// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where
+#        define SPDLOG_CONSTEXPR_FUNC
-// a constexpr function in spdlog could end up calling a non-constexpr function in fmt
+#    endif
-// depending on the compiler
-// If fmt determines it can't use constexpr, we should inline the function instead
-#ifdef SPDLOG_USE_STD_FORMAT
-    #define SPDLOG_CONSTEXPR_FUNC constexpr
-#else  // Being built with fmt
-    #if FMT_USE_CONSTEXPR
-        #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR
-    #else
-        #define SPDLOG_CONSTEXPR_FUNC inline
-    #endif
 #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
 
 // disable thread local on msvc 2013
 #ifndef SPDLOG_NO_TLS
-    #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+#    if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
-        #define SPDLOG_NO_TLS 1
+#        define SPDLOG_NO_TLS 1
-    #endif
+#    endif
 #endif
 
 #ifndef SPDLOG_FUNCTION
-    #define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+#    define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
 #endif
 
 #ifdef SPDLOG_NO_EXCEPTIONS
-    #define SPDLOG_TRY
+#    define SPDLOG_TRY
-    #define SPDLOG_THROW(ex)                               \
+#    define SPDLOG_THROW(ex)                                                                                                               \
-        do {                                               \
+        do                                                                                                                                 \
+        {                                                                                                                                  \
             printf("spdlog fatal error: %s\n", ex.what());                                                                                 \
             std::abort();                                                                                                                  \
         } while (0)
-    #define SPDLOG_CATCH_STD
+#    define SPDLOG_CATCH_STD
 #else
-    #define SPDLOG_TRY try
+#    define SPDLOG_TRY try
-    #define SPDLOG_THROW(ex) throw(ex)
+#    define SPDLOG_THROW(ex) throw(ex)
-    #define SPDLOG_CATCH_STD             \
+#    define SPDLOG_CATCH_STD                                                                                                               \
-        catch (const std::exception &) { \
+        catch (const std::exception &) {}
-        }
 #endif
 
 namespace spdlog {
@@ -130,12 +115,12 @@ class sink;
 
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 using filename_t = std::wstring;
-    // allow macro expansion to occur in SPDLOG_FILENAME_T
+// allow macro expansion to occur in SPDLOG_FILENAME_T
-    #define SPDLOG_FILENAME_T_INNER(s) L##s
+#    define SPDLOG_FILENAME_T_INNER(s) L##s
-    #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
+#    define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
 #else
 using filename_t = std::string;
-    #define SPDLOG_FILENAME_T(s) s
+#    define SPDLOG_FILENAME_T(s) s
 #endif
 
 using log_clock = std::chrono::system_clock;
@@ -148,79 +133,61 @@ namespace fmt_lib = std;
 using string_view_t = std::string_view;
 using memory_buf_t = std::string;
 
-template <typename... Args>
+template<typename... Args>
-    #if __cpp_lib_format >= 202207L
-using format_string_t = std::format_string<Args...>;
-    #else
 using format_string_t = std::string_view;
-    #endif
 
-template <class T, class Char = char>
+template<class T, class Char = char>
-struct is_convertible_to_basic_format_string
+struct is_convertible_to_basic_format_string : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value>
-    : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> {};
+{};
 
-    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = std::wstring_view;
 using wmemory_buf_t = std::wstring;
 
-template <typename... Args>
+template<typename... Args>
-        #if __cpp_lib_format >= 202207L
-using wformat_string_t = std::wformat_string<Args...>;
-        #else
 using wformat_string_t = std::wstring_view;
-        #endif
+#    endif
-    #endif
+#    define SPDLOG_BUF_TO_STRING(x) x
-    #define SPDLOG_BUF_TO_STRING(x) x
 #else // use fmt lib instead of std::format
 namespace fmt_lib = fmt;
 
 using string_view_t = fmt::basic_string_view<char>;
 using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
 
-template <typename... Args>
+template<typename... Args>
 using format_string_t = fmt::format_string<Args...>;
 
-template <class T>
+template<class T>
 using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-template <typename Char>
+// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here,
-    #if FMT_VERSION >= 90101
+// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char>
-using fmt_runtime_string = fmt::runtime_format_string<Char>;
+template<class T, class Char = char>
-    #else
-using fmt_runtime_string = fmt::basic_runtime<Char>;
-    #endif
-
-// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the
-// condition from basic_format_string here, in addition, fmt::basic_runtime<Char> is only
-// convertible to basic_format_string<Char> but not basic_string_view<Char>
-template <class T, class Char = char>
 struct is_convertible_to_basic_format_string
     : std::integral_constant<bool,
-                             std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+          std::is_convertible<T, fmt::basic_string_view<Char>>::value || std::is_same<remove_cvref_t<T>, fmt::basic_runtime<Char>>::value>
-                                 std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> {
+{};
-};
 
-    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = fmt::basic_string_view<wchar_t>;
 using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
 
-template <typename... Args>
+template<typename... Args>
 using wformat_string_t = fmt::wformat_string<Args...>;
-    #endif
+#    endif
-    #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
+#    define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
 #endif
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    #ifndef _WIN32
+#    ifndef _WIN32
-        #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
-    #endif  // _WIN32
+#    endif // _WIN32
 #endif     // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
-template <class T>
+template<class T>
-struct is_convertible_to_any_format_string
+struct is_convertible_to_any_format_string : std::integral_constant<bool, is_convertible_to_basic_format_string<T, char>::value ||
-    : std::integral_constant<bool,
+                                                                              is_convertible_to_basic_format_string<T, wchar_t>::value>
-                             is_convertible_to_basic_format_string<T, char>::value ||
+{};
-                                 is_convertible_to_basic_format_string<T, wchar_t>::value> {};
 
 #if defined(SPDLOG_NO_ATOMIC_LEVELS)
 using level_t = details::null_atomic_int;
@@ -237,12 +204,13 @@ using level_t = std::atomic<int>;
 #define SPDLOG_LEVEL_OFF 6
 
 #if !defined(SPDLOG_ACTIVE_LEVEL)
-    #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 #endif
 
 // Log level enum
 namespace level {
-enum level_enum : int {
+enum level_enum : int
+{
     trace = SPDLOG_LEVEL_TRACE,
     debug = SPDLOG_LEVEL_DEBUG,
     info = SPDLOG_LEVEL_INFO,
@@ -262,18 +230,19 @@ enum level_enum : int {
 #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)
 
 #if !defined(SPDLOG_LEVEL_NAMES)
-    #define SPDLOG_LEVEL_NAMES                                                                  \
+#    define SPDLOG_LEVEL_NAMES                                                                                                             \
         {                                                                                                                                  \
-            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO,           \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR,  \
-                SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
+                SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF                                                                          \
-                SPDLOG_LEVEL_NAME_OFF                                                           \
         }
 #endif
 
 #if !defined(SPDLOG_SHORT_LEVEL_NAMES)
 
-    #define SPDLOG_SHORT_LEVEL_NAMES \
+#    define SPDLOG_SHORT_LEVEL_NAMES                                                                                                       \
-        { "T", "D", "I", "W", "E", "C", "O" }
+        {                                                                                                                                  \
+            "T", "D", "I", "W", "E", "C", "O"                                                                                              \
+        }
 #endif
 
 SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
@@ -285,13 +254,19 @@ SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NO
 //
 // Color mode used by sinks with color support.
 //
-enum class color_mode { always, automatic, never };
+enum class color_mode
+{
+    always,
+    automatic,
+    never
+};
 
 //
 // Pattern time - specific time getting to use for pattern_formatter.
 // local time by default
 //
-enum class pattern_time_type {
+enum class pattern_time_type
+{
     local, // log localtime
     utc    // log utc
 };
@@ -299,7 +274,8 @@ enum class pattern_time_type {
 //
 // Log exception
 //
-class SPDLOG_API spdlog_ex : public std::exception {
+class SPDLOG_API spdlog_ex : public std::exception
+{
 public:
     explicit spdlog_ex(std::string msg);
     spdlog_ex(const std::string &msg, int last_errno);
@@ -312,25 +288,32 @@ private:
 [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);
 [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);
 
-struct source_loc {
+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},
+        : filename{filename_in}
-          line{line_in},
+        , line{line_in}
-          funcname{funcname_in} {}
+        , funcname{funcname_in}
+    {}
 
-    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
+    {
+        return line == 0;
+    }
     const char *filename{nullptr};
     int line{0};
     const char *funcname{nullptr};
 };
 
-struct file_event_handlers {
+struct file_event_handlers
+{
     file_event_handlers()
-        : before_open(nullptr),
+        : before_open(nullptr)
-          after_open(nullptr),
+        , after_open(nullptr)
-          before_close(nullptr),
+        , before_close(nullptr)
-          after_close(nullptr) {}
+        , after_close(nullptr)
+    {}
 
     std::function<void(const filename_t &filename)> before_open;
     std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
@@ -340,61 +323,33 @@ struct file_event_handlers {
 
 namespace details {
 
-// to_string_view
-
-SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)
-    SPDLOG_NOEXCEPT {
-    return spdlog::string_view_t{buf.data(), buf.size()};
-}
-
-SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str)
-    SPDLOG_NOEXCEPT {
-    return str;
-}
-
-#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf)
-    SPDLOG_NOEXCEPT {
-    return spdlog::wstring_view_t{buf.data(), buf.size()};
-}
-
-SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str)
-    SPDLOG_NOEXCEPT {
-    return str;
-}
-#endif
-
-#if defined(SPDLOG_USE_STD_FORMAT) &&  __cpp_lib_format >= 202207L
-template <typename T, typename... Args>
-SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
-    std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
-    return fmt.get();
-}
-#endif
-
 // make_unique support for pre c++14
+
 #if __cplusplus >= 201402L // C++14 and beyond
 using std::enable_if_t;
 using std::make_unique;
 #else
-template <bool B, class T = void>
+template<bool B, class T = void>
 using enable_if_t = typename std::enable_if<B, T>::type;
 
-template <typename T, typename... Args>
+template<typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&...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
 
 // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
-template <typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
+template<typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0>
-constexpr T conditional_static_cast(U value) {
+constexpr T conditional_static_cast(U value)
+{
     return static_cast<T>(value);
 }
 
-template <typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
-constexpr T conditional_static_cast(U value) {
+constexpr T conditional_static_cast(U value)
+{
     return value;
 }
 
@@ -402,5 +357,5 @@ constexpr T conditional_static_cast(U value) {
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "common-inl.h"
+#    include "common-inl.h"
 #endif

include/spdlog/details/backtracer-inl.h

@@ -4,56 +4,62 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/backtracer.h>
+#    include <spdlog/details/backtracer.h>
 #endif
 namespace spdlog {
 namespace details {
-SPDLOG_INLINE backtracer::backtracer(const backtracer &other) {
+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 {
+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) {
+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) {
+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() {
+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 bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
 
-SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) {
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
     std::lock_guard<std::mutex> lock{mutex_};
     messages_.push_back(log_msg_buffer{msg});
 }
 
-SPDLOG_INLINE bool backtracer::empty() const {
-    std::lock_guard<std::mutex> lock{mutex_};
-    return messages_.empty();
-}
-
 // 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) {
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
+{
     std::lock_guard<std::mutex> lock{mutex_};
-    while (!messages_.empty()) {
+    while (!messages_.empty())
+    {
         auto &front_msg = messages_.front();
         fun(front_msg);
         messages_.pop_front();

include/spdlog/details/backtracer.h

@@ -3,19 +3,20 @@
 
 #pragma once
 
-#include <spdlog/details/circular_q.h>
 #include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/circular_q.h>
 
 #include <atomic>
-#include <functional>
 #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 {
+class SPDLOG_API backtracer
+{
     mutable std::mutex mutex_;
     std::atomic<bool> enabled_{false};
     circular_q<log_msg_buffer> messages_;
@@ -31,7 +32,6 @@ public:
     void disable();
     bool enabled() const;
     void push_back(const log_msg &msg);
-    bool empty() const;
 
     // 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);
@@ -41,5 +41,5 @@ public:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "backtracer-inl.h"
+#    include "backtracer-inl.h"
 #endif

include/spdlog/details/circular_q.h

@@ -4,15 +4,14 @@
 // circular q view of std::vector.
 #pragma once
 
-#include <cassert>
 #include <vector>
-
+#include <cassert>
-#include "spdlog/common.h"
 
 namespace spdlog {
 namespace details {
-template <typename T>
+template<typename T>
-class circular_q {
+class circular_q
+{
     size_t max_items_ = 0;
     typename std::vector<T>::size_type head_ = 0;
     typename std::vector<T>::size_type tail_ = 0;
@@ -27,24 +26,30 @@ public:
 
     explicit circular_q(size_t max_items)
         : max_items_(max_items + 1) // one item is reserved as marker for full q
-          ,
+        , v_(max_items_)
-          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(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+    }
 
-    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT {
+    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) {
+    void push_back(T &&item)
-        if (max_items_ > 0) {
+    {
+        if (max_items_ > 0)
+        {
             v_[tail_] = std::move(item);
             tail_ = (tail_ + 1) % max_items_;
 
@@ -58,47 +63,73 @@ public:
 
     // 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_]; }
+    const T &front() const
+    {
+        return v_[head_];
+    }
 
-    T &front() { return v_[head_]; }
+    T &front()
+    {
+        return v_[head_];
+    }
 
     // Return number of elements actually stored
-    size_t size() const {
+    size_t size() const
-        if (tail_ >= head_) {
+    {
+        if (tail_ >= head_)
+        {
             return tail_ - head_;
-        } else {
+        }
+        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 {
+    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() { head_ = (head_ + 1) % max_items_; }
+    void pop_front()
+    {
+        head_ = (head_ + 1) % max_items_;
+    }
 
-    bool empty() const { return tail_ == head_; }
+    bool empty() const
+    {
+        return tail_ == head_;
+    }
 
-    bool full() const {
+    bool full() const
+    {
         // head is ahead of the tail by 1
-        if (max_items_ > 0) {
+        if (max_items_ > 0)
+        {
             return ((tail_ + 1) % max_items_) == head_;
         }
         return false;
     }
 
-    size_t overrun_counter() const { return overrun_counter_; }
+    size_t overrun_counter() const
+    {
+        return overrun_counter_;
+    }
 
-    void reset_overrun_counter() { overrun_counter_ = 0; }
+    void reset_overrun_counter()
+    {
+        overrun_counter_ = 0;
+    }
 
 private:
     // copy from other&& and reset it to disabled state
-    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT {
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
+    {
         max_items_ = other.max_items_;
         head_ = other.head_;
         tail_ = other.tail_;

include/spdlog/details/console_globals.h

@@ -3,23 +3,27 @@
 
 #pragma once
 
-#include <mutex>
 #include <spdlog/details/null_mutex.h>
+#include <mutex>
 
 namespace spdlog {
 namespace details {
 
-struct console_mutex {
+struct console_mutex
+{
     using mutex_t = std::mutex;
-    static mutex_t &mutex() {
+    static mutex_t &mutex()
+    {
         static mutex_t s_mutex;
         return s_mutex;
     }
 };
 
-struct console_nullmutex {
+struct console_nullmutex
+{
     using mutex_t = null_mutex;
-    static mutex_t &mutex() {
+    static mutex_t &mutex()
+    {
         static mutex_t s_mutex;
         return s_mutex;
     }

include/spdlog/details/file_helper-inl.h

@@ -4,11 +4,11 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/file_helper.h>
+#    include <spdlog/details/file_helper.h>
 #endif
 
-#include <spdlog/common.h>
 #include <spdlog/details/os.h>
+#include <spdlog/common.h>
 
 #include <cerrno>
 #include <chrono>
@@ -21,36 +21,47 @@ namespace spdlog {
 namespace details {
 
 SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
-    : event_handlers_(event_handlers) {}
+    : event_handlers_(event_handlers)
+{}
 
-SPDLOG_INLINE file_helper::~file_helper() { close(); }
+SPDLOG_INLINE file_helper::~file_helper()
+{
+    close();
+}
 
-SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
+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");
 
-    if (event_handlers_.before_open) {
+    if (event_handlers_.before_open)
+    {
         event_handlers_.before_open(filename_);
     }
-    for (int tries = 0; tries < open_tries_; ++tries) {
+    for (int tries = 0; tries < open_tries_; ++tries)
+    {
         // create containing folder if not exists already.
         os::create_dir(os::dir_name(fname));
-        if (truncate) {
+        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)) {
+            if (os::fopen_s(&tmp, fname, trunc_mode))
+            {
                 continue;
             }
             std::fclose(tmp);
         }
-        if (!os::fopen_s(&fd_, fname, mode)) {
+        if (!os::fopen_s(&fd_, fname, mode))
-            if (event_handlers_.after_open) {
+        {
+            if (event_handlers_.after_open)
+            {
                 event_handlers_.after_open(filename_, fd_);
             }
             return;
@@ -59,62 +70,68 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
         details::os::sleep_for_millis(open_interval_);
     }
 
-    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing",
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
-                    errno);
 }
 
-SPDLOG_INLINE void file_helper::reopen(bool truncate) {
+SPDLOG_INLINE void file_helper::reopen(bool truncate)
-    if (filename_.empty()) {
+{
+    if (filename_.empty())
+    {
         throw_spdlog_ex("Failed re opening file - was not opened before");
     }
     this->open(filename_, truncate);
 }
 
-SPDLOG_INLINE void file_helper::flush() {
+SPDLOG_INLINE void file_helper::flush()
-    if (std::fflush(fd_) != 0) {
+{
+    if (std::fflush(fd_) != 0)
+    {
         throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
     }
 }
 
-SPDLOG_INLINE void file_helper::sync() {
+SPDLOG_INLINE void file_helper::close()
-    if (!os::fsync(fd_)) {
+{
-        throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
+    if (fd_ != nullptr)
-    }
+    {
-}
+        if (event_handlers_.before_close)
-
+        {
-SPDLOG_INLINE void file_helper::close() {
-    if (fd_ != nullptr) {
-        if (event_handlers_.before_close) {
             event_handlers_.before_close(filename_, fd_);
         }
 
         std::fclose(fd_);
         fd_ = nullptr;
 
-        if (event_handlers_.after_close) {
+        if (event_handlers_.after_close)
+        {
             event_handlers_.after_close(filename_);
         }
     }
 }
 
-SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
-    if (fd_ == nullptr) return;
+{
     size_t msg_size = buf.size();
     auto data = buf.data();
-
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
-    if (!details::os::fwrite_bytes(data, msg_size, fd_)) {
+    {
         throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
     }
 }
 
-SPDLOG_INLINE size_t file_helper::size() const {
+SPDLOG_INLINE size_t file_helper::size() const
-    if (fd_ == nullptr) {
+{
+    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_; }
+SPDLOG_INLINE const filename_t &file_helper::filename() const
+{
+    return filename_;
+}
 
 //
 // return file path and its extension:
@@ -129,19 +146,21 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_
 // ".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(
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
-    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) {
+    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) {
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    {
         return std::make_tuple(fname, filename_t());
     }
 

include/spdlog/details/file_helper.h

@@ -13,7 +13,8 @@ namespace details {
 // 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 {
+class SPDLOG_API file_helper
+{
 public:
     file_helper() = default;
     explicit file_helper(const file_event_handlers &event_handlers);
@@ -25,7 +26,6 @@ public:
     void open(const filename_t &fname, bool truncate = false);
     void reopen(bool truncate);
     void flush();
-    void sync();
     void close();
     void write(const memory_buf_t &buf);
     size_t size() const;
@@ -57,5 +57,5 @@ private:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "file_helper-inl.h"
+#    include "file_helper-inl.h"
 #endif

include/spdlog/details/fmt_helper.h

@@ -3,14 +3,14 @@
 #pragma once
 
 #include <chrono>
-#include <iterator>
-#include <spdlog/common.h>
-#include <spdlog/fmt/fmt.h>
 #include <type_traits>
+#include <iterator>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/common.h>
 
 #ifdef SPDLOG_USE_STD_FORMAT
-    #include <charconv>
+#    include <charconv>
-    #include <limits>
+#    include <limits>
 #endif
 
 // Some fmt helpers to efficiently format and pad ints and strings
@@ -18,117 +18,145 @@ namespace spdlog {
 namespace details {
 namespace fmt_helper {
 
-inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
+inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
+{
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
+{
     auto *buf_ptr = view.data();
     dest.append(buf_ptr, buf_ptr + view.size());
 }
 
 #ifdef SPDLOG_USE_STD_FORMAT
-template <typename T>
+template<typename T>
-inline void append_int(T n, memory_buf_t &dest) {
+inline void append_int(T n, memory_buf_t &dest)
+{
     // Buffer should be large enough to hold all digits (digits10 + 1) and a sign
     SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2;
     char buf[BUF_SIZE];
 
     auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);
-    if (ec == std::errc()) {
+    if (ec == std::errc())
+    {
         dest.append(buf, ptr);
-    } else {
+    }
+    else
+    {
         throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
     }
 }
 #else
-template <typename T>
+template<typename T>
-inline void append_int(T n, memory_buf_t &dest) {
+inline void append_int(T n, memory_buf_t &dest)
+{
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
 #endif
 
-template <typename T>
+template<typename T>
-SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) {
+SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n)
+{
     // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912
     unsigned int count = 1;
-    for (;;) {
+    for (;;)
+    {
         // Integer division is slow so do it for a group of four digits instead
         // of for every digit. The idea comes from the talk by Alexandrescu
         // "Three Optimization Tips for C++". See speed-test for a comparison.
-        if (n < 10) return count;
+        if (n < 10)
-        if (n < 100) return count + 1;
+            return count;
-        if (n < 1000) return count + 2;
+        if (n < 100)
-        if (n < 10000) return count + 3;
+            return count + 1;
+        if (n < 1000)
+            return count + 2;
+        if (n < 10000)
+            return count + 3;
         n /= 10000u;
         count += 4;
     }
 }
 
-template <typename T>
+template<typename T>
-inline unsigned int count_digits(T n) {
+inline unsigned int count_digits(T n)
-    using count_type =
+{
-        typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
 #ifdef SPDLOG_USE_STD_FORMAT
     return count_digits_fallback(static_cast<count_type>(n));
 #else
     return static_cast<unsigned int>(fmt::
-    // fmt 7.0.0 renamed the internal namespace to detail.
+// fmt 7.0.0 renamed the internal namespace to detail.
-    // See: https://github.com/fmtlib/fmt/issues/1538
+// See: https://github.com/fmtlib/fmt/issues/1538
-    #if FMT_VERSION < 70000
+#    if FMT_VERSION < 70000
             internal
-    #else
+#    else
             detail
-    #endif
+#    endif
         ::count_digits(static_cast<count_type>(n)));
 #endif
 }
 
-inline void pad2(int n, memory_buf_t &dest) {
+inline void pad2(int n, memory_buf_t &dest)
+{
     if (n >= 0 && n < 100) // 0-99
     {
         dest.push_back(static_cast<char>('0' + n / 10));
         dest.push_back(static_cast<char>('0' + n % 10));
-    } else  // unlikely, but just in case, let fmt deal with it
+    }
+    else // unlikely, but just in case, let fmt deal with it
     {
         fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
     }
 }
 
-template <typename T>
+template<typename T>
-inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) {
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
+{
     static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
-    for (auto digits = count_digits(n); digits < width; digits++) {
+    for (auto digits = count_digits(n); digits < width; digits++)
+    {
         dest.push_back('0');
     }
     append_int(n, dest);
 }
 
-template <typename T>
+template<typename T>
-inline void pad3(T n, memory_buf_t &dest) {
+inline void pad3(T n, memory_buf_t &dest)
+{
     static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
-    if (n < 1000) {
+    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 {
+    }
+    else
+    {
         append_int(n, dest);
     }
 }
 
-template <typename T>
+template<typename T>
-inline void pad6(T n, memory_buf_t &dest) {
+inline void pad6(T n, memory_buf_t &dest)
+{
     pad_uint(n, 6, dest);
 }
 
-template <typename T>
+template<typename T>
-inline void pad9(T n, memory_buf_t &dest) {
+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>
+template<typename ToDuration>
-inline ToDuration time_fraction(log_clock::time_point tp) {
+inline ToDuration time_fraction(log_clock::time_point tp)
+{
     using std::chrono::duration_cast;
     using std::chrono::seconds;
     auto duration = tp.time_since_epoch();

include/spdlog/details/log_msg-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/log_msg.h>
+#    include <spdlog/details/log_msg.h>
 #endif
 
 #include <spdlog/details/os.h>
@@ -12,33 +12,26 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time,
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
-                               spdlog::source_loc loc,
+    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-                               string_view_t a_logger_name,
+    : logger_name(a_logger_name)
-                               spdlog::level::level_enum lvl,
+    , level(lvl)
-                               spdlog::string_view_t msg)
+    , time(log_time)
-    : logger_name(a_logger_name),
-      level(lvl),
-      time(log_time)
 #ifndef SPDLOG_NO_THREAD_ID
-      ,
+    , thread_id(os::thread_id())
-      thread_id(os::thread_id())
 #endif
-      ,
+    , source(loc)
-      source(loc),
+    , payload(msg)
-      payload(msg) {
+{}
-}
 
-SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc,
+SPDLOG_INLINE log_msg::log_msg(
-                               string_view_t a_logger_name,
+    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-                               spdlog::level::level_enum lvl,
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
-                               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_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
-                               spdlog::level::level_enum lvl,
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
-                               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

@@ -8,13 +8,10 @@
 
 namespace spdlog {
 namespace details {
-struct SPDLOG_API log_msg {
+struct SPDLOG_API log_msg
+{
     log_msg() = default;
-    log_msg(log_clock::time_point log_time,
+    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
-            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;
@@ -36,5 +33,5 @@ struct SPDLOG_API log_msg {
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "log_msg-inl.h"
+#    include "log_msg-inl.h"
 #endif

include/spdlog/details/log_msg_buffer-inl.h

@@ -4,33 +4,35 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/log_msg_buffer.h>
+#    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} {
+    : 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} {
+    : 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
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
-    : 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) {
+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());
@@ -38,14 +40,16 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot
     return *this;
 }
 
-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT {
+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() {
+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()};
 }

include/spdlog/details/log_msg_buffer.h

@@ -11,7 +11,8 @@ 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 {
+class SPDLOG_API log_msg_buffer : public log_msg
+{
     memory_buf_t buffer;
     void update_string_views();
 
@@ -28,5 +29,5 @@ public:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "log_msg_buffer-inl.h"
+#    include "log_msg_buffer-inl.h"
 #endif

include/spdlog/details/mpmc_blocking_q.h

@@ -12,23 +12,25 @@
 
 #include <spdlog/details/circular_q.h>
 
-#include <atomic>
 #include <condition_variable>
 #include <mutex>
 
 namespace spdlog {
 namespace details {
 
-template <typename T>
+template<typename T>
-class mpmc_blocking_queue {
+class mpmc_blocking_queue
+{
 public:
     using item_type = T;
     explicit mpmc_blocking_queue(size_t max_items)
-        : q_(max_items) {}
+        : q_(max_items)
+    {}
 
 #ifndef __MINGW32__
     // try to enqueue and block if no room left
-    void enqueue(T &&item) {
+    void enqueue(T &&item)
+    {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@@ -38,7 +40,8 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item) {
+    void enqueue_nowait(T &&item)
+    {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             q_.push_back(std::move(item));
@@ -46,29 +49,14 @@ public:
         push_cv_.notify_one();
     }
 
-    void enqueue_if_have_room(T &&item) {
+    // try to dequeue item. if no item found. wait up to timeout and try again
-        bool pushed = false;
-        {
-            std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!q_.full()) {
-                q_.push_back(std::move(item));
-                pushed = true;
-            }
-        }
-
-        if (pushed) {
-            push_cv_.notify_one();
-        } else {
-            ++discard_counter_;
-        }
-    }
-
-    // dequeue with a timeout.
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+            {
                 return false;
             }
             popped_item = std::move(q_.front());
@@ -78,23 +66,13 @@ public:
         return true;
     }
 
-    // blocking dequeue without a timeout.
-    void dequeue(T &popped_item) {
-        {
-            std::unique_lock<std::mutex> lock(queue_mutex_);
-            push_cv_.wait(lock, [this] { return !this->q_.empty(); });
-            popped_item = std::move(q_.front());
-            q_.pop_front();
-        }
-        pop_cv_.notify_one();
-    }
-
 #else
     // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
     // so release the mutex at the very end each function.
 
     // try to enqueue and block if no room left
-    void enqueue(T &&item) {
+    void enqueue(T &&item)
+    {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         pop_cv_.wait(lock, [this] { return !this->q_.full(); });
         q_.push_back(std::move(item));
@@ -102,32 +80,20 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item) {
+    void enqueue_nowait(T &&item)
+    {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.push_back(std::move(item));
         push_cv_.notify_one();
     }
 
-    void enqueue_if_have_room(T &&item) {
+    // try to dequeue item. if no item found. wait up to timeout and try again
-        bool pushed = false;
-        std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!q_.full()) {
-            q_.push_back(std::move(item));
-            pushed = true;
-        }
-
-        if (pushed) {
-            push_cv_.notify_one();
-        } else {
-            ++discard_counter_;
-        }
-    }
-
-    // dequeue with a timeout.
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
         std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+        {
             return false;
         }
         popped_item = std::move(q_.front());
@@ -136,42 +102,31 @@ public:
         return true;
     }
 
-    // blocking dequeue without a timeout.
-    void dequeue(T &popped_item) {
-        std::unique_lock<std::mutex> lock(queue_mutex_);
-        push_cv_.wait(lock, [this] { return !this->q_.empty(); });
-        popped_item = std::move(q_.front());
-        q_.pop_front();
-        pop_cv_.notify_one();
-    }
-
 #endif
 
-    size_t overrun_counter() {
+    size_t overrun_counter()
-        std::lock_guard<std::mutex> lock(queue_mutex_);
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
         return q_.overrun_counter();
     }
 
-    size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }
+    size_t size()
-
+    {
-    size_t size() {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
-        std::lock_guard<std::mutex> lock(queue_mutex_);
         return q_.size();
     }
 
-    void reset_overrun_counter() {
+    void reset_overrun_counter()
-        std::lock_guard<std::mutex> lock(queue_mutex_);
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.reset_overrun_counter();
     }
 
-    void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); }
-
 private:
     std::mutex queue_mutex_;
     std::condition_variable push_cv_;
     std::condition_variable pop_cv_;
     spdlog::details::circular_q<T> q_;
-    std::atomic<size_t> discard_counter_{0};
 };
 } // namespace details
 } // namespace spdlog

include/spdlog/details/null_mutex.h

@@ -9,23 +9,33 @@
 
 namespace spdlog {
 namespace details {
-struct null_mutex {
+struct null_mutex
+{
     void lock() const {}
     void unlock() const {}
 };
 
-struct null_atomic_int {
+struct null_atomic_int
+{
     int value;
     null_atomic_int() = default;
 
     explicit null_atomic_int(int new_value)
-        : value(new_value) {}
+        : value(new_value)
+    {}
 
-    int load(std::memory_order = std::memory_order_relaxed) const { return value; }
+    int load(std::memory_order = std::memory_order_relaxed) const
+    {
+        return value;
+    }
 
-    void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; }
+    void store(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        value = new_value;
+    }
 
-    int exchange(int new_value, std::memory_order = std::memory_order_relaxed) {
+    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

@@ -4,88 +4,86 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/os.h>
+#    include <spdlog/details/os.h>
 #endif
 
 #include <spdlog/common.h>
 
 #include <algorithm>
-#include <array>
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <string>
+#include <thread>
+#include <array>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <thread>
 
 #ifdef _WIN32
-    #include <spdlog/details/windows_include.h>
-    #include <fileapi.h>  // for FlushFileBuffers
-    #include <io.h>       // for _get_osfhandle, _isatty, _fileno
-    #include <process.h>  // for _get_pid
 
-    #ifdef __MINGW32__
+#    include <io.h>      // _get_osfhandle and _isatty support
-        #include <share.h>
+#    include <process.h> //  _get_pid support
-    #endif
+#    include <spdlog/details/windows_include.h>
 
-    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+#    ifdef __MINGW32__
-        #include <cassert>
+#        include <share.h>
-        #include <limits>
+#    endif
-    #endif
 
-    #include <direct.h>  // for _mkdir/_wmkdir
+#    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 <fcntl.h>
-    #include <unistd.h>
+#    include <unistd.h>
 
-    #ifdef __linux__
+#    ifdef __linux__
-        #include <sys/syscall.h>  //Use gettid() syscall under linux to get thread id
+#        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
 
-    #elif defined(_AIX)
+#    elif defined(_AIX)
-        #include <pthread.h>  // for pthread_getthrds_np
+#        include <pthread.h> // for pthread_getthrds_np
 
-    #elif defined(__DragonFly__) || defined(__FreeBSD__)
+#    elif defined(__DragonFly__) || defined(__FreeBSD__)
-        #include <pthread_np.h>  // for pthread_getthreadid_np
+#        include <pthread_np.h> // for pthread_getthreadid_np
 
-    #elif defined(__NetBSD__)
+#    elif defined(__NetBSD__)
-        #include <lwp.h>  // for _lwp_self
+#        include <lwp.h> // for _lwp_self
 
-    #elif defined(__sun)
+#    elif defined(__sun)
-        #include <thread.h>  // for thr_self
+#        include <thread.h> // for thr_self
-    #endif
+#    endif
 
 #endif // unix
 
-#if defined __APPLE__
-    #include <AvailabilityMacros.h>
-#endif
-
 #ifndef __has_feature          // Clang - feature checking macros.
-    #define __has_feature(x) 0  // Compatibility with non-clang compilers.
+#    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 {
+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::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-            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 {
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
 #ifdef _WIN32
     std::tm tm;
     ::localtime_s(&tm, &time_tt);
@@ -96,12 +94,15 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
     return tm;
 }
 
-SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT {
+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 {
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
 #ifdef _WIN32
     std::tm tm;
     ::gmtime_s(&tm, &time_tt);
@@ -112,49 +113,55 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
     return tm;
 }
 
-SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT {
+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) {
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+{
 #ifdef _WIN32
-    #ifdef SPDLOG_WCHAR_FILENAMES
+#    ifdef SPDLOG_WCHAR_FILENAMES
     *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-    #else
+#    else
     *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-    #endif
+#    endif
-    #if defined(SPDLOG_PREVENT_CHILD_FD)
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
-    if (*fp != nullptr) {
+    if (*fp != nullptr)
+    {
         auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
-        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        {
             ::fclose(*fp);
             *fp = nullptr;
         }
     }
-    #endif
+#    endif
 #else // unix
-    #if defined(SPDLOG_PREVENT_CHILD_FD)
+#    if defined(SPDLOG_PREVENT_CHILD_FD)
     const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
-    const int fd =
+    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
-        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1)
-    if (fd == -1) {
+    {
         return true;
     }
     *fp = ::fdopen(fd, mode.c_str());
-    if (*fp == nullptr) {
+    if (*fp == nullptr)
+    {
         ::close(fd);
     }
-    #else
+#    else
     *fp = ::fopen((filename.c_str()), mode.c_str());
-    #endif
+#    endif
 #endif
 
     return *fp == nullptr;
 }
 
-SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+{
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
     return ::_wremove(filename.c_str());
 #else
@@ -162,11 +169,13 @@ SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
 #endif
 }
 
-SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
+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 {
+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
@@ -175,14 +184,15 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
 }
 
 // Return true if path exists (file or directory)
-SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
 #ifdef _WIN32
-    struct _stat buffer;
+#    ifdef SPDLOG_WCHAR_FILENAMES
-    #ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = ::GetFileAttributesW(filename.c_str());
-    return (::_wstat(filename.c_str(), &buffer) == 0);
+#    else
-    #else
+    auto attribs = ::GetFileAttributesA(filename.c_str());
-    return (::_stat(filename.c_str(), &buffer) == 0);
+#    endif
-    #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);
@@ -190,89 +200,98 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
 }
 
 #ifdef _MSC_VER
-    // avoid warning about unreachable statement at the end of filesize()
+// avoid warning about unreachable statement at the end of filesize()
-    #pragma warning(push)
+#    pragma warning(push)
-    #pragma warning(disable : 4702)
+#    pragma warning(disable : 4702)
 #endif
 
 // Return file size according to open FILE* object
-SPDLOG_INLINE size_t filesize(FILE *f) {
+SPDLOG_INLINE size_t filesize(FILE *f)
-    if (f == nullptr) {
+{
+    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
+#    if defined(_WIN64) // 64 bits
     __int64 ret = ::_filelengthi64(fd);
-    if (ret >= 0) {
+    if (ret >= 0)
+    {
         return static_cast<size_t>(ret);
     }
 
-    #else  // windows 32 bits
+#    else // windows 32 bits
     long ret = ::_filelength(fd);
-    if (ret >= 0) {
+    if (ret >= 0)
+    {
         return static_cast<size_t>(ret);
     }
-    #endif
+#    endif
 
 #else // unix
-    // OpenBSD and AIX doesn't compile with :: before the fileno(..)
+// OpenBSD and AIX doesn't compile with :: before the fileno(..)
-    #if defined(__OpenBSD__) || defined(_AIX)
+#    if defined(__OpenBSD__) || defined(_AIX)
     int fd = fileno(f);
-    #else
+#    else
     int fd = ::fileno(f);
-    #endif
+#    endif
-    // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
+// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-    #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
+#    if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
-        (defined(__LP64__) || defined(_LP64))
     struct stat64 st;
-    if (::fstat64(fd, &st) == 0) {
+    if (::fstat64(fd, &st) == 0)
+    {
         return static_cast<size_t>(st.st_size);
     }
-    #else  // other unix or linux 32 bits or cygwin
+#    else // other unix or linux 32 bits or cygwin
     struct stat st;
-    if (::fstat(fd, &st) == 0) {
+    if (::fstat(fd, &st) == 0)
+    {
         return static_cast<size_t>(st.st_size);
     }
-    #endif
+#    endif
 #endif
     throw_spdlog_ex("Failed getting file size from fd", errno);
     return 0; // will not be reached.
 }
 
 #ifdef _MSC_VER
-    #pragma warning(pop)
+#    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) {
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
+{
+
 #ifdef _WIN32
-    #if _WIN32_WINNT < _WIN32_WINNT_WS08
+#    if _WIN32_WINNT < _WIN32_WINNT_WS08
     TIME_ZONE_INFORMATION tzinfo;
     auto rv = ::GetTimeZoneInformation(&tzinfo);
-    #else
+#    else
     DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
     auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
-    #endif
+#    endif
-    if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw_spdlog_ex("Failed getting timezone info. ", errno);
 
     int offset = -tzinfo.Bias;
-    if (tm.tm_isdst) {
+    if (tm.tm_isdst)
+    {
         offset -= tzinfo.DaylightBias;
-    } else {
+    }
+    else
+    {
         offset -= tzinfo.StandardBias;
     }
     return offset;
 #else
 
-    #if defined(sun) || defined(__sun) || defined(_AIX) || \
+#    if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
-        (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) ||  \
-        (!defined(__APPLE__) && !defined(_BSD_SOURCE) && !defined(_GNU_SOURCE) && \
-            (!defined(_POSIX_VERSION) || (_POSIX_VERSION < 202405L)))
     // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper {
+    struct helper
-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(),
+    {
-                                             const std::tm &gmtm = details::os::gmtime()) {
+        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);
 
@@ -297,9 +316,9 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
     };
 
     auto offset_seconds = helper::calculate_gmt_offset(tm);
-    #else
+#    else
     auto offset_seconds = tm.tm_gmtoff;
-    #endif
+#    endif
 
     return static_cast<int>(offset_seconds / 60);
 #endif
@@ -308,13 +327,14 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
 // 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 {
+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)
+#    if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-        #define SYS_gettid __NR_gettid
+#        define SYS_gettid __NR_gettid
-    #endif
+#    endif
     return static_cast<size_t>(::syscall(SYS_gettid));
 #elif defined(_AIX)
     struct __pthrdsinfo buf;
@@ -333,25 +353,7 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
     return static_cast<size_t>(::thr_self());
 #elif __APPLE__
     uint64_t tid;
-    // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
-    // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
-    #ifdef MAC_OS_X_VERSION_MAX_ALLOWED
-    {
-        #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
-        tid = pthread_mach_thread_np(pthread_self());
-        #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-        if (&pthread_threadid_np) {
     pthread_threadid_np(nullptr, &tid);
-        } else {
-            tid = pthread_mach_thread_np(pthread_self());
-        }
-        #else
-        pthread_threadid_np(nullptr, &tid);
-        #endif
-    }
-    #else
-    pthread_threadid_np(nullptr, &tid);
-    #endif
     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()));
@@ -359,7 +361,8 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
 }
 
 // Return current thread id as size_t (from thread local storage)
-SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+{
 #if defined(SPDLOG_NO_TLS)
     return _thread_id();
 #else // cache thread id in tls
@@ -370,7 +373,8 @@ SPDLOG_INLINE 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
-SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT
+{
 #if defined(_WIN32)
     ::Sleep(milliseconds);
 #else
@@ -380,16 +384,22 @@ SPDLOG_INLINE 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)
-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) {
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
     memory_buf_t buf;
     wstr_to_utf8buf(filename, buf);
     return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; }
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    return filename;
+}
 #endif
 
-SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+{
+
 #ifdef _WIN32
     return conditional_static_cast<int>(::GetCurrentProcessId());
 #else
@@ -399,29 +409,29 @@ SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
 
 // Determine if the terminal supports colors
 // Based on: https://github.com/agauniyal/rang/
-SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {
+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) {
+        if (env_colorterm_p != nullptr)
+        {
             return true;
         }
 
-        static constexpr std::array<const char *, 16> terms = {
+        static constexpr std::array<const char *, 16> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
-            {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys",
+            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
-             "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
 
         const char *env_term_p = std::getenv("TERM");
-        if (env_term_p == nullptr) {
+        if (env_term_p == nullptr)
+        {
             return false;
         }
 
-        return std::any_of(terms.begin(), terms.end(), [&](const char *term) {
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
-            return std::strstr(env_term_p, term) != nullptr;
-        });
     }();
 
     return result;
@@ -430,7 +440,9 @@ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {
 
 // Determine if the terminal attached
 // Source: https://github.com/agauniyal/rang/
-SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+{
+
 #ifdef _WIN32
     return ::_isatty(_fileno(file)) != 0;
 #else
@@ -439,77 +451,86 @@ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
 }
 
 #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) {
+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)()) / 4 - 1) {
+{
+    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) {
+    if (wstr_size == 0)
+    {
         target.resize(0);
         return;
     }
 
     int result_size = static_cast<int>(target.capacity());
-    if ((wstr_size + 1) * 4 > result_size) {
+    if ((wstr_size + 1) * 2 > result_size)
-        result_size =
+    {
-            ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
     }
 
-    if (result_size > 0) {
+    if (result_size > 0)
+    {
         target.resize(result_size);
-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
-                                            result_size, NULL, NULL);
 
-        if (result_size > 0) {
+        if (result_size > 0)
+        {
             target.resize(result_size);
             return;
         }
     }
 
-    throw_spdlog_ex(
+    throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
-        fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
 }
 
-SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
+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) {
+{
+    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) {
+    if (str_size == 0)
+    {
         target.resize(0);
         return;
     }
 
-    // find the size to allocate for the result buffer
+    int result_size = static_cast<int>(target.capacity());
-    int result_size =
+    if (str_size + 1 > result_size)
-        ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
+    {
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
+    }
 
-    if (result_size > 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);
-        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
-                                            result_size);
-        if (result_size > 0) {
-            assert(result_size == target.size());
             return;
         }
     }
 
-    throw_spdlog_ex(
+    throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
-        fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
 }
-#endif  // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&
+#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
-        // defined(_WIN32)
 
 // return true on success
-static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
+static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+{
 #ifdef _WIN32
-    #ifdef SPDLOG_WCHAR_FILENAMES
+#    ifdef SPDLOG_WCHAR_FILENAMES
     return ::_wmkdir(path.c_str()) == 0;
-    #else
+#    else
     return ::_mkdir(path.c_str()) == 0;
-    #endif
+#    endif
 #else
     return ::mkdir(path.c_str(), mode_t(0755)) == 0;
 #endif
@@ -517,35 +538,32 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
 
 // 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(const filename_t &path) {
+SPDLOG_INLINE bool create_dir(const filename_t &path)
-    if (path_exists(path)) {
+{
+    if (path_exists(path))
+    {
         return true;
     }
 
-    if (path.empty()) {
+    if (path.empty())
+    {
         return false;
     }
 
     size_t search_offset = 0;
-    do {
+    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) {
+        if (token_pos == filename_t::npos)
+        {
             token_pos = path.size();
         }
 
         auto subdir = path.substr(0, token_pos);
-#ifdef _WIN32
-        // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\",
-        // otherwise path_exists(subdir) returns false (issue #3079)
-        const bool is_drive = subdir.length() == 2 && subdir[1] == ':';
-        if (is_drive) {
-            subdir += '\\';
-            token_pos++;
-        }
-#endif
 
-        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
+        {
             return false; // return error if failed creating dir
         }
         search_offset = token_pos + 1;
@@ -559,49 +577,30 @@ SPDLOG_INLINE bool create_dir(const filename_t &path) {
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
+SPDLOG_INLINE filename_t dir_name(const 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) {
+std::string SPDLOG_INLINE getenv(const char *field)
+{
+
 #if defined(_MSC_VER)
-    #if defined(__cplusplus_winrt)
+#    if defined(__cplusplus_winrt)
     return std::string{}; // not supported under uwp
-    #else
+#    else
     size_t len = 0;
     char buf[128];
     bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
     return ok ? buf : std::string{};
-    #endif
+#    endif
 #else // revert to getenv
     char *buf = ::getenv(field);
     return buf ? buf : std::string{};
 #endif
 }
 
-// Do fsync by FILE handlerpointer
-// Return true on success
-SPDLOG_INLINE bool fsync(FILE *fp) {
-#ifdef _WIN32
-    return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;
-#else
-    return ::fsync(fileno(fp)) == 0;
-#endif
-}
-
-// Do non-locking fwrite if possible by the os or use the regular locking fwrite
-// Return true on success.
-SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
-    #if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)
-    return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
-    #elif defined(SPDLOG_FWRITE_UNLOCKED)
-    return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
-    #else
-    return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;
-    #endif
-}
-
 } // namespace os
 } // namespace details
 } // namespace spdlog

include/spdlog/details/os.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include <ctime>  // std::time_t
 #include <spdlog/common.h>
+#include <ctime> // std::time_t
 
 namespace spdlog {
 namespace details {
@@ -22,27 +22,26 @@ SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
 
 // eol definition
 #if !defined(SPDLOG_EOL)
-    #ifdef _WIN32
+#    ifdef _WIN32
-        #define SPDLOG_EOL "\r\n"
+#        define SPDLOG_EOL "\r\n"
-    #else
+#    else
-        #define SPDLOG_EOL "\n"
+#        define SPDLOG_EOL "\n"
-    #endif
+#    endif
 #endif
 
 SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
 
 // folder separator
 #if !defined(SPDLOG_FOLDER_SEPS)
-    #ifdef _WIN32
+#    ifdef _WIN32
-        #define SPDLOG_FOLDER_SEPS "\\/"
+#        define SPDLOG_FOLDER_SEPS "\\/"
-    #else
+#    else
-        #define SPDLOG_FOLDER_SEPS "/"
+#        define SPDLOG_FOLDER_SEPS "/"
-    #endif
+#    endif
 #endif
 
 SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
-SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] =
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
-    SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
 
 // fopen_s on non windows for writing
 SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
@@ -110,18 +109,10 @@ SPDLOG_API bool create_dir(const filename_t &path);
 // return empty string if field not found
 SPDLOG_API std::string getenv(const char *field);
 
-// Do fsync by FILE objectpointer.
-// Return true on success.
-SPDLOG_API bool fsync(FILE *fp);
-
-// Do non-locking fwrite if possible by the os or use the regular locking fwrite
-// Return true on success.
-SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);
-
 } // namespace os
 } // namespace details
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "os-inl.h"
+#    include "os-inl.h"
 #endif

include/spdlog/details/periodic_worker-inl.h

@@ -4,15 +4,17 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/periodic_worker.h>
+#    include <spdlog/details/periodic_worker.h>
 #endif
 
 namespace spdlog {
 namespace details {
 
 // stop the worker thread and join it
-SPDLOG_INLINE periodic_worker::~periodic_worker() {
+SPDLOG_INLINE periodic_worker::~periodic_worker()
-    if (worker_thread_.joinable()) {
+{
+    if (worker_thread_.joinable())
+    {
         {
             std::lock_guard<std::mutex> lock(mutex_);
             active_ = false;

include/spdlog/details/periodic_worker.h

@@ -7,8 +7,7 @@
 //
 // RAII over the owned thread:
 //    creates the thread on construction.
-//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
-//    to finish first).
 
 #include <chrono>
 #include <condition_variable>
@@ -18,27 +17,30 @@
 namespace spdlog {
 namespace details {
 
-class SPDLOG_API periodic_worker {
+class SPDLOG_API periodic_worker
+{
 public:
-    template <typename Rep, typename Period>
+    template<typename Rep, typename Period>
-    periodic_worker(const std::function<void()> &callback_fun,
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval)
-                    std::chrono::duration<Rep, Period> interval) {
+    {
         active_ = (interval > std::chrono::duration<Rep, Period>::zero());
-        if (!active_) {
+        if (!active_)
+        {
             return;
         }
 
         worker_thread_ = std::thread([this, callback_fun, interval]() {
-            for (;;) {
+            for (;;)
+            {
                 std::unique_lock<std::mutex> lock(this->mutex_);
-                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+                {
                     return; // active_ == false, so exit this thread
                 }
                 callback_fun();
             }
         });
     }
-    std::thread &get_thread() { return worker_thread_; }
     periodic_worker(const periodic_worker &) = delete;
     periodic_worker &operator=(const periodic_worker &) = delete;
     // stop the worker thread and join it
@@ -54,5 +56,5 @@ private:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "periodic_worker-inl.h"
+#    include "periodic_worker-inl.h"
 #endif

include/spdlog/details/registry-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/registry.h>
+#    include <spdlog/details/registry.h>
 #endif
 
 #include <spdlog/common.h>
@@ -13,12 +13,12 @@
 #include <spdlog/pattern_formatter.h>
 
 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-    // support for the default stdout color logger
+// support for the default stdout color logger
-    #ifdef _WIN32
+#    ifdef _WIN32
-        #include <spdlog/sinks/wincolor_sink.h>
+#        include <spdlog/sinks/wincolor_sink.h>
-    #else
+#    else
-        #include <spdlog/sinks/ansicolor_sink.h>
+#        include <spdlog/sinks/ansicolor_sink.h>
-    #endif
+#    endif
 #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
 
 #include <chrono>
@@ -31,14 +31,16 @@ namespace spdlog {
 namespace details {
 
 SPDLOG_INLINE registry::registry()
-    : formatter_(new pattern_formatter()) {
+    : 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
+#    ifdef _WIN32
     auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
-    #else
+#    else
     auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
-    #endif
+#    endif
 
     const char *default_logger_name = "";
     default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
@@ -49,16 +51,19 @@ SPDLOG_INLINE registry::registry()
 
 SPDLOG_INLINE registry::~registry() = default;
 
-SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) {
+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) {
+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_) {
+    if (err_handler_)
+    {
         new_logger->set_error_handler(err_handler_);
     }
 
@@ -69,22 +74,26 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logge
 
     new_logger->flush_on(flush_level_);
 
-    if (backtrace_n_messages_ > 0) {
+    if (backtrace_n_messages_ > 0)
+    {
         new_logger->enable_backtrace(backtrace_n_messages_);
     }
 
-    if (automatic_registration_) {
+    if (automatic_registration_)
+    {
         register_logger_(std::move(new_logger));
     }
 }
 
-SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) {
+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() {
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     return default_logger_;
 }
@@ -93,110 +102,140 @@ SPDLOG_INLINE std::shared_ptr<logger> registry::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(); }
+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) {
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    if (new_default_logger != nullptr) {
+    // 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) {
+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() {
+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) {
+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_) {
+    for (auto &l : loggers_)
+    {
         l.second->set_formatter(formatter_->clone());
     }
 }
 
-SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) {
+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_) {
+    for (auto &l : loggers_)
+    {
         l.second->enable_backtrace(n_messages);
     }
 }
 
-SPDLOG_INLINE void registry::disable_backtrace() {
+SPDLOG_INLINE void registry::disable_backtrace()
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     backtrace_n_messages_ = 0;
-    for (auto &l : loggers_) {
+    for (auto &l : loggers_)
+    {
         l.second->disable_backtrace();
     }
 }
 
-SPDLOG_INLINE void registry::set_level(level::level_enum log_level) {
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_) {
+    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) {
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_) {
+    for (auto &l : loggers_)
+    {
         l.second->flush_on(log_level);
     }
     flush_level_ = log_level;
 }
 
-SPDLOG_INLINE void registry::set_error_handler(err_handler handler) {
+SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_) {
+    for (auto &l : loggers_)
+    {
         l.second->set_error_handler(handler);
     }
     err_handler_ = std::move(handler);
 }
 
-SPDLOG_INLINE void registry::apply_all(
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
-    const std::function<void(const std::shared_ptr<logger>)> &fun) {
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_) {
+    for (auto &l : loggers_)
+    {
         fun(l.second);
     }
 }
 
-SPDLOG_INLINE void registry::flush_all() {
+SPDLOG_INLINE void registry::flush_all()
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_) {
+    for (auto &l : loggers_)
+    {
         l.second->flush();
     }
 }
 
-SPDLOG_INLINE void registry::drop(const std::string &logger_name) {
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
     loggers_.erase(logger_name);
-    if (is_default_logger) {
+    if (default_logger_ && default_logger_->name() == logger_name)
+    {
         default_logger_.reset();
     }
 }
 
-SPDLOG_INLINE void registry::drop_all() {
+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() {
+SPDLOG_INLINE void registry::shutdown()
+{
     {
         std::lock_guard<std::mutex> lock(flusher_mutex_);
         periodic_flusher_.reset();
@@ -210,48 +249,54 @@ SPDLOG_INLINE void registry::shutdown() {
     }
 }
 
-SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() { return tp_mutex_; }
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+    return tp_mutex_;
+}
 
-SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) {
+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) {
+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_) {
+    for (auto &logger : loggers_)
+    {
         auto logger_entry = log_levels_.find(logger.first);
-        if (logger_entry != log_levels_.end()) {
+        if (logger_entry != log_levels_.end())
+        {
             logger.second->set_level(logger_entry->second);
-        } else if (global_level_requested) {
+        }
+        else if (global_level_requested)
+        {
             logger.second->set_level(*global_level);
         }
     }
 }
 
-SPDLOG_INLINE registry &registry::instance() {
+SPDLOG_INLINE registry &registry::instance()
+{
     static registry s_instance;
     return s_instance;
 }
 
-SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) {
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
-    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+{
-    auto it = log_levels_.find(new_logger->name());
+    if (loggers_.find(logger_name) != loggers_.end())
-    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    {
-    new_logger->set_level(new_level);
-}
-
-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) {
+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);

include/spdlog/details/registry.h

@@ -14,9 +14,9 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <mutex>
 #include <string>
 #include <unordered_map>
+#include <mutex>
 
 namespace spdlog {
 class logger;
@@ -24,7 +24,8 @@ class logger;
 namespace details {
 class thread_pool;
 
-class SPDLOG_API registry {
+class SPDLOG_API registry
+{
 public:
     using log_levels = std::unordered_map<std::string, level::level_enum>;
     registry(const registry &) = delete;
@@ -38,14 +39,11 @@ public:
     // 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
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
-    // another.
     logger *get_default_raw();
 
-    // set default logger and add it to the registry if not registered already.
+    // set default logger.
     // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
-    // Note: Make sure to unregister it when no longer needed or before calling again with a new
-    // logger.
     void set_default_logger(std::shared_ptr<logger> new_default_logger);
 
     void set_tp(std::shared_ptr<thread_pool> tp);
@@ -63,18 +61,14 @@ public:
 
     void flush_on(level::level_enum log_level);
 
-    template <typename Rep, typename Period>
+    template<typename Rep, typename Period>
-    void flush_every(std::chrono::duration<Rep, Period> interval) {
+    void flush_every(std::chrono::duration<Rep, Period> interval)
+    {
         std::lock_guard<std::mutex> lock(flusher_mutex_);
         auto clbk = [this]() { this->flush_all(); };
         periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
     }
 
-    std::unique_ptr<periodic_worker> &get_flusher() {
-        std::lock_guard<std::mutex> lock(flusher_mutex_);
-        return periodic_flusher_;
-    }
-
     void set_error_handler(err_handler handler);
 
     void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
@@ -97,8 +91,6 @@ public:
 
     static registry &instance();
 
-    void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
-
 private:
     registry();
     ~registry();
@@ -125,5 +117,5 @@ private:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "registry-inl.h"
+#    include "registry-inl.h"
 #endif

include/spdlog/details/synchronous_factory.h

@@ -10,9 +10,11 @@ namespace spdlog {
 // Default logger factory-  creates synchronous loggers
 class logger;
 
-struct synchronous_factory {
+struct synchronous_factory
-    template <typename Sink, typename... SinkArgs>
+{
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
+    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);

include/spdlog/details/tcp_client-windows.h

@@ -8,12 +8,12 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-#include <windows.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")
@@ -21,52 +21,69 @@
 
 namespace spdlog {
 namespace details {
-class tcp_client {
+class tcp_client
+{
     SOCKET socket_ = INVALID_SOCKET;
 
-    static void init_winsock_() {
+    static void init_winsock_()
+    {
         WSADATA wsaData;
         auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
-        if (rv != 0) {
+        if (rv != 0)
+        {
             throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
         }
     }
 
-    static void throw_winsock_error_(const std::string &msg, int last_error) {
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
         char buf[512];
-        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
-                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
-                         (sizeof(buf) / sizeof(char)), NULL);
 
         throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
     }
 
 public:
-    tcp_client() { init_winsock_(); }
+    tcp_client()
+    {
+        init_winsock_();
+    }
 
-    ~tcp_client() {
+    ~tcp_client()
+    {
         close();
         ::WSACleanup();
     }
 
-    bool is_connected() const { return socket_ != INVALID_SOCKET; }
+    bool is_connected() const
+    {
+        return socket_ != INVALID_SOCKET;
+    }
 
-    void close() {
+    void close()
+    {
         ::closesocket(socket_);
         socket_ = INVALID_SOCKET;
     }
 
-    SOCKET fd() const { return socket_; }
+    SOCKET fd() const
+    {
+        return socket_;
+    }
 
     // try to connect or throw on failure
-    void connect(const std::string &host, int port) {
+    void connect(const std::string &host, int port)
-        if (is_connected()) {
+    {
+        if (is_connected())
+        {
             close();
         }
-        struct addrinfo hints {};
+        struct addrinfo hints
+        {};
         ZeroMemory(&hints, sizeof(hints));
 
-        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
+        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;
@@ -75,7 +92,8 @@ public:
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
         int last_error = 0;
-        if (rv != 0) {
+        if (rv != 0)
+        {
             last_error = ::WSAGetLastError();
             WSACleanup();
             throw_winsock_error_("getaddrinfo failed", last_error);
@@ -83,41 +101,48 @@ public:
 
         // Try each address until we successfully connect(2).
 
-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
+        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) {
+            if (socket_ == INVALID_SOCKET)
+            {
                 last_error = ::WSAGetLastError();
                 WSACleanup();
                 continue;
             }
-            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) {
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            {
                 break;
-            } else {
+            }
+            else
+            {
                 last_error = ::WSAGetLastError();
                 close();
             }
         }
         ::freeaddrinfo(addrinfo_result);
-        if (socket_ == INVALID_SOCKET) {
+        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),
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(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) {
+    void send(const char *data, size_t n_bytes)
+    {
         size_t bytes_sent = 0;
-        while (bytes_sent < n_bytes) {
+        while (bytes_sent < n_bytes)
+        {
             const int send_flags = 0;
-            auto write_result =
+            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
-                ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR)
-            if (write_result == SOCKET_ERROR) {
+            {
                 int last_error = ::WSAGetLastError();
                 close();
                 throw_winsock_error_("send failed", last_error);

include/spdlog/details/tcp_client.h

@@ -4,47 +4,60 @@
 #pragma once
 
 #ifdef _WIN32
-    #error include tcp_client-windows.h instead
+#    error include tcp_client-windows.h instead
 #endif
 
 // tcp client helper
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.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 {
+class tcp_client
+{
     int socket_ = -1;
 
 public:
-    bool is_connected() const { return socket_ != -1; }
+    bool is_connected() const
+    {
+        return socket_ != -1;
+    }
 
-    void close() {
+    void close()
-        if (is_connected()) {
+    {
+        if (is_connected())
+        {
             ::close(socket_);
             socket_ = -1;
         }
     }
 
-    int fd() const { return socket_; }
+    int fd() const
+    {
+        return socket_;
+    }
 
-    ~tcp_client() { close(); }
+    ~tcp_client()
+    {
+        close();
+    }
 
     // try to connect or throw on failure
-    void connect(const std::string &host, int port) {
+    void connect(const std::string &host, int port)
+    {
         close();
-        struct addrinfo hints {};
+        struct addrinfo hints
+        {};
         memset(&hints, 0, sizeof(struct addrinfo));
-        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
+        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;
@@ -52,25 +65,29 @@ public:
         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) {
+        if (rv != 0)
+        {
             throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
         }
 
         // Try each address until we successfully connect(2).
         int last_errno = 0;
-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
+        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) {
+            if (socket_ == -1)
+            {
                 last_errno = errno;
                 continue;
             }
             rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
-            if (rv == 0) {
+            if (rv == 0)
+            {
                 break;
             }
             last_errno = errno;
@@ -78,39 +95,40 @@ public:
             socket_ = -1;
         }
         ::freeaddrinfo(addrinfo_result);
-        if (socket_ == -1) {
+        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),
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag), sizeof(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),
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
-                     sizeof(enable_flag));
 #endif
 
 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-    #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+#    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) {
+    void send(const char *data, size_t n_bytes)
+    {
         size_t bytes_sent = 0;
-        while (bytes_sent < n_bytes) {
+        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 =
+            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
-                ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0)
-            if (write_result < 0) {
+            {
                 close();
                 throw_spdlog_ex("write(2) failed", errno);
             }

include/spdlog/details/thread_pool-inl.h

@@ -4,26 +4,26 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/details/thread_pool.h>
+#    include <spdlog/details/thread_pool.h>
 #endif
 
-#include <cassert>
 #include <spdlog/common.h>
+#include <cassert>
 
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
+SPDLOG_INLINE thread_pool::thread_pool(
-                                       size_t threads_n,
+    size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
-                                       std::function<void()> on_thread_start,
+    : q_(q_max_items)
-                                       std::function<void()> on_thread_stop)
+{
-    : q_(q_max_items) {
+    if (threads_n == 0 || threads_n > 1000)
-    if (threads_n == 0 || threads_n > 1000) {
+    {
-        throw_spdlog_ex(
+        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
-            "spdlog::thread_pool(): invalid threads_n param (valid "
                         "range is 1-1000)");
     }
-    for (size_t i = 0; i < threads_n; i++) {
+    for (size_t i = 0; i < threads_n; i++)
+    {
         threads_.emplace_back([this, on_thread_start, on_thread_stop] {
             on_thread_start();
             this->thread_pool::worker_loop_();
@@ -32,76 +32,90 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
     }
 }
 
-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
-                                       size_t threads_n,
+    : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
-                                       std::function<void()> on_thread_start)
+{}
-    : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {}
 
 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
     : thread_pool(
-          q_max_items, threads_n, [] {}, [] {}) {}
+          q_max_items, threads_n, [] {}, [] {})
+{}
 
 // message all threads to terminate gracefully join them
-SPDLOG_INLINE thread_pool::~thread_pool() {
+SPDLOG_INLINE thread_pool::~thread_pool()
-    SPDLOG_TRY {
+{
-        for (size_t i = 0; i < threads_.size(); i++) {
+    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_) {
+        for (auto &t : threads_)
+        {
             t.join();
         }
     }
     SPDLOG_CATCH_STD
 }
 
-void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
-                                         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,
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
-                                           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::overrun_counter()
+{
+    return q_.overrun_counter();
+}
 
-void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); }
+void SPDLOG_INLINE thread_pool::reset_overrun_counter()
+{
+    q_.reset_overrun_counter();
+}
 
-size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); }
+size_t SPDLOG_INLINE thread_pool::queue_size()
+{
+    return q_.size();
+}
 
-void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); }
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
-
+{
-size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); }
+    if (overflow_policy == async_overflow_policy::block)
-
+    {
-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 if (overflow_policy == async_overflow_policy::overrun_oldest) {
+    }
+    else
+    {
         q_.enqueue_nowait(std::move(new_msg));
-    } else {
-        assert(overflow_policy == async_overflow_policy::discard_new);
-        q_.enqueue_if_have_room(std::move(new_msg));
     }
 }
 
-void SPDLOG_INLINE thread_pool::worker_loop_() {
+void SPDLOG_INLINE thread_pool::worker_loop_()
-    while (process_next_msg_()) {
+{
-    }
+    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_() {
+bool SPDLOG_INLINE thread_pool::process_next_msg_()
+{
     async_msg incoming_async_msg;
-    q_.dequeue(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) {
+    switch (incoming_async_msg.msg_type)
+    {
     case async_msg_type::log: {
         incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
         return true;

include/spdlog/details/thread_pool.h

@@ -8,10 +8,10 @@
 #include <spdlog/details/os.h>
 
 #include <chrono>
-#include <functional>
 #include <memory>
 #include <thread>
 #include <vector>
+#include <functional>
 
 namespace spdlog {
 class async_logger;
@@ -20,11 +20,17 @@ namespace details {
 
 using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
 
-enum class async_msg_type { log, flush, terminate };
+enum class async_msg_type
+{
+    log,
+    flush,
+    terminate
+};
 
 // Async msg to move to/from the queue
 // Movable only. should never be copied
-struct async_msg : log_msg_buffer {
+struct async_msg : log_msg_buffer
+{
     async_msg_type msg_type{async_msg_type::log};
     async_logger_ptr worker_ptr;
 
@@ -37,11 +43,13 @@ struct async_msg : log_msg_buffer {
 // support for vs2013 move
 #if defined(_MSC_VER) && _MSC_VER <= 1800
     async_msg(async_msg &&other)
-        : log_msg_buffer(std::move(other)),
+        : log_msg_buffer(std::move(other))
-          msg_type(other.msg_type),
+        , msg_type(other.msg_type)
-          worker_ptr(std::move(other.worker_ptr)) {}
+        , worker_ptr(std::move(other.worker_ptr))
+    {}
 
-    async_msg &operator=(async_msg &&other) {
+    async_msg &operator=(async_msg &&other)
+    {
         *static_cast<log_msg_buffer *>(this) = std::move(other);
         msg_type = other.msg_type;
         worker_ptr = std::move(other.worker_ptr);
@@ -54,28 +62,29 @@ struct async_msg : log_msg_buffer {
 
     // construct from log_msg with given type
     async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
-        : log_msg_buffer{m},
+        : log_msg_buffer{m}
-          msg_type{the_type},
+        , msg_type{the_type}
-          worker_ptr{std::move(worker)} {}
+        , worker_ptr{std::move(worker)}
+    {}
 
     async_msg(async_logger_ptr &&worker, async_msg_type the_type)
-        : log_msg_buffer{},
+        : log_msg_buffer{}
-          msg_type{the_type},
+        , msg_type{the_type}
-          worker_ptr{std::move(worker)} {}
+        , worker_ptr{std::move(worker)}
+    {}
 
     explicit async_msg(async_msg_type the_type)
-        : async_msg{nullptr, the_type} {}
+        : async_msg{nullptr, the_type}
+    {}
 };
 
-class SPDLOG_API 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,
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop);
-                size_t threads_n,
-                std::function<void()> on_thread_start,
-                std::function<void()> on_thread_stop);
     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);
 
@@ -85,14 +94,10 @@ public:
     thread_pool(const thread_pool &) = delete;
     thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr,
+    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
-                  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();
     void reset_overrun_counter();
-    size_t discard_counter();
-    void reset_discard_counter();
     size_t queue_size();
 
 private:
@@ -113,5 +118,5 @@ private:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "thread_pool-inl.h"
+#    include "thread_pool-inl.h"
 #endif

include/spdlog/details/udp_client-windows.h

@@ -9,44 +9,47 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 #include <spdlog/details/windows_include.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
 #include <winsock2.h>
 #include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
 
-#if defined(_MSC_VER)
+#pragma comment(lib, "Ws2_32.lib")
-    #pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
-    #pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
-    #pragma comment(lib, "AdvApi32.lib")
-#endif
 
 namespace spdlog {
 namespace details {
-class udp_client {
+class udp_client
+{
     static constexpr int TX_BUFFER_SIZE = 1024 * 10;
     SOCKET socket_ = INVALID_SOCKET;
-    sockaddr_in addr_ = {};
+    sockaddr_in addr_ = {0};
 
-    static void init_winsock_() {
+    static void init_winsock_()
+    {
         WSADATA wsaData;
         auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
-        if (rv != 0) {
+        if (rv != 0)
+        {
             throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
         }
     }
 
-    static void throw_winsock_error_(const std::string &msg, int last_error) {
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
         char buf[512];
-        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
-                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
-                         (sizeof(buf) / sizeof(char)), NULL);
 
         throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
     }
 
-    void cleanup_() {
+    void cleanup_()
-        if (socket_ != INVALID_SOCKET) {
+    {
+        if (socket_ != INVALID_SOCKET)
+        {
             ::closesocket(socket_);
         }
         socket_ = INVALID_SOCKET;
@@ -54,42 +57,52 @@ class udp_client {
     }
 
 public:
-    udp_client(const std::string &host, uint16_t port) {
+    udp_client(const std::string &host, uint16_t port)
+    {
         init_winsock_();
 
         addr_.sin_family = PF_INET;
         addr_.sin_port = htons(port);
         addr_.sin_addr.s_addr = INADDR_ANY;
-        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) {
+        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1)
+        {
             int last_error = ::WSAGetLastError();
             ::WSACleanup();
             throw_winsock_error_("error: Invalid address!", last_error);
         }
 
         socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
-        if (socket_ == INVALID_SOCKET) {
+        if (socket_ == INVALID_SOCKET)
+        {
             int last_error = ::WSAGetLastError();
             ::WSACleanup();
             throw_winsock_error_("error: Create Socket failed", last_error);
         }
 
         int option_value = TX_BUFFER_SIZE;
-        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
-                         reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
+        {
             int last_error = ::WSAGetLastError();
             cleanup_();
             throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error);
         }
     }
 
-    ~udp_client() { cleanup_(); }
+    ~udp_client()
+    {
+        cleanup_();
+    }
 
-    SOCKET fd() const { return socket_; }
+    SOCKET fd() const
+    {
+        return socket_;
+    }
 
-    void send(const char *data, size_t n_bytes) {
+    void send(const char *data, size_t n_bytes)
+    {
         socklen_t tolen = sizeof(struct sockaddr);
-        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_,
+        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1)
-                     tolen) == -1) {
+        {
             throw_spdlog_ex("sendto(2) failed", errno);
         }
     }

include/spdlog/details/udp_client.h

@@ -7,46 +7,51 @@
 // Will throw on construction if the socket creation failed.
 
 #ifdef _WIN32
-    #error "include udp_client-windows.h instead"
+#    error "include udp_client-windows.h instead"
 #endif
 
-#include <arpa/inet.h>
-#include <cstring>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
+
 #include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 #include <unistd.h>
+#include <netdb.h>
+#include <netinet/udp.h>
 
 #include <string>
 
 namespace spdlog {
 namespace details {
 
-class udp_client {
+class udp_client
+{
     static constexpr int TX_BUFFER_SIZE = 1024 * 10;
     int socket_ = -1;
     struct sockaddr_in sockAddr_;
 
-    void cleanup_() {
+    void cleanup_()
-        if (socket_ != -1) {
+    {
+        if (socket_ != -1)
+        {
             ::close(socket_);
             socket_ = -1;
         }
     }
 
 public:
-    udp_client(const std::string &host, uint16_t port) {
+    udp_client(const std::string &host, uint16_t port)
+    {
         socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
-        if (socket_ < 0) {
+        if (socket_ < 0)
+        {
             throw_spdlog_ex("error: Create Socket Failed!");
         }
 
         int option_value = TX_BUFFER_SIZE;
-        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
-                         reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
+        {
             cleanup_();
             throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
         }
@@ -54,7 +59,8 @@ public:
         sockAddr_.sin_family = AF_INET;
         sockAddr_.sin_port = htons(port);
 
-        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) {
+        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0)
+        {
             cleanup_();
             throw_spdlog_ex("error: Invalid address!");
         }
@@ -62,17 +68,24 @@ public:
         ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
     }
 
-    ~udp_client() { cleanup_(); }
+    ~udp_client()
+    {
+        cleanup_();
+    }
 
-    int fd() const { return socket_; }
+    int fd() const
+    {
+        return socket_;
+    }
 
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
-    void send(const char *data, size_t n_bytes) {
+    void send(const char *data, size_t n_bytes)
+    {
         ssize_t toslen = 0;
         socklen_t tolen = sizeof(struct sockaddr);
-        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1)
-            -1) {
+        {
             throw_spdlog_ex("sendto(2) failed", errno);
         }
     }

include/spdlog/details/windows_include.h

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

include/spdlog/fmt/bin_to_hex.h

@@ -9,13 +9,13 @@
 #include <spdlog/common.h>
 
 #if defined(__has_include)
-    #if __has_include(<version>)
+#    if __has_include(<version>)
-        #include <version>
+#        include <version>
-    #endif
+#    endif
 #endif
 
 #if __cpp_lib_span >= 202002L
-    #include <span>
+#    include <span>
 #endif
 
 //
@@ -39,18 +39,29 @@
 namespace spdlog {
 namespace details {
 
-template <typename It>
+template<typename It>
-class dump_info {
+class dump_info
+{
 public:
     dump_info(It range_begin, It range_end, size_t size_per_line)
-        : begin_(range_begin),
+        : begin_(range_begin)
-          end_(range_end),
+        , end_(range_end)
-          size_per_line_(size_per_line) {}
+        , size_per_line_(size_per_line)
+    {}
 
     // do not use begin() and end() to avoid collision with fmt/ranges
-    It get_begin() const { return begin_; }
+    It get_begin() const
-    It get_end() const { return end_; }
+    {
-    size_t size_per_line() const { return size_per_line_; }
+        return begin_;
+    }
+    It get_end() const
+    {
+        return end_;
+    }
+    size_t size_per_line() const
+    {
+        return size_per_line_;
+    }
 
 private:
     It begin_, end_;
@@ -59,23 +70,22 @@ private:
 } // namespace details
 
 // create a dump_info that wraps the given container
-template <typename Container>
+template<typename Container>
-inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container,
+inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32)
-                                                                     size_t size_per_line = 32) {
+{
-    static_assert(sizeof(typename Container::value_type) == 1,
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(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);
 }
 
 #if __cpp_lib_span >= 202002L
 
-template <typename Value, size_t Extent>
+template<typename Value, size_t Extent>
 inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
-    const std::span<Value, Extent> &container, size_t size_per_line = 32) {
+    const std::span<Value, Extent> &container, size_t size_per_line = 32)
+{
     using Container = std::span<Value, Extent>;
-    static_assert(sizeof(typename Container::value_type) == 1,
+    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
-                  "sizeof(Container::value_type) != 1");
     using Iter = typename Container::iterator;
     return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
 }
@@ -83,10 +93,9 @@ inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
 #endif
 
 // create dump_info from ranges
-template <typename It>
+template<typename It>
-inline details::dump_info<It> to_hex(const It range_begin,
+inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
-                                     const It range_end,
+{
-                                     size_t size_per_line = 32) {
     return details::dump_info<It>(range_begin, range_end, size_per_line);
 }
 
@@ -100,9 +109,10 @@ namespace
 #endif
 {
 
-template <typename T>
+template<typename T>
-struct formatter<spdlog::details::dump_info<T>, char> {
+struct formatter<spdlog::details::dump_info<T>, char>
-    char delimiter = ' ';
+{
+    const char delimiter = ' ';
     bool put_newlines = true;
     bool put_delimiters = true;
     bool use_uppercase = false;
@@ -110,11 +120,14 @@ struct formatter<spdlog::details::dump_info<T>, char> {
     bool show_ascii = false;
 
     // parse the format string flags
-    template <typename ParseContext>
+    template<typename ParseContext>
-    SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
         auto it = ctx.begin();
-        while (it != ctx.end() && *it != '}') {
+        while (it != ctx.end() && *it != '}')
-            switch (*it) {
+        {
+            switch (*it)
+            {
             case 'X':
                 use_uppercase = true;
                 break;
@@ -129,7 +142,8 @@ struct formatter<spdlog::details::dump_info<T>, char> {
                 show_ascii = false;
                 break;
             case 'a':
-                    if (put_newlines) {
+                if (put_newlines)
+                {
                     show_ascii = true;
                 }
                 break;
@@ -141,9 +155,9 @@ struct formatter<spdlog::details::dump_info<T>, char> {
     }
 
     // format the given bytes range as hex
-    template <typename FormatContext, typename Container>
+    template<typename FormatContext, typename Container>
-    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const
+    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
-        -> 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;
@@ -156,15 +170,18 @@ struct formatter<spdlog::details::dump_info<T>, char> {
 
         int size_per_line = static_cast<int>(the_range.size_per_line());
         auto start_of_line = the_range.get_begin();
-        for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) {
+        for (auto i = the_range.get_begin(); i != the_range.get_end(); i++)
+        {
             auto ch = static_cast<unsigned char>(*i);
 
-            if (put_newlines &&
+            if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line))
-                (i == the_range.get_begin() || i - start_of_line >= size_per_line)) {
+            {
-                if (show_ascii && i != the_range.get_begin()) {
+                if (show_ascii && i != the_range.get_begin())
+                {
                     *inserter++ = delimiter;
                     *inserter++ = delimiter;
-                    for (auto j = start_of_line; j < i; j++) {
+                    for (auto j = start_of_line; j < i; j++)
+                    {
                         auto pc = static_cast<unsigned char>(*j);
                         *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
                     }
@@ -179,7 +196,8 @@ struct formatter<spdlog::details::dump_info<T>, char> {
                 continue;
             }
 
-            if (put_delimiters && i != the_range.get_begin()) {
+            if (put_delimiters)
+            {
                 *inserter++ = delimiter;
             }
 
@@ -188,19 +206,23 @@ struct formatter<spdlog::details::dump_info<T>, char> {
         }
         if (show_ascii) // add ascii to last line
         {
-            if (the_range.get_end() - the_range.get_begin() > size_per_line) {
+            if (the_range.get_end() - the_range.get_begin() > size_per_line)
+            {
                 auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
-                while (blank_num-- > 0) {
+                while (blank_num-- > 0)
+                {
                     *inserter++ = delimiter;
                     *inserter++ = delimiter;
-                    if (put_delimiters) {
+                    if (put_delimiters)
+                    {
                         *inserter++ = delimiter;
                     }
                 }
             }
             *inserter++ = delimiter;
             *inserter++ = delimiter;
-            for (auto j = start_of_line; j != the_range.get_end(); j++) {
+            for (auto j = start_of_line; j != the_range.get_end(); j++)
+            {
                 auto pc = static_cast<unsigned char>(*j);
                 *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
             }
@@ -209,14 +231,16 @@ struct formatter<spdlog::details::dump_info<T>, char> {
     }
 
     // put newline(and position header)
-    template <typename It>
+    template<typename It>
-    void put_newline(It inserter, std::size_t pos) const {
+    void put_newline(It inserter, std::size_t pos)
+    {
 #ifdef _WIN32
         *inserter++ = '\r';
 #endif
         *inserter++ = '\n';
 
-        if (put_positions) {
+        if (put_positions)
+        {
             spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
         }
     }

include/spdlog/fmt/bundled/args.h

@@ -1,4 +1,4 @@
-// Formatting library for C++ - dynamic argument lists
+// Formatting library for C++ - dynamic format arguments
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@@ -8,39 +8,34 @@
 #ifndef FMT_ARGS_H_
 #define FMT_ARGS_H_
 
-#ifndef FMT_MODULE
+#include <functional>  // std::reference_wrapper
-#  include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
-#  include <memory>      // std::unique_ptr
+#include <vector>
-#  include <vector>
-#endif
 
-#include "format.h"  // std_string_view
+#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> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T> const T& unwrap(const T& v) { return v; }
-template <typename T>
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
-auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
   return static_cast<const T&>(v);
 }
 
-// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
+class dynamic_arg_list {
-// 2022 (v17.10.0).
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-//
+  // templates it doesn't complain about inability to deduce single translation
-// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // unit for placing vtable. So storage_node_base is made a fake template.
-// templates it doesn't complain about inability to deduce single translation
+  template <typename = void> struct node {
-// unit for placing vtable. So node is made a fake template.
-template <typename = void> struct node {
     virtual ~node() = default;
     std::unique_ptr<node<>> next;
-};
+  };
 
-class dynamic_arg_list {
   template <typename T> struct typed_node : node<> {
     T value;
 
@@ -55,7 +50,7 @@ class dynamic_arg_list {
   std::unique_ptr<node<>> head_;
 
  public:
-  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+  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_);
@@ -66,18 +61,28 @@ class dynamic_arg_list {
 }  // namespace detail
 
 /**
- * A dynamic list of formatting arguments with storage.
+  \rst
- *
+  A dynamic version of `fmt::format_arg_store`.
- * It can be implicitly converted into `fmt::basic_format_args` for passing
+  It's equipped with a storage to potentially temporary objects which lifetimes
- * into type-erased formatting functions such as `fmt::vformat`.
+  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 {
+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, char_type>::value;
+        detail::mapped_type_constant<T, Context>::value;
 
     enum {
       value = !(detail::is_reference_wrapper<T>::value ||
@@ -90,7 +95,7 @@ template <typename Context> class dynamic_format_arg_store {
   };
 
   template <typename T>
-  using stored_t = conditional_t<
+  using stored_type = conditional_t<
       std::is_convertible<T, std::basic_string<char_type>>::value &&
           !detail::is_reference_wrapper<T>::value,
       std::basic_string<char_type>, T>;
@@ -105,71 +110,79 @@ template <typename Context> class dynamic_format_arg_store {
 
   friend class basic_format_args<Context>;
 
-  auto data() const -> const basic_format_arg<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(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())
+    if (named_info_.empty()) {
-      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
-    data_.emplace_back(detail::unwrap(arg.value));
+      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] = {named_info_.data(), named_info_.size()};
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
     guard.release();
   }
 
  public:
   constexpr dynamic_format_arg_store() = default;
 
-  operator basic_format_args<Context>() const {
-    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
-                                      !named_info_.empty());
-  }
-
   /**
-   * Adds an argument into the dynamic store for later passing to a formatting
+    \rst
-   * function.
+    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.
+    Note that custom types and string types (but not string views) are copied
-   *
+    into the store dynamically allocating memory if necessary.
-   * **Example**:
+
-   *
+    **Example**::
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+
-   *     store.push_back(42);
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     store.push_back("abc");
+      store.push_back(42);
-   *     store.push_back(1.5f);
+      store.push_back("abc");
-   *     std::string result = fmt::vformat("{} and {} and {}", store);
+      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_t<T>>(arg));
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
     else
       emplace_arg(detail::unwrap(arg));
   }
 
   /**
-   * Adds a reference to the argument into the dynamic store for later passing
+    \rst
-   * to a formatting function.
+    Adds a reference to the argument into the dynamic store for later passing to
-   *
+    a formatting function.
-   * **Example**:
+
-   *
+    **Example**::
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+
-   *     char band[] = "Rolling Stones";
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     store.push_back(std::cref(band));
+      char band[] = "Rolling Stones";
-   *     band[9] = 'c'; // Changing str affects the output.
+      store.push_back(std::cref(band));
-   *     std::string result = fmt::vformat("{}", store);
+      band[9] = 'c'; // Changing str affects the output.
-   *     // result == "Rolling Scones"
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
   */
   template <typename T> void push_back(std::reference_wrapper<T> arg) {
     static_assert(
@@ -179,9 +192,9 @@ template <typename Context> class dynamic_format_arg_store {
   }
 
   /**
-   * Adds named argument into the dynamic store for later passing to a
+    Adds named argument into the dynamic store for later passing to a formatting
-   * formatting function. `std::reference_wrapper` is supported to avoid
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
-   * copying of the argument. The name is always copied into the store.
+    argument. The name is always copied into the store.
   */
   template <typename T>
   void push_back(const detail::named_arg<char_type, T>& arg) {
@@ -189,30 +202,31 @@ template <typename Context> class dynamic_format_arg_store {
         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_t<T>>(arg.value)));
+          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.
+  /** Erase all elements from the store */
   void clear() {
     data_.clear();
     named_info_.clear();
-    dynamic_args_ = {};
+    dynamic_args_ = detail::dynamic_arg_list();
   }
 
-  /// Reserves space to store at least `new_cap` arguments including
+  /**
-  /// `new_cap_named` named arguments.
+    \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");
+               "Set of arguments includes set of named arguments");
     data_.reserve(new_cap);
     named_info_.reserve(new_cap_named);
   }
-
-  /// Returns the number of elements in the store.
-  size_t size() const noexcept { return data_.size(); }
 };
 
 FMT_END_NAMESPACE

include/spdlog/fmt/bundled/color.h

@@ -11,7 +11,7 @@
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 enum class color : uint32_t {
   alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@@ -203,7 +203,7 @@ struct rgb {
   uint8_t b;
 };
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
@@ -225,21 +225,22 @@ struct color_type {
     uint32_t rgb_color;
   } value;
 };
-}  // namespace detail
 
-/// A text style consisting of foreground and background colors and emphasis.
+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()) noexcept
       : set_foreground_color(), set_background_color(), ems(em) {}
 
-  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
+  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)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
       foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
     }
 
@@ -248,7 +249,7 @@ class text_style {
       background_color = rhs.background_color;
     } else if (rhs.set_background_color) {
       if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        report_error("can't OR a terminal color");
+        FMT_THROW(format_error("can't OR a terminal color"));
       background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
     }
 
@@ -257,29 +258,29 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-      -> text_style {
+                                            const text_style& rhs) {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_foreground() const noexcept {
     return set_foreground_color;
   }
-  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_background() const noexcept {
     return set_background_color;
   }
-  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
+  FMT_CONSTEXPR bool has_emphasis() const noexcept {
     return static_cast<uint8_t>(ems) != 0;
   }
-  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
+  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
     FMT_ASSERT(has_foreground(), "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
+  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
     FMT_ASSERT(has_background(), "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
+  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
     FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
     return ems;
   }
@@ -297,11 +298,9 @@ class text_style {
     }
   }
 
-  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
-      -> text_style;
 
-  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
-      -> text_style;
 
   detail::color_type foreground_color;
   detail::color_type background_color;
@@ -310,27 +309,24 @@ class text_style {
   emphasis ems;
 };
 
-/// Creates a text style from the foreground (text) color.
+/** Creates a text style from the foreground (text) color. */
-FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
-    -> text_style {
   return text_style(true, foreground);
 }
 
-/// Creates a text style from the background color.
+/** Creates a text style from the background color. */
-FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
-    -> text_style {
   return text_style(false, background);
 }
 
-FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
-    -> text_style {
   return text_style(lhs) | rhs;
 }
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
                                   const char* esc) noexcept {
     // If we have a terminal color, we need to output another escape code
     // sequence.
@@ -389,9 +385,9 @@ template <typename Char> struct ansi_color_escape {
   }
   FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
 
-  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
+  FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; }
-  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
-    return buffer + basic_string_view<Char>(buffer).size();
+    return buffer + std::char_traits<Char>::length(buffer);
   }
 
  private:
@@ -405,152 +401,194 @@ template <typename Char> struct ansi_color_escape {
     out[2] = static_cast<Char>('0' + c % 10);
     out[3] = static_cast<Char>(delimiter);
   }
-  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+  static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept {
-      -> bool {
     return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
   }
 };
 
 template <typename Char>
-FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    -> ansi_color_escape<Char> {
+    detail::color_type foreground) noexcept {
   return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    -> ansi_color_escape<Char> {
+    detail::color_type background) noexcept {
   return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
-    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(em);
 }
 
+template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
+  int result = std::fputs(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
+  int result = std::fputws(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <typename Char> inline void reset_color(FILE* stream) {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) {
+  fputs(L"\x1b[0m", stream);
+}
+
 template <typename Char> inline void reset_color(buffer<Char>& buffer) {
   auto reset_color = string_view("\x1b[0m");
   buffer.append(reset_color.begin(), reset_color.end());
 }
 
-template <typename T> struct styled_arg : view {
+template <typename T> struct styled_arg {
   const T& value;
   text_style style;
-  styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };
 
 template <typename Char>
 void vformat_to(buffer<Char>& buf, const text_style& ts,
-                basic_string_view<Char> fmt,
+                basic_string_view<Char> format_str,
-                basic_format_args<buffered_context<Char>> args) {
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
   bool has_style = false;
   if (ts.has_emphasis()) {
     has_style = true;
-    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
     buf.append(emphasis.begin(), emphasis.end());
   }
   if (ts.has_foreground()) {
     has_style = true;
-    auto foreground = make_foreground_color<Char>(ts.get_foreground());
+    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 = make_background_color<Char>(ts.get_background());
+    auto background = detail::make_background_color<Char>(ts.get_background());
     buf.append(background.begin(), background.end());
   }
-  vformat_to(buf, fmt, args);
+  detail::vformat_to(buf, format_str, args, {});
-  if (has_style) reset_color<Char>(buf);
+  if (has_style) detail::reset_color<Char>(buf);
 }
-}  // namespace detail
 
-inline void vprint(FILE* f, const text_style& ts, string_view fmt,
+FMT_END_DETAIL_NAMESPACE
-                   format_args args) {
+
-  auto buf = memory_buffer();
+template <typename S, typename Char = char_t<S>>
-  detail::vformat_to(buf, ts, fmt, args);
+void vprint(std::FILE* f, const text_style& ts, const S& format,
-  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+  if (detail::is_utf8()) {
+    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+  } else {
+    buf.push_back(Char(0));
+    detail::fputs(buf.data(), f);
+  }
 }
 
 /**
- * Formats a string and prints it to the specified file stream using ANSI
+  \rst
- * escape sequences to specify text formatting.
+  Formats a string and prints it to the specified file stream using ANSI
- *
+  escape sequences to specify text formatting.
- * **Example**:
+
- *
+  **Example**::
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
  */
-template <typename... T>
+template <typename S, typename... Args,
-void print(FILE* f, const text_style& ts, format_string<T...> fmt,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
-           T&&... args) {
+void print(std::FILE* f, const text_style& ts, const S& format_str,
-  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }
 
 /**
- * Formats a string and prints it to stdout using ANSI escape sequences to
+  \rst
- * specify text formatting.
+  Formats a string and prints it to stdout using ANSI escape sequences to
- *
+  specify text formatting.
- * **Example**:
+
- *
+  **Example**::
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+
- *                "Elapsed time: {0:.2f} seconds", 1.23);
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
  */
-template <typename... T>
+template <typename S, typename... Args,
-void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
-  return print(stdout, ts, fmt, std::forward<T>(args)...);
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
 }
 
-inline auto vformat(const text_style& ts, string_view fmt, format_args args)
+template <typename S, typename Char = char_t<S>>
-    -> std::string {
+inline std::basic_string<Char> vformat(
-  auto buf = memory_buffer();
+    const text_style& ts, const S& format_str,
-  detail::vformat_to(buf, ts, fmt, args);
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
   return fmt::to_string(buf);
 }
 
 /**
- * Formats arguments and returns the result as a string using ANSI escape
+  \rst
- * sequences to specify text formatting.
+  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);
- * ```
- */
-template <typename... T>
-inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
-}
 
-/// Formats a string with the given text_style and writes the output to `out`.
+  **Example**::
-template <typename OutputIt,
+
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+    #include <fmt/color.h>
-auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
-                format_args args) -> OutputIt {
+                                      "The answer is {}", 42);
-  auto&& buf = detail::get_buffer<char>(out);
+  \endrst
-  detail::vformat_to(buf, ts, fmt, args);
+*/
-  return detail::get_iterator(buf, out);
+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, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 /**
- * Formats arguments with the given text style, writes the result to the output
+  Formats a string with the given text_style and writes the output to ``out``.
- * 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);
  */
-template <typename OutputIt, typename... T,
+template <typename OutputIt, typename Char,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-inline auto format_to(OutputIt out, const text_style& ts,
+OutputIt vformat_to(
-                      format_string<T...> fmt, T&&... args) -> OutputIt {
+    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
-  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
+    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, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }
 
 template <typename T, typename Char>
@@ -559,44 +597,47 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
   auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     const auto& ts = arg.style;
+    const auto& value = arg.value;
     auto out = ctx.out();
 
     bool has_style = false;
     if (ts.has_emphasis()) {
       has_style = true;
       auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-      out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
+      out = std::copy(emphasis.begin(), emphasis.end(), out);
     }
     if (ts.has_foreground()) {
       has_style = true;
       auto foreground =
           detail::make_foreground_color<Char>(ts.get_foreground());
-      out = detail::copy<Char>(foreground.begin(), foreground.end(), out);
+      out = std::copy(foreground.begin(), foreground.end(), out);
     }
     if (ts.has_background()) {
       has_style = true;
       auto background =
           detail::make_background_color<Char>(ts.get_background());
-      out = detail::copy<Char>(background.begin(), background.end(), out);
+      out = std::copy(background.begin(), background.end(), out);
     }
-    out = formatter<T, Char>::format(arg.value, ctx);
+    out = formatter<T, Char>::format(value, ctx);
     if (has_style) {
       auto reset_color = string_view("\x1b[0m");
-      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
     }
     return out;
   }
 };
 
 /**
- * Returns an argument that will be formatted using ANSI escape sequences,
+  \rst
- * to be used in a formatting function.
+  Returns an argument that will be formatted using ANSI escape sequences,
- *
+  to be used in a formatting function.
- * **Example**:
+
- *
+  **Example**::
- *     fmt::print("Elapsed time: {0:.2f} seconds",
+
- *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
+    fmt::print("Elapsed time: {0:.2f} seconds",
- *                                  fmt::bg(fmt::color::blue)));
+               fmt::styled(1.23, fmt::fg(fmt::color::green) |
+                                 fmt::bg(fmt::color::blue)));
+  \endrst
  */
 template <typename T>
 FMT_CONSTEXPR auto styled(const T& value, text_style ts)
@@ -604,7 +645,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
   return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COLOR_H_

include/spdlog/fmt/bundled/compile.h

@@ -8,41 +8,134 @@
 #ifndef FMT_COMPILE_H_
 #define FMT_COMPILE_H_
 
-#ifndef FMT_MODULE
-#  include <iterator>  // std::back_inserter
-#endif
-
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR 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;
+  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
+
+  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.
-FMT_EXPORT class compiled_string {};
+class compiled_string {};
 
 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};
 
-namespace detail {
-
 /**
- * Converts a string literal `s` into a format string that will be parsed at
+  \rst
- * compile time and converted into efficient formatting code. Requires C++17
+  Converts a string literal *s* into a format string that will be parsed at
- * `constexpr if` compiler support.
+  compile time and converted into efficient formatting code. Requires C++17
- *
+  ``constexpr if`` compiler support.
- * **Example**:
+
- *
+  **Example**::
- *     // Converts 42 into std::string using the most efficient method and no
+
- *     // runtime format string processing.
+    // Converts 42 into std::string using the most efficient method and no
- *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
  */
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
+#  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_ARGS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  explicit constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
 template <typename T, typename... Tail>
-auto first(const T& value, const Tail&...) -> const T& {
+const T& first(const T& value, const Tail&...) {
   return value;
 }
 
@@ -60,29 +153,6 @@ constexpr const auto& get([[maybe_unused]] const T& first,
     return detail::get<N - 1>(rest...);
 }
 
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_static_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#  endif
-
-template <typename... Args, typename Char>
-FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#  endif
-  (void)name;
-  return -1;
-}
-
 template <typename Char, typename... Args>
 constexpr int get_arg_index_by_name(basic_string_view<Char> name,
                                     type_list<Args...>) {
@@ -126,8 +196,7 @@ template <typename Char> struct code_unit {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&...) const {
-    *out++ = value;
+    return write<Char>(out, value);
-    return out;
   }
 };
 
@@ -151,13 +220,7 @@ template <typename Char, typename T, int N> struct field {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    const T& arg = get_arg_checked<T, N>(args...);
+    return write<Char>(out, get_arg_checked<T, N>(args...));
-    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
-      auto s = basic_string_view<Char>(arg);
-      return copy<Char>(s.begin(), s.end(), out);
-    } else {
-      return write<Char>(out, arg);
-    }
   }
 };
 
@@ -245,12 +308,13 @@ constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
 }
 
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt);
+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 fmt) {
+constexpr auto parse_tail(T head, S format_str) {
-  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
+  if constexpr (POS !=
-    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
+                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;
@@ -267,14 +331,14 @@ template <typename T, typename Char> struct parse_specs_result {
   int next_arg_id;
 };
 
-enum { manual_indexing_id = -1 };
+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 =
+  auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
-      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
+                                         next_arg_id);
   auto f = formatter<T, Char>();
   auto end = f.parse(ctx);
   return {f, pos + fmt::detail::to_unsigned(end - str.data()),
@@ -282,36 +346,36 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 }
 
 template <typename Char> struct arg_id_handler {
-  arg_id_kind kind;
   arg_ref<Char> arg_id;
 
-  constexpr int on_auto() {
+  constexpr int operator()() {
     FMT_ASSERT(false, "handler cannot be used with automatic indexing");
     return 0;
   }
-  constexpr int on_index(int id) {
+  constexpr int operator()(int id) {
-    kind = arg_id_kind::index;
     arg_id = arg_ref<Char>(id);
     return 0;
   }
-  constexpr int on_name(basic_string_view<Char> id) {
+  constexpr int operator()(basic_string_view<Char> id) {
-    kind = arg_id_kind::name;
     arg_id = arg_ref<Char>(id);
     return 0;
   }
+
+  constexpr void on_error(const char* message) {
+    FMT_THROW(format_error(message));
+  }
 };
 
 template <typename Char> struct parse_arg_id_result {
-  arg_id_kind kind;
   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_id_kind::none, arg_ref<Char>{}};
+  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.kind, handler.arg_id, arg_id_end};
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
 }
 
 template <typename T, typename Enable = void> struct field_type {
@@ -325,13 +389,14 @@ struct field_type<T, enable_if_t<detail::is_named_arg<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 fmt) {
+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>(fmt);
+  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>(), fmt);
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
   } else if constexpr (c != ':') {
     FMT_THROW(format_error("expected ':'"));
   } else {
@@ -344,7 +409,7 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
       return parse_tail<Args, result.end + 1, result.next_arg_id>(
           spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
               result.fmt},
-          fmt);
+          format_str);
     }
   }
 }
@@ -352,21 +417,22 @@ constexpr auto parse_replacement_field_then_tail(S fmt) {
 // 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 fmt) {
+constexpr auto compile_format_string(S format_str) {
   using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr auto str = basic_string_view<char_type>(format_str);
   if constexpr (str[POS] == '{') {
     if constexpr (POS + 1 == str.size())
       FMT_THROW(format_error("unmatched '{' in format string"));
     if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+      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>(fmt);
+                                               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());
@@ -374,62 +440,68 @@ constexpr auto compile_format_string(S fmt) {
       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.kind == arg_id_kind::index) {
+      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.index;
+        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>(
-            fmt);
+            format_str);
-      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
+      } 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.name, Args{});
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
-        if constexpr (arg_index >= 0) {
+        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>(fmt);
+              arg_index, next_id>(format_str);
-        } else if constexpr (c == '}') {
+        } else {
+          if constexpr (c == '}') {
             return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
+                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())
       FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+    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), fmt);
+      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]}, fmt);
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
     }
   }
 }
 
 template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-constexpr auto compile(S fmt) {
+constexpr auto compile(S format_str) {
-  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
+  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>(fmt);
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
     return result;
   }
 }
 #endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
 
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 
@@ -451,7 +523,7 @@ constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          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) {
@@ -478,7 +550,7 @@ FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
 }
 
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          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)>,
@@ -493,47 +565,47 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
 #endif
 
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
-    -> format_to_n_result<OutputIt> {
+                                         const S& format_str, Args&&... args) {
-  using traits = detail::fixed_buffer_traits;
+  auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+                           format_str, std::forward<Args>(args)...);
-  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
+  return {it.base(), it.count()};
-  return {buf.out(), buf.count()};
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
+FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
-    -> size_t {
+                                      const Args&... args) {
-  auto buf = detail::counting_buffer<>();
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
-  fmt::format_to(appender(buf), fmt, args...);
+      .count();
-  return buf.count();
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& fmt, const Args&... args) {
+void print(std::FILE* f, const S& format_str, const Args&... args) {
-  auto buf = memory_buffer();
+  memory_buffer buffer;
-  fmt::format_to(appender(buf), fmt, args...);
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
-  detail::print(f, {buf.data(), buf.size()});
+  detail::print(f, {buffer.data(), buffer.size()});
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(const S& fmt, const Args&... args) {
+void print(const S& format_str, const Args&... args) {
-  print(stdout, fmt, args...);
+  print(stdout, format_str, args...);
 }
 
 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail::fixed_string Str> constexpr auto operator""_cf() {
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
-  return FMT_COMPILE(Str.data);
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
+                                     Str>();
 }
 }  // namespace literals
 #endif
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COMPILE_H_

include/spdlog/fmt/bundled/locale.h

@@ -0,0 +1,2 @@
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead

include/spdlog/fmt/bundled/os.h

@@ -8,19 +8,17 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_
 
+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#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"
 
-#ifndef FMT_MODULE
-#  include <cerrno>
-#  include <cstddef>
-#  include <cstdio>
-#  include <system_error>  // std::system_error
-
-#  if FMT_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
-#  endif
-#endif  // FMT_MODULE
-
 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
 #  if FMT_HAS_INCLUDE("winapifamily.h")
@@ -48,7 +46,6 @@
 
 // Calls to system functions are wrapped in FMT_SYSTEM for testability.
 #ifdef FMT_SYSTEM
-#  define FMT_HAS_SYSTEM
 #  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
 #  define FMT_SYSTEM(call) ::call
@@ -74,89 +71,143 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 /**
- * A reference to a null-terminated string. It can be constructed from a C
+  \rst
- * string or `std::string`.
+  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:
+
- *
+  You can use one of the following type aliases for common character types:
- * +---------------+-----------------------------+
+
- * | Type          | Definition                  |
+  +---------------+-----------------------------+
- * +===============+=============================+
+  | Type          | Definition                  |
- * | cstring_view  | basic_cstring_view<char>    |
+  +===============+=============================+
- * +---------------+-----------------------------+
+  | cstring_view  | basic_cstring_view<char>    |
- * | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
- * +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
- *
+  +---------------+-----------------------------+
- * This class is most useful as a parameter type for functions that wrap C APIs.
+
+  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.
+  /** Constructs a string reference object from a C string. */
   basic_cstring_view(const Char* s) : data_(s) {}
 
-  /// Constructs a string reference from an `std::string` object.
+  /**
+    \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.
+  /** Returns the pointer to a C string. */
-  auto c_str() const -> const Char* { return data_; }
+  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() noexcept;
 
-namespace detail {
+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) noexcept;
-}
+FMT_END_DETAIL_NAMESPACE
 
-FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                          format_args args);
 
 /**
- * Constructs a `std::system_error` object with the description of the form
+ \rst
- *
+ Constructs a :class:`std::system_error` object with the description
- *     <message>: <system-message>
+ of the form
- *
+
- * where `<message>` is the formatted message and `<system-message>` is the
+ .. parsed-literal::
- * system message corresponding to the error code.
+   *<message>*: *<system-message>*
- * `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
+ where *<message>* is the formatted message and *<system-message>* is the
- * will look like "error -1".
+ system message corresponding to the error code.
- *
+ *error_code* is a Windows error code as given by ``GetLastError``.
- * **Example**:
+ If *error_code* is not a valid error code such as -1, the system message
- *
+ will look like "error -1".
- *     // This throws a system_error with the description
+
- *     //   cannot open file 'madeup': The system cannot find the file
+ **Example**::
- * specified.
+
- *     // or similar (system message may vary).
+   // This throws a system_error with the description
- *     const char *filename = "madeup";
+   //   cannot open file 'madeup': The system cannot find the file specified.
- *     LPOFSTRUCT of = LPOFSTRUCT();
+   // or similar (system message may vary).
- *     HFILE file = OpenFile(filename, &of, OF_READ);
+   const char *filename = "madeup";
- *     if (file == HFILE_ERROR) {
+   LPOFSTRUCT of = LPOFSTRUCT();
- *       throw fmt::windows_error(GetLastError(),
+   HFILE file = OpenFile(filename, &of, OF_READ);
- *                                "cannot open file '{}'", filename);
+   if (file == HFILE_ERROR) {
- *     }
+     throw fmt::windows_error(GetLastError(),
- */
+                              "cannot open file '{}'", filename);
-template <typename... T>
+   }
-auto windows_error(int error_code, string_view message, const T&... args)
+ \endrst
-    -> std::system_error {
+*/
-  return vwindows_error(error_code, message, vargs<T...>{{args...}});
+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) noexcept;
 #else
-inline auto system_category() noexcept -> const std::error_category& {
+inline const std::error_category& system_category() noexcept {
   return std::system_category();
 }
 #endif  // _WIN32
@@ -164,8 +215,8 @@ inline auto system_category() noexcept -> const std::error_category& {
 // 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& fmt, Args&&... args) {
+void say(const S& format_str, Args&&... args) {
-  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
 }
 #endif
 
@@ -176,24 +227,24 @@ class buffered_file {
 
   friend class file;
 
-  inline explicit buffered_file(FILE* f) : file_(f) {}
+  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.
-  inline buffered_file() noexcept : file_(nullptr) {}
+  buffered_file() noexcept : file_(nullptr) {}
 
   // Destroys the object closing the file it represents if any.
   FMT_API ~buffered_file() noexcept;
 
  public:
-  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
     other.file_ = nullptr;
   }
 
-  inline auto operator=(buffered_file&& other) -> buffered_file& {
+  buffered_file& operator=(buffered_file&& other) {
     close();
     file_ = other.file_;
     other.file_ = nullptr;
@@ -207,20 +258,21 @@ class buffered_file {
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-  inline auto get() const noexcept -> FILE* { return file_; }
+  FILE* get() const noexcept { return file_; }
 
-  FMT_API auto descriptor() const -> int;
+  FMT_API int descriptor() const;
 
-  template <typename... T>
+  void vprint(string_view format_str, format_args args) {
-  inline void print(string_view fmt, const T&... args) {
+    fmt::vprint(file_, format_str, args);
-    fmt::vargs<T...> vargs = {{args...}};
+  }
-    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
+
-                               : fmt::vprint(file_, fmt, vargs);
+  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 noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
@@ -234,8 +286,6 @@ class FMT_API file {
   // Constructs a file object with a given descriptor.
   explicit file(int fd) : fd_(fd) {}
 
-  friend struct pipe;
-
  public:
   // Possible values for the oflag argument to the constructor.
   enum {
@@ -248,7 +298,7 @@ class FMT_API file {
   };
 
   // Constructs a file object which doesn't represent any file.
-  inline file() noexcept : fd_(-1) {}
+  file() noexcept : fd_(-1) {}
 
   // Opens a file and constructs a file object representing this file.
   file(cstring_view path, int oflag);
@@ -257,10 +307,10 @@ class FMT_API file {
   file(const file&) = delete;
   void operator=(const file&) = delete;
 
-  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
 
   // Move assignment is not noexcept because close may throw.
-  inline auto operator=(file&& other) -> file& {
+  file& operator=(file&& other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -271,24 +321,24 @@ class FMT_API file {
   ~file() noexcept;
 
   // Returns the file descriptor.
-  inline auto descriptor() const noexcept -> int { return fd_; }
+  int descriptor() const noexcept { return fd_; }
 
   // Closes the file.
   void close();
 
   // Returns the file size. The size has signed type for consistency with
   // stat::st_size.
-  auto size() const -> long long;
+  long long size() const;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  auto read(void* buffer, size_t count) -> size_t;
+  size_t read(void* buffer, size_t count);
 
   // Attempts to write count bytes from the specified buffer to the file.
-  auto write(const void* buffer, size_t count) -> size_t;
+  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.
-  static auto dup(int fd) -> file;
+  static file dup(int fd);
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
@@ -298,35 +348,24 @@ class FMT_API file {
   // necessary.
   void dup2(int fd, std::error_code& ec) noexcept;
 
-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  auto fdopen(const char* mode) -> buffered_file;
-
-#  if defined(_WIN32) && !defined(__MINGW32__)
-  // Opens a file and constructs a file object representing this file by
-  // wcstring_view filename. Windows only.
-  static file open_windows_file(wcstring_view path, int oflag);
-#  endif
-};
-
-struct FMT_API pipe {
-  file read_end;
-  file write_end;
-
   // Creates a pipe setting up read_end and write_end file objects for reading
   // and writing respectively.
-  pipe();
+  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.
+  buffered_file fdopen(const char* mode);
 };
 
 // Returns the memory page size.
-auto getpagesize() -> long;
+long getpagesize();
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 struct buffer_size {
-  constexpr buffer_size() = default;
+  buffer_size() = default;
   size_t value = 0;
-  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
+  buffer_size operator=(size_t val) const {
     auto bs = buffer_size();
     bs.value = val;
     return bs;
@@ -337,7 +376,7 @@ struct ostream_params {
   int oflag = file::WRONLY | file::CREATE | file::TRUNC;
   size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
 
-  constexpr ostream_params() {}
+  ostream_params() {}
 
   template <typename... T>
   ostream_params(T... params, int new_oflag) : ostream_params(params...) {
@@ -358,70 +397,82 @@ struct ostream_params {
 #  endif
 };
 
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE
 
-FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
 
-/// A fast buffered output stream for writing from a single thread. Writing from
+/** A fast output stream which is not thread-safe. */
-/// multiple threads without external synchronization may result in a data race.
+class FMT_API ostream final : private detail::buffer<char> {
-class FMT_API ostream : private detail::buffer<char> {
  private:
   file file_;
 
-  ostream(cstring_view path, const detail::ostream_params& params);
+  void grow(size_t) override;
 
-  static void grow(buffer<char>& buf, size_t);
+  ostream(cstring_view path, const detail::ostream_params& params)
-
+      : file_(path, params.oflag) {
- public:
+    set(new char[params.buffer_size], params.buffer_size);
-  ostream(ostream&& other) noexcept;
-  ~ostream();
-
-  operator writer() {
-    detail::buffer<char>& buf = *this;
-    return buf;
   }
 
-  inline void flush() {
+ 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();
+  }
+
+  void flush() {
     if (size() == 0) return;
-    file_.write(data(), size() * sizeof(data()[0]));
+    file_.write(data(), size());
     clear();
   }
 
   template <typename... T>
-  friend auto output_file(cstring_view path, T... params) -> ostream;
+  friend ostream output_file(cstring_view path, T... params);
 
-  inline void close() {
+  void close() {
     flush();
     file_.close();
   }
 
-  /// Formats `args` according to specifications in `fmt` and writes the
+  /**
-  /// output to the file.
+    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(appender(*this), fmt.str, vargs<T...>{{args...}});
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
   }
 };
 
 /**
- * Opens a file for writing. Supported parameters passed in `params`:
+  \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)
+  * ``<integer>``: Flags passed to `open
- *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
- * - `buffer_size=<integer>`: Output buffer size
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
- *
+  * ``buffer_size=<integer>``: Output buffer size
- * **Example**:
+
- *
+  **Example**::
- *     auto out = fmt::output_file("guide.txt");
+
- *     out.print("Don't {}", "Panic");
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
  */
 template <typename... T>
-inline auto output_file(cstring_view path, T... params) -> ostream {
+inline ostream output_file(cstring_view path, T... params) {
   return {path, detail::ostream_params(params...)};
 }
 #endif  // FMT_USE_FCNTL
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_OS_H_

include/spdlog/fmt/bundled/ostream.h

@@ -8,53 +8,108 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#ifndef FMT_MODULE
+#include <fstream>
-#  include <fstream>  // std::filebuf
+#include <ostream>
-#endif
+#if defined(_WIN32) && defined(__GLIBCXX__)
-
-#ifdef _WIN32
-#  ifdef __GLIBCXX__
 #  include <ext/stdio_filebuf.h>
 #  include <ext/stdio_sync_filebuf.h>
-#  endif
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
-#  include <io.h>
+#  include <__std_stream>
 #endif
 
-#include "chrono.h"  // formatbuf
+#include "format.h"
-
-#ifdef _MSVC_STL_UPDATE
-#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
-#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
-#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
-#else
-#  define FMT_MSVC_STL_UPDATE 0
-#endif
 
 FMT_BEGIN_NAMESPACE
+
+template <typename OutputIt, typename Char> class basic_printf_context;
+
 namespace detail {
 
+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
+ private:
+  template <typename U>
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
+
+  template <typename> static auto test(...) -> std::false_type;
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    enable_if_t<
+        std::is_arithmetic<T>::value || std::is_array<T>::value ||
+        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
+        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+        std::is_same<T, std_string_view<Char>>::value ||
+        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type {};
+
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
 struct file_access_tag {};
 }  // namespace
-template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
+template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
 class file_access {
   friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };
 
-#if FMT_MSVC_STL_UPDATE
+#if FMT_MSC_VERSION
 template class file_access<file_access_tag, std::filebuf,
                            &std::filebuf::_Myfile>;
 auto get_file(std::filebuf&) -> FILE*;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+template class file_access<file_access_tag, std::__stdoutbuf<char>,
+                           &std::__stdoutbuf<char>::__file_>;
+auto get_file(std::__stdoutbuf<char>&) -> FILE*;
 #endif
 
+inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+#if FMT_MSC_VERSION
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  FILE* c_file;
+  if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else
+    return false;
+  if (c_file) return write_console(c_file, data);
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#else
+  ignore_unused(os, data);
+#endif
+  return false;
+}
+inline bool write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) {
+  return false;
+}
+
 // Write the content of buf to os.
 // It is a separate function rather than a part of vprint to simplify testing.
 template <typename Char>
 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
   const Char* buf_data = buf.data();
-  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
+  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 {
@@ -65,9 +120,20 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
   } while (size != 0);
 }
 
-template <typename T> struct streamed_view {
+template <typename Char, typename T>
-  const T& value;
+void format_value(buffer<Char>& buf, const T& value,
-};
+                  locale_ref loc = locale_ref()) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&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);
+}
+
+template <typename T> struct streamed_view { const T& value; };
+
 }  // namespace detail
 
 // Formats an object of type T that has an overloaded ostream operator<<.
@@ -75,14 +141,11 @@ template <typename Char>
 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
   void set_debug_format() = delete;
 
-  template <typename T, typename Context>
+  template <typename T, typename OutputIt>
-  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
+      -> OutputIt {
     auto buffer = basic_memory_buffer<Char>();
-    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
+    format_value(buffer, value, ctx.locale());
-    auto&& output = std::basic_ostream<Char>(&formatbuf);
-    output.imbue(std::locale::classic());  // The default is always unlocalized.
-    output << value;
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
     return formatter<basic_string_view<Char>, Char>::format(
         {buffer.data(), buffer.size()}, ctx);
   }
@@ -93,72 +156,80 @@ using ostream_formatter = basic_ostream_formatter<char>;
 template <typename T, typename Char>
 struct formatter<detail::streamed_view<T>, Char>
     : basic_ostream_formatter<Char> {
-  template <typename Context>
+  template <typename OutputIt>
-  auto format(detail::streamed_view<T> view, Context& ctx) const
+  auto format(detail::streamed_view<T> view,
-      -> decltype(ctx.out()) {
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
     return basic_ostream_formatter<Char>::format(view.value, ctx);
   }
 };
 
 /**
- * Returns a view that formats `value` via an ostream `operator<<`.
+  \rst
- *
+  Returns a view that formats `value` via an ostream ``operator<<``.
- * **Example**:
+
- *
+  **Example**::
- *     fmt::print("Current thread id: {}\n",
+
- *                fmt::streamed(std::this_thread::get_id()));
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
  */
 template <typename T>
-constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
+auto streamed(const T& value) -> detail::streamed_view<T> {
   return {value};
 }
 
-inline void vprint(std::ostream& os, string_view fmt, format_args args) {
+namespace detail {
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : basic_ostream_formatter<Char> {
+  using basic_ostream_formatter<Char>::format;
+};
+
+inline void vprint_directly(std::ostream& os, string_view format_str,
+                            format_args args) {
   auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
+  detail::vformat_to(buffer, format_str, args);
-  FILE* f = nullptr;
+  detail::write_buffer(os, buffer);
-#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
+}
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+
-    f = detail::get_file(*buf);
+}  // namespace detail
-#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
+
-  auto* rdbuf = os.rdbuf();
+FMT_MODULE_EXPORT template <typename Char>
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+void vprint(std::basic_ostream<Char>& os,
-    f = sfbuf->file();
+            basic_string_view<type_identity_t<Char>> format_str,
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-    f = fbuf->file();
+  auto buffer = basic_memory_buffer<Char>();
-#endif
+  detail::vformat_to(buffer, format_str, args);
-#ifdef _WIN32
+  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
-    }
-  }
-#endif
-  detail::ignore_unused(f);
   detail::write_buffer(os, buffer);
 }
 
 /**
- * Prints formatted data to the stream `os`.
+  \rst
- *
+  Prints formatted data to the stream *os*.
- * **Example**:
+
- *
+  **Example**::
- *     fmt::print(cerr, "Don't {}!", "panic");
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
  */
-FMT_EXPORT template <typename... T>
+FMT_MODULE_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::vargs<T...> vargs = {{args...}};
+  const auto& vargs = fmt::make_format_args(args...);
-  if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
+  if (detail::is_utf8())
-  auto buffer = memory_buffer();
+    vprint(os, fmt, vargs);
-  detail::vformat_to(buffer, fmt.str, vargs);
+  else
-  detail::write_buffer(os, buffer);
+    detail::vprint_directly(os, fmt, vargs);
 }
 
-FMT_EXPORT template <typename... T>
+FMT_MODULE_EXPORT
-void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
+template <typename... Args>
-  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+void print(std::wostream& os,
+           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+           Args&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 }
 
 FMT_END_NAMESPACE

include/spdlog/fmt/bundled/printf.h

@@ -8,121 +8,107 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#ifndef FMT_MODULE
+#include <algorithm>  // std::max
-#  include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
-#  include <limits>     // std::numeric_limits
-#endif
 
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
-template <typename T> struct printf_formatter {
+template <typename T> struct printf_formatter { printf_formatter() = delete; };
-  printf_formatter() = delete;
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
 };
 
-template <typename Char> class basic_printf_context {
+template <typename OutputIt, typename Char> class basic_printf_context {
  private:
-  basic_appender<Char> out_;
+  OutputIt out_;
   basic_format_args<basic_printf_context> args_;
 
-  static_assert(std::is_same<Char, char>::value ||
-                    std::is_same<Char, wchar_t>::value,
-                "Unsupported code unit type.");
-
  public:
   using char_type = Char;
-  using parse_context_type = parse_context<Char>;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
   template <typename T> using formatter_type = printf_formatter<T>;
-  enum { builtin_types = 1 };
 
-  /// Constructs a `printf_context` object. References to the arguments are
+  /**
-  /// stored in the context object so make sure they have appropriate lifetimes.
+    \rst
-  basic_printf_context(basic_appender<Char> out,
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(OutputIt out,
                        basic_format_args<basic_printf_context> args)
       : out_(out), args_(args) {}
 
-  auto out() -> basic_appender<Char> { return out_; }
+  OutputIt out() { return out_; }
-  void advance_to(basic_appender<Char>) {}
+  void advance_to(OutputIt it) { out_ = it; }
 
-  auto locale() -> detail::locale_ref { return {}; }
+  detail::locale_ref locale() { return {}; }
 
-  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
+  format_arg arg(int id) const { return args_.get(id); }
-    return args_.get(id);
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
   }
 };
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out =
-      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
-  template <typename T> static auto fits_in_int(T value) -> bool {
+  template <typename T> static bool fits_in_int(T value) {
-    unsigned max = to_unsigned(max_value<int>());
+    unsigned max = max_value<int>();
     return value <= max;
   }
-  inline static auto fits_in_int(bool) -> bool { return true; }
+  static bool fits_in_int(bool) { return true; }
 };
 
 template <> struct int_checker<true> {
-  template <typename T> static auto fits_in_int(T value) -> bool {
+  template <typename T> static bool fits_in_int(T value) {
     return value >= (std::numeric_limits<int>::min)() &&
            value <= max_value<int>();
   }
-  inline static auto fits_in_int(int) -> bool { return true; }
+  static bool fits_in_int(int) { return true; }
 };
 
-struct printf_precision_handler {
+class printf_precision_handler {
+ public:
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> int {
+  int operator()(T value) {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      report_error("number is too big");
+      FMT_THROW(format_error("number is too big"));
     return (std::max)(static_cast<int>(value), 0);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> int {
+  int operator()(T) {
-    report_error("precision is not integer");
+    FMT_THROW(format_error("precision is not integer"));
     return 0;
   }
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-struct is_zero_int {
+class is_zero_int {
+ public:
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> bool {
+  bool operator()(T value) {
     return value == 0;
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> bool {
+  bool operator()(T) {
     return false;
   }
 };
 
 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
 
-template <> struct make_unsigned_or_bool<bool> {
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };
-  using type = bool;
-};
 
 template <typename T, typename Context> class arg_converter {
  private:
@@ -145,19 +131,24 @@ template <typename T, typename Context> class arg_converter {
     using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
     if (const_check(sizeof(target_type) <= sizeof(int))) {
       // Extra casts are used to silence warnings.
-      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+      if (is_signed) {
-      if (is_signed)
+        arg_ = detail::make_arg<Context>(
-        arg_ = static_cast<int>(static_cast<target_type>(value));
+            static_cast<int>(static_cast<target_type>(value)));
-      else
-        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
       } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = detail::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
         // glibc's printf doesn't sign extend arguments of smaller types:
         //   std::printf("%lld", -42);  // prints "4294967254"
         // but we don't have to do the same because it's a UB.
-      if (is_signed)
+        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
-        arg_ = static_cast<long long>(value);
+      } else {
-      else
+        arg_ = detail::make_arg<Context>(
-        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
     }
   }
 
@@ -171,7 +162,7 @@ template <typename T, typename Context> class arg_converter {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  arg.visit(arg_converter<T, Context>(arg, type));
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
@@ -184,7 +175,8 @@ template <typename Context> class char_converter {
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   void operator()(T value) {
-    arg_ = static_cast<typename Context::char_type>(value);
+    arg_ = detail::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@@ -194,148 +186,150 @@ template <typename Context> class char_converter {
 // An argument visitor that return a pointer to a C string if argument is a
 // string or null otherwise.
 template <typename Char> struct get_cstring {
-  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
+  template <typename T> const Char* operator()(T) { return nullptr; }
-  auto operator()(const Char* s) -> const Char* { return s; }
+  const Char* operator()(const Char* s) { return s; }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class printf_width_handler {
+template <typename Char> class printf_width_handler {
  private:
+  using format_specs = basic_format_specs<Char>;
+
   format_specs& specs_;
 
  public:
-  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> unsigned {
+  unsigned operator()(T value) {
     auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
     if (detail::is_negative(value)) {
-      specs_.set_align(align::left);
+      specs_.align = align::left;
       width = 0 - width;
     }
-    unsigned int_max = to_unsigned(max_value<int>());
+    unsigned int_max = max_value<int>();
-    if (width > int_max) report_error("number is too big");
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
     return static_cast<unsigned>(width);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> unsigned {
+  unsigned operator()(T) {
-    report_error("width is not integer");
+    FMT_THROW(format_error("width is not integer"));
     return 0;
   }
 };
 
-// Workaround for a bug with the XL compiler when initializing
+// The ``printf`` argument formatter.
-// printf_arg_formatter's base class.
+template <typename OutputIt, typename Char>
-template <typename Char>
-auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
-    -> arg_formatter<Char> {
-  return {iter, s, locale_ref()};
-}
-
-// The `printf` argument formatter.
-template <typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
  private:
   using base = arg_formatter<Char>;
-  using context_type = basic_printf_context<Char>;
+  using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;
 
   context_type& context_;
 
-  void write_null_pointer(bool is_string = false) {
+  OutputIt write_null_pointer(bool is_string = false) {
     auto s = this->specs;
-    s.set_type(presentation_type::none);
+    s.type = presentation_type::none;
-    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
+    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
-  }
-
-  template <typename T> void write(T value) {
-    detail::write<Char>(this->out, value, this->specs, this->locale);
   }
 
  public:
-  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
-                       context_type& ctx)
+      : base{iter, s, locale_ref()}, context_(ctx) {}
-      : base(make_arg_formatter(iter, s)), context_(ctx) {}
 
-  void operator()(monostate value) { write(value); }
+  OutputIt operator()(monostate value) { return base::operator()(value); }
 
   template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  void operator()(T value) {
+  OutputIt operator()(T value) {
     // MSVC2013 fails to compile separate overloads for bool and Char so use
     // std::is_same instead.
-    if (!std::is_same<T, Char>::value) {
+    if (std::is_same<T, Char>::value) {
-      write(value);
+      format_specs fmt_specs = this->specs;
-      return;
+      if (fmt_specs.type != presentation_type::none &&
-    }
+          fmt_specs.type != presentation_type::chr) {
-    format_specs s = this->specs;
-    if (s.type() != presentation_type::none &&
-        s.type() != presentation_type::chr) {
         return (*this)(static_cast<int>(value));
       }
-    s.set_sign(sign::none);
+      fmt_specs.sign = sign::none;
-    s.clear_alt();
+      fmt_specs.alt = false;
-    s.set_fill(' ');  // Ignore '0' flag for char types.
+      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
       // align::numeric needs to be overwritten here since the '0' flag is
       // ignored for non-numeric types
-    if (s.align() == align::none || s.align() == align::numeric)
+      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
-      s.set_align(align::right);
+        fmt_specs.align = align::right;
-    detail::write<Char>(this->out, static_cast<Char>(value), s);
+      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+    }
+    return base::operator()(value);
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  void operator()(T value) {
+  OutputIt operator()(T value) {
-    write(value);
+    return base::operator()(value);
   }
 
-  void operator()(const char* value) {
+  /** Formats a null-terminated C string. */
-    if (value)
+  OutputIt operator()(const char* value) {
-      write(value);
+    if (value) return base::operator()(value);
-    else
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
-  void operator()(const wchar_t* value) {
+  /** Formats a null-terminated wide C string. */
-    if (value)
+  OutputIt operator()(const wchar_t* value) {
-      write(value);
+    if (value) return base::operator()(value);
-    else
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
-  void operator()(basic_string_view<Char> value) { write(value); }
+  OutputIt operator()(basic_string_view<Char> value) {
-
+    return base::operator()(value);
-  void operator()(const void* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer();
   }
 
-  void operator()(typename basic_format_arg<context_type>::handle handle) {
+  /** Formats a pointer. */
-    auto parse_ctx = parse_context<Char>({});
+  OutputIt operator()(const void* value) {
+    return value ? base::operator()(value) : write_null_pointer();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx =
+        basic_printf_parse_context<Char>(basic_string_view<Char>());
     handle.format(parse_ctx, context_);
+    return this->out;
   }
 };
 
 template <typename Char>
-void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
-    case '-': specs.set_align(align::left); break;
+    case '-':
-    case '+': specs.set_sign(sign::plus); break;
+      specs.align = align::left;
-    case '0': specs.set_fill('0'); break;
-    case ' ':
-      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
       break;
-    case '#': specs.set_alt(); break;
+    case '+':
-    default:  return;
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) {
+        specs.sign = sign::space;
+      }
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
     }
   }
 }
 
 template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs& specs,
+int parse_header(const Char*& it, const Char* end,
-                  GetArg get_arg) -> int {
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
   int arg_index = -1;
   Char c = *it;
   if (c >= '0' && c <= '9') {
@@ -346,11 +340,11 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
       ++it;
       arg_index = value != -1 ? value : max_value<int>();
     } else {
-      if (c == '0') specs.set_fill('0');
+      if (c == '0') specs.fill[0] = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
-        if (value == -1) report_error("number is too big");
+        if (value == -1) FMT_THROW(format_error("number is too big"));
         specs.width = value;
         return arg_index;
       }
@@ -361,47 +355,23 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
   if (it != end) {
     if (*it >= '0' && *it <= '9') {
       specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) report_error("number is too big");
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
     } else if (*it == '*') {
       ++it;
-      specs.width = static_cast<int>(
+      specs.width = static_cast<int>(visit_format_arg(
-          get_arg(-1).visit(detail::printf_width_handler(specs)));
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
     }
   }
   return arg_index;
 }
 
-inline auto parse_printf_presentation_type(char c, type t, bool& upper)
-    -> presentation_type {
-  using pt = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  switch (c) {
-  case 'd': return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o': return in(t, integral_set) ? pt::oct : pt::none;
-  case 'X': upper = true; FMT_FALLTHROUGH;
-  case 'x': return in(t, integral_set) ? pt::hex : pt::none;
-  case 'E': upper = true; FMT_FALLTHROUGH;
-  case 'e': return in(t, float_set) ? pt::exp : pt::none;
-  case 'F': upper = true; FMT_FALLTHROUGH;
-  case 'f': return in(t, float_set) ? pt::fixed : pt::none;
-  case 'G': upper = true; FMT_FALLTHROUGH;
-  case 'g': return in(t, float_set) ? pt::general : pt::none;
-  case 'A': upper = true; FMT_FALLTHROUGH;
-  case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;
-  case 'c': return in(t, integral_set) ? pt::chr : pt::none;
-  case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:  return pt::none;
-  }
-}
-
 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
              basic_format_args<Context> args) {
-  using iterator = basic_appender<Char>;
+  using OutputIt = buffer_appender<Char>;
-  auto out = iterator(buf);
+  auto out = OutputIt(buf);
-  auto context = basic_printf_context<Char>(out, args);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
-  auto parse_ctx = parse_context<Char>(format);
+  auto parse_ctx = basic_printf_parse_context<Char>(format);
 
   // Returns the argument with specified index or, if arg_index is -1, the next
   // argument.
@@ -417,24 +387,26 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
   const Char* end = parse_ctx.end();
   auto it = start;
   while (it != end) {
-    if (!find<false, Char>(it, end, '%', it)) {
+    if (!detail::find<false, Char>(it, end, '%', it)) {
-      it = end;  // find leaves it == nullptr if it doesn't find '%'.
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
       break;
     }
     Char c = *it++;
     if (it != end && *it == c) {
-      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
       start = ++it;
       continue;
     }
-    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
+    out = detail::write(out, basic_string_view<Char>(
+                                 start, detail::to_unsigned(it - 1 - start)));
 
-    auto specs = format_specs();
+    basic_format_specs<Char> specs;
-    specs.set_align(align::right);
+    specs.align = align::right;
 
     // Parse argument index, flags and width.
     int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) report_error("argument not found");
+    if (arg_index == 0) parse_ctx.on_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -444,8 +416,8 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         specs.precision = parse_nonnegative_int(it, end, 0);
       } else if (c == '*') {
         ++it;
-        specs.precision =
+        specs.precision = static_cast<int>(
-            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
       } else {
         specs.precision = 0;
       }
@@ -454,31 +426,32 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     auto arg = get_arg(arg_index);
     // For d, i, o, u, x, and X conversion specifiers, if a precision is
     // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && is_integral_type(arg.type())) {
+    if (specs.precision >= 0 && arg.is_integral())
-      // Ignore '0' for non-numeric types or if '-' present.
+      specs.fill[0] =
-      specs.set_fill(' ');
+          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
-    }
+    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
-    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
+      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
-      auto str = arg.visit(get_cstring<Char>());
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
-      auto sv = basic_string_view<Char>(
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
-          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
+          basic_string_view<Char>(
-      arg = sv;
+              str, detail::to_unsigned(nul != str_end ? nul - str
-    }
+                                                      : specs.precision)));
-    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
-    if (specs.fill_unit<Char>() == '0') {
-      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
-        specs.set_align(align::numeric);
-      } else {
-        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
-        specs.set_fill(' ');
     }
+    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
     }
 
     // Parse length and convert the argument to the required type.
     c = it != end ? *it++ : 0;
     Char t = it != end ? *it : 0;
+    using detail::convert_arg;
     switch (c) {
     case 'h':
       if (t == 'h') {
@@ -498,136 +471,170 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         convert_arg<long>(arg, t);
       }
       break;
-    case 'j': convert_arg<intmax_t>(arg, t); break;
+    case 'j':
-    case 'z': convert_arg<size_t>(arg, t); break;
+      convert_arg<intmax_t>(arg, t);
-    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
+      break;
+    case 'z':
+      convert_arg<size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
     case 'L':
       // printf produces garbage when 'L' is omitted for long double, no
       // need to do the same.
       break;
-    default: --it; convert_arg<void>(arg, c);
+    default:
+      --it;
+      convert_arg<void>(arg, c);
     }
 
     // Parse type.
-    if (it == end) report_error("invalid format string");
+    if (it == end) FMT_THROW(format_error("invalid format string"));
     char type = static_cast<char>(*it++);
-    if (is_integral_type(arg.type())) {
+    if (arg.is_integral()) {
       // Normalize type.
       switch (type) {
       case 'i':
-      case 'u': type = 'd'; break;
+      case 'u':
+        type = 'd';
+        break;
       case 'c':
-        arg.visit(char_converter<basic_printf_context<Char>>(arg));
+        visit_format_arg(
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
         break;
       }
     }
-    bool upper = false;
+    specs.type = parse_presentation_type(type);
-    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
+    if (specs.type == presentation_type::none)
-    if (specs.type() == presentation_type::none)
+      parse_ctx.on_error("invalid type specifier");
-      report_error("invalid format specifier");
-    if (upper) specs.set_upper();
 
     start = it;
 
     // Format argument.
-    arg.visit(printf_arg_formatter<Char>(out, specs, context));
+    out = visit_format_arg(
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
   }
-  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE
 
-using printf_context = basic_printf_context<char>;
+template <typename Char>
-using wprintf_context = basic_printf_context<wchar_t>;
+using basic_printf_context_t =
+    basic_printf_context<detail::buffer_appender<Char>, Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
 
 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
 
-/// Constructs an `format_arg_store` object that contains references to
+/**
-/// arguments and can be implicitly converted to `printf_args`.
+  \rst
-template <typename Char = char, typename... T>
+  Constructs an `~fmt::format_arg_store` object that contains references to
-inline auto make_printf_args(T&... args)
+  arguments and can be implicitly converted to `~fmt::printf_args`.
-    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
+  \endrst
-  return fmt::make_format_args<basic_printf_context<Char>>(args...);
+ */
-}
+template <typename... T>
-
+inline auto make_printf_args(const T&... args)
-template <typename Char> struct vprintf_args {
+    -> format_arg_store<printf_context, T...> {
-  using type = basic_format_args<basic_printf_context<Char>>;
+  return {args...};
-};
-
-template <typename Char>
-inline auto vsprintf(basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  return {buf.data(), buf.size()};
 }
 
 /**
- * Formats `args` according to specifications in `fmt` and returns the result
+  \rst
- * as as string.
+  Constructs an `~fmt::format_arg_store` object that contains references to
- *
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
- * **Example**:
+  \endrst
- *
- *     std::string message = fmt::sprintf("The answer is %d", 42);
  */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
+template <typename... T>
-inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
+inline auto make_wprintf_args(const T&... args)
-  return vsprintf(detail::to_string_view(fmt),
+    -> format_arg_store<wprintf_context, T...> {
-                  fmt::make_format_args<basic_printf_context<Char>>(args...));
+  return {args...};
 }
 
-template <typename Char>
+template <typename S, typename Char = char_t<S>>
-inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
+inline auto vsprintf(
-                     typename vprintf_args<Char>::type args) -> int {
+    const S& fmt,
-  auto buf = basic_memory_buffer<Char>();
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-  detail::vprintf(buf, fmt, args);
+    -> std::basic_string<Char> {
-  size_t size = buf.size();
+  basic_memory_buffer<Char> buffer;
-  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... T,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
+  using context = basic_printf_context_t<Char>;
+  return vsprintf(detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vfprintf(
+    std::FILE* f, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
              : static_cast<int>(size);
 }
 
 /**
- * Formats `args` according to specifications in `fmt` and writes the output
+  \rst
- * to `f`.
+  Prints formatted data to the file *f*.
- *
+
- * **Example**:
+  **Example**::
- *
+
- *     fmt::fprintf(stderr, "Don't %s!", "panic");
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
  */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
+template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
+  using context = basic_printf_context_t<Char>;
   return vfprintf(f, detail::to_string_view(fmt),
-                  make_printf_args<Char>(args...));
+                  fmt::make_format_args<context>(args...));
 }
 
-template <typename Char>
+template <typename S, typename Char = char_t<S>>
-FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
+inline auto vprintf(
-                                   typename vprintf_args<Char>::type args)
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> int {
-  return vfprintf(stdout, fmt, args);
+  return vfprintf(stdout, detail::to_string_view(fmt), args);
 }
 
 /**
- * Formats `args` according to specifications in `fmt` and writes the output
+  \rst
- * to `stdout`.
+  Prints formatted data to ``stdout``.
- *
+
- * **Example**:
+  **Example**::
- *
+
- *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
  */
-template <typename... T>
+template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
-inline auto printf(string_view fmt, const T&... args) -> int {
+inline auto printf(const S& fmt, const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args(args...));
+  return vprintf(
-}
+      detail::to_string_view(fmt),
-template <typename... T>
+      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
-FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
-                                  const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
 }
 
-FMT_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_PRINTF_H_

include/spdlog/fmt/bundled/std.h

@@ -1,726 +0,0 @@
-// Formatting library for C++ - formatters for standard library types
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_STD_H_
-#define FMT_STD_H_
-
-#include "format.h"
-#include "ostream.h"
-
-#ifndef FMT_MODULE
-#  include <atomic>
-#  include <bitset>
-#  include <complex>
-#  include <cstdlib>
-#  include <exception>
-#  include <functional>
-#  include <memory>
-#  include <thread>
-#  include <type_traits>
-#  include <typeinfo>
-#  include <utility>
-#  include <vector>
-
-// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
-#  if FMT_CPLUSPLUS >= 201703L
-#    if FMT_HAS_INCLUDE(<filesystem>) && \
-        (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)
-#      include <filesystem>
-#    endif
-#    if FMT_HAS_INCLUDE(<variant>)
-#      include <variant>
-#    endif
-#    if FMT_HAS_INCLUDE(<optional>)
-#      include <optional>
-#    endif
-#  endif
-// Use > instead of >= in the version check because <source_location> may be
-// available after C++17 but before C++20 is marked as implemented.
-#  if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
-#    include <source_location>
-#  endif
-#  if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
-#    include <expected>
-#  endif
-#endif  // FMT_MODULE
-
-#if FMT_HAS_INCLUDE(<version>)
-#  include <version>
-#endif
-
-// GCC 4 does not support FMT_HAS_INCLUDE.
-#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
-#  include <cxxabi.h>
-// Android NDK with gabi++ library on some architectures does not implement
-// abi::__cxa_demangle().
-#  ifndef __GABIXX_CXXABI_H__
-#    define FMT_HAS_ABI_CXA_DEMANGLE
-#  endif
-#endif
-
-// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
-#ifndef FMT_CPP_LIB_FILESYSTEM
-#  ifdef __cpp_lib_filesystem
-#    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
-#  else
-#    define FMT_CPP_LIB_FILESYSTEM 0
-#  endif
-#endif
-
-#ifndef FMT_CPP_LIB_VARIANT
-#  ifdef __cpp_lib_variant
-#    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
-#  else
-#    define FMT_CPP_LIB_VARIANT 0
-#  endif
-#endif
-
-#if FMT_CPP_LIB_FILESYSTEM
-FMT_BEGIN_NAMESPACE
-
-namespace detail {
-
-template <typename Char, typename PathChar>
-auto get_path_string(const std::filesystem::path& p,
-                     const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
-    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
-  else
-    return p.string<Char>();
-}
-
-template <typename Char, typename PathChar>
-void write_escaped_path(basic_memory_buffer<Char>& quoted,
-                        const std::filesystem::path& p,
-                        const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> &&
-                std::is_same_v<PathChar, wchar_t>) {
-    auto buf = basic_memory_buffer<wchar_t>();
-    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
-    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
-    FMT_ASSERT(valid, "invalid utf16");
-  } else if constexpr (std::is_same_v<Char, PathChar>) {
-    write_escaped_string<std::filesystem::path::value_type>(
-        std::back_inserter(quoted), native);
-  } else {
-    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-  }
-}
-
-}  // namespace detail
-
-FMT_EXPORT
-template <typename Char> struct formatter<std::filesystem::path, Char> {
- private:
-  format_specs specs_;
-  detail::arg_ref<Char> width_ref_;
-  bool debug_ = false;
-  char path_type_ = 0;
-
- public:
-  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    Char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    if (it != end && *it == '?') {
-      debug_ = true;
-      ++it;
-    }
-    if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
-    auto specs = specs_;
-    auto path_string =
-        !path_type_ ? p.native()
-                    : p.generic_string<std::filesystem::path::value_type>();
-
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    if (!debug_) {
-      auto s = detail::get_path_string<Char>(p, path_string);
-      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
-    }
-    auto quoted = basic_memory_buffer<Char>();
-    detail::write_escaped_path(quoted, p, path_string);
-    return detail::write(ctx.out(),
-                         basic_string_view<Char>(quoted.data(), quoted.size()),
-                         specs);
-  }
-};
-
-class path : public std::filesystem::path {
- public:
-  auto display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{}"), base);
-  }
-  auto system_string() const -> std::string { return string(); }
-
-  auto generic_display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{:g}"), base);
-  }
-  auto generic_system_string() const -> std::string { return generic_string(); }
-};
-
-FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_FILESYSTEM
-
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <std::size_t N, typename Char>
-struct formatter<std::bitset<N>, Char>
-    : nested_formatter<basic_string_view<Char>, Char> {
- private:
-  // Functor because C++11 doesn't support generic lambdas.
-  struct writer {
-    const std::bitset<N>& bs;
-
-    template <typename OutputIt>
-    FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
-      for (auto pos = N; pos > 0; --pos) {
-        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
-      }
-
-      return out;
-    }
-  };
-
- public:
-  template <typename FormatContext>
-  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return this->write_padded(ctx, writer{bs});
-  }
-};
-
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
-FMT_END_NAMESPACE
-
-#ifdef __cpp_lib_optional
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::optional<T>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value>> {
- private:
-  formatter<T, Char> underlying_;
-  static constexpr basic_string_view<Char> optional =
-      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
-                             '('>{};
-  static constexpr basic_string_view<Char> none =
-      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
-
-  template <class U>
-  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-      -> decltype(u.set_debug_format(set)) {
-    u.set_debug_format(set);
-  }
-
-  template <class U>
-  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    maybe_set_debug_format(underlying_, true);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::optional<T>& opt, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    if (!opt) return detail::write<Char>(ctx.out(), none);
-
-    auto out = ctx.out();
-    out = detail::write<Char>(out, optional);
-    ctx.advance_to(out);
-    out = underlying_.format(*opt, ctx);
-    return detail::write(out, ')');
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_optional
-
-#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Char, typename OutputIt, typename T>
-auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (has_to_string_view<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
-  return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-FMT_END_NAMESPACE
-#endif
-
-#ifdef __cpp_lib_expected
-FMT_BEGIN_NAMESPACE
-
-FMT_EXPORT
-template <typename T, typename E, typename Char>
-struct formatter<std::expected<T, E>, Char,
-                 std::enable_if_t<(std::is_void<T>::value ||
-                                   is_formattable<T, Char>::value) &&
-                                  is_formattable<E, Char>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::expected<T, E>& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    if (value.has_value()) {
-      out = detail::write<Char>(out, "expected(");
-      if constexpr (!std::is_void<T>::value)
-        out = detail::write_escaped_alternative<Char>(out, *value);
-    } else {
-      out = detail::write<Char>(out, "unexpected(");
-      out = detail::write_escaped_alternative<Char>(out, value.error());
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_expected
-
-#ifdef __cpp_lib_source_location
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <> struct formatter<std::source_location> {
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }
-
-  template <typename FormatContext>
-  auto format(const std::source_location& loc, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write(out, loc.file_name());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.line());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.column());
-    out = detail::write(out, ": ");
-    out = detail::write(out, loc.function_name());
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif
-
-#if FMT_CPP_LIB_VARIANT
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T>
-using variant_index_sequence =
-    std::make_index_sequence<std::variant_size<T>::value>;
-
-template <typename> struct is_variant_like_ : std::false_type {};
-template <typename... Types>
-struct is_variant_like_<std::variant<Types...>> : std::true_type {};
-
-// formattable element check.
-template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... Is>
-  static std::conjunction<
-      is_formattable<std::variant_alternative_t<Is, T>, C>...>
-      check(std::index_sequence<Is...>);
-
- public:
-  static constexpr const bool value =
-      decltype(check(variant_index_sequence<T>{}))::value;
-};
-
-}  // namespace detail
-
-template <typename T> struct is_variant_like {
-  static constexpr const bool value = detail::is_variant_like_<T>::value;
-};
-
-template <typename T, typename C> struct is_variant_formattable {
-  static constexpr const bool value =
-      detail::is_variant_formattable_<T, C>::value;
-};
-
-FMT_EXPORT
-template <typename Char> struct formatter<std::monostate, Char> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write<Char>(ctx.out(), "monostate");
-  }
-};
-
-FMT_EXPORT
-template <typename Variant, typename Char>
-struct formatter<
-    Variant, Char,
-    std::enable_if_t<std::conjunction_v<
-        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const Variant& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    out = detail::write<Char>(out, "variant(");
-    FMT_TRY {
-      std::visit(
-          [&](const auto& v) {
-            out = detail::write_escaped_alternative<Char>(out, v);
-          },
-          value);
-    }
-    FMT_CATCH(const std::bad_variant_access&) {
-      detail::write<Char>(out, "valueless by exception");
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-FMT_EXPORT
-template <> struct formatter<std::error_code> {
- private:
-  format_specs specs_;
-  detail::arg_ref<char> width_ref_;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    return it;
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR20 auto format(const std::error_code& ec,
-                              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto specs = specs_;
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    memory_buffer buf;
-    buf.append(string_view(ec.category().name()));
-    buf.push_back(':');
-    detail::write<char>(appender(buf), ec.value());
-    return detail::write<char>(ctx.out(), string_view(buf.data(), buf.size()),
-                               specs);
-  }
-};
-
-#if FMT_USE_RTTI
-namespace detail {
-
-template <typename Char, typename OutputIt>
-auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-  int status = 0;
-  std::size_t size = 0;
-  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-  string_view demangled_name_view;
-  if (demangled_name_ptr) {
-    demangled_name_view = demangled_name_ptr.get();
-
-    // Normalization of stdlib inline namespace names.
-    // libc++ inline namespaces.
-    //  std::__1::*       -> std::*
-    //  std::__1::__fs::* -> std::*
-    // libstdc++ inline namespaces.
-    //  std::__cxx11::*             -> std::*
-    //  std::filesystem::__cxx11::* -> std::filesystem::*
-    if (demangled_name_view.starts_with("std::")) {
-      char* begin = demangled_name_ptr.get();
-      char* to = begin + 5;  // std::
-      for (char *from = to, *end = begin + demangled_name_view.size();
-           from < end;) {
-        // This is safe, because demangled_name is NUL-terminated.
-        if (from[0] == '_' && from[1] == '_') {
-          char* next = from + 1;
-          while (next < end && *next != ':') next++;
-          if (next[0] == ':' && next[1] == ':') {
-            from = next + 2;
-            continue;
-          }
-        }
-        *to++ = *from++;
-      }
-      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-    }
-  } else {
-    demangled_name_view = string_view(ti.name());
-  }
-  return detail::write_bytes<Char>(out, demangled_name_view);
-#  elif FMT_MSC_VERSION
-  const string_view demangled_name(ti.name());
-  for (std::size_t i = 0; i < demangled_name.size(); ++i) {
-    auto sub = demangled_name;
-    sub.remove_prefix(i);
-    if (sub.starts_with("enum ")) {
-      i += 4;
-      continue;
-    }
-    if (sub.starts_with("class ") || sub.starts_with("union ")) {
-      i += 5;
-      continue;
-    }
-    if (sub.starts_with("struct ")) {
-      i += 6;
-      continue;
-    }
-    if (*sub.begin() != ' ') *out++ = *sub.begin();
-  }
-  return out;
-#  else
-  return detail::write_bytes<Char>(out, string_view(ti.name()));
-#  endif
-}
-
-}  // namespace detail
-
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
-                 > {
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename Context>
-  auto format(const std::type_info& ti, Context& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write_demangled_name<Char>(ctx.out(), ti);
-  }
-};
-#endif
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<
-    T, Char,  // DEPRECATED! Mixing code unit types.
-    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
- private:
-  bool with_typename_ = false;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it == end || *it == '}') return it;
-    if (*it == 't') {
-      ++it;
-      with_typename_ = FMT_USE_RTTI != 0;
-    }
-    return it;
-  }
-
-  template <typename Context>
-  auto format(const std::exception& ex, Context& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-#if FMT_USE_RTTI
-    if (with_typename_) {
-      out = detail::write_demangled_name<Char>(out, typeid(ex));
-      *out++ = ':';
-      *out++ = ' ';
-    }
-#endif
-    return detail::write_bytes<Char>(out, string_view(ex.what()));
-  }
-};
-
-namespace detail {
-
-template <typename T, typename Enable = void>
-struct has_flip : std::false_type {};
-
-template <typename T>
-struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
-    : std::true_type {};
-
-template <typename T> struct is_bit_reference_like {
-  static constexpr const bool value =
-      std::is_convertible<T, bool>::value &&
-      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
-};
-
-#ifdef _LIBCPP_VERSION
-
-// Workaround for libc++ incompatibility with C++ standard.
-// According to the Standard, `bitset::operator[] const` returns bool.
-template <typename C>
-struct is_bit_reference_like<std::__bit_const_reference<C>> {
-  static constexpr const bool value = true;
-};
-
-#endif
-
-}  // namespace detail
-
-// We can't use std::vector<bool, Allocator>::reference and
-// std::bitset<N>::reference because the compiler can't deduce Allocator and N
-// in partial specialization.
-FMT_EXPORT
-template <typename BitRef, typename Char>
-struct formatter<BitRef, Char,
-                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
-    : formatter<bool, Char> {
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v, ctx);
-  }
-};
-
-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::atomic<T>, Char,
-                 enable_if_t<is_formattable<T, Char>::value>>
-    : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic<T>& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<T, Char>::format(v.load(), ctx);
-  }
-};
-
-#ifdef __cpp_lib_atomic_flag_test
-FMT_EXPORT
-template <typename Char>
-struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic_flag& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v.test(), ctx);
-  }
-};
-#endif  // __cpp_lib_atomic_flag_test
-
-FMT_EXPORT
-template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
-  template <typename FormatContext, typename OutputIt>
-  FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
-                               detail::dynamic_format_specs<Char>& specs,
-                               FormatContext& ctx, OutputIt out) const
-      -> OutputIt {
-    if (c.real() != 0) {
-      *out++ = Char('(');
-      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
-      specs.set_sign(sign::plus);
-      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-      *out++ = Char('i');
-      *out++ = Char(')');
-      return out;
-    }
-    out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-    if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-    *out++ = Char('i');
-    return out;
-  }
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type_constant<T, Char>::value);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::complex<T>& c, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto specs = specs_;
-    if (specs.dynamic()) {
-      detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
-                                  specs.width_ref, ctx);
-      detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
-                                  specs.precision_ref, ctx);
-    }
-
-    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
-    auto buf = basic_memory_buffer<Char>();
-
-    auto outer_specs = format_specs();
-    outer_specs.width = specs.width;
-    outer_specs.copy_fill_from(specs);
-    outer_specs.set_align(specs.align());
-
-    specs.width = 0;
-    specs.set_fill({});
-    specs.set_align(align::none);
-
-    do_format(c, specs, ctx, basic_appender<Char>(buf));
-    return detail::write<Char>(ctx.out(),
-                               basic_string_view<Char>(buf.data(), buf.size()),
-                               outer_specs);
-  }
-};
-
-FMT_EXPORT
-template <typename T, typename Char>
-struct formatter<std::reference_wrapper<T>, Char,
-                 enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>>
-    : formatter<remove_cvref_t<T>, Char> {
-  template <typename FormatContext>
-  auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx);
-  }
-};
-
-FMT_END_NAMESPACE
-#endif  // FMT_STD_H_

include/spdlog/fmt/bundled/xchar.h

@@ -8,131 +8,52 @@
 #ifndef FMT_XCHAR_H_
 #define FMT_XCHAR_H_
 
-#include "color.h"
+#include <cwchar>
-#include "format.h"
-#include "ostream.h"
-#include "ranges.h"
 
-#ifndef FMT_MODULE
+#include "format.h"
-#  include <cwchar>
-#  if FMT_USE_LOCALE
-#    include <locale>
-#  endif
-#endif
 
 FMT_BEGIN_NAMESPACE
 namespace detail {
-
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-
-template <typename S, typename = void> struct format_string_char {};
-
-template <typename S>
-struct format_string_char<
-    S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
-  using type = char_t<S>;
-};
-
-template <typename S>
-struct format_string_char<
-    S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> {
-  using type = typename S::char_type;
-};
-
-template <typename S>
-using format_string_char_t = typename format_string_char<S>::type;
-
-inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
-                      const format_specs& specs, locale_ref loc) -> bool {
-#if FMT_USE_LOCALE
-  auto& numpunct =
-      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
-  auto separator = std::wstring();
-  auto grouping = numpunct.grouping();
-  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
-  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
-#endif
-  return false;
 }
-}  // namespace detail
 
-FMT_BEGIN_EXPORT
+FMT_MODULE_EXPORT_BEGIN
 
 using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = parse_context<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
-using wformat_context = buffered_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>;
 
-template <typename Char, typename... T> struct basic_fstring {
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
- private:
+// Workaround broken conversion on older gcc.
-  basic_string_view<Char> str_;
+template <typename... Args> using wformat_string = wstring_view;
-
+inline auto runtime(wstring_view s) -> wstring_view { return s; }
-  static constexpr int num_static_named_args =
+#else
-      detail::count_static_named_args<T...>();
+template <typename... Args>
-
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
-  using checker = detail::format_string_checker<
+inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; }
-      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
+#endif
-      num_static_named_args != detail::count_named_args<T...>()>;
-
-  using arg_pack = detail::arg_pack<T...>;
-
- public:
-  using t = basic_fstring;
-
-  template <typename S,
-            FMT_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {
-    if (FMT_USE_CONSTEVAL)
-      detail::parse_format_string<Char>(s, checker(s, arg_pack()));
-  }
-  template <typename S,
-            FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
-                              std::is_same<typename S::char_type, Char>::value)>
-  FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {
-    FMT_CONSTEXPR auto sv = basic_string_view<Char>(S());
-    FMT_CONSTEXPR int ignore =
-        (parse_format_string(sv, checker(sv, arg_pack())), 0);
-    detail::ignore_unused(ignore);
-  }
-  basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  operator basic_string_view<Char>() const { return str_; }
-  auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-template <typename Char, typename... T>
-using basic_format_string = basic_fstring<Char, T...>;
-
-template <typename... T>
-using wformat_string = typename basic_format_string<wchar_t, T...>::t;
-inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
-  return {{s}};
-}
 
 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 {};
 
-#ifdef __cpp_char8_t
+template <typename... Args>
-template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
-#endif
+    const Args&... args) {
-
+  return {args...};
-template <typename... T>
-constexpr auto make_wformat_args(T&... args)
-    -> decltype(fmt::make_format_args<wformat_context>(args...)) {
-  return fmt::make_format_args<wformat_context>(args...);
 }
 
-#if !FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
   return {s};
 }
-}  // namespace literals
 #endif
+}  // namespace literals
 
 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@@ -140,9 +61,9 @@ auto join(It begin, Sentinel end, wstring_view sep)
   return {begin, end, sep};
 }
 
-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
+template <typename Range>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
                  wchar_t> {
   return join(std::begin(range), std::end(range), sep);
 }
@@ -153,19 +74,13 @@ auto join(std::initializer_list<T> list, wstring_view sep)
   return join(std::begin(list), std::end(list), sep);
 }
 
-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-auto join(const Tuple& tuple, basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, Tuple> {
-  return {tuple, sep};
-}
-
 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> fmt,
+auto vformat(basic_string_view<Char> format_str,
-             typename detail::vformat_args<Char>::type args)
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
+  basic_memory_buffer<Char> buffer;
-  detail::vformat_to(buf, fmt, args);
+  detail::vformat_to(buffer, format_str, args);
-  return {buf.data(), buf.size()};
+  return to_string(buffer);
 }
 
 template <typename... T>
@@ -173,130 +88,119 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
   return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
-template <typename OutputIt, typename... T>
-auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, fmt::wstring_view(fmt),
-                    fmt::make_wformat_args(args...));
-}
-
 // 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... T,
+template <typename S, typename... Args, typename Char = char_t<S>,
-          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                         !std::is_same<Char, wchar_t>::value)>
-auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(fmt),
+  return vformat(detail::to_string_view(format_str),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
+                 fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename Locale, typename S,
+template <typename Locale, typename S, typename Char = char_t<S>,
-          typename Char = detail::format_string_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& fmt,
+inline auto vformat(
-                    typename detail::vformat_args<Char>::type args)
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
-  detail::vformat_to(buf, detail::to_string_view(fmt), args,
-                     detail::locale_ref(loc));
-  return {buf.data(), buf.size()};
 }
 
-template <typename Locale, typename S, typename... T,
+template <typename Locale, typename S, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          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& fmt, T&&... args)
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
     -> std::basic_string<Char> {
-  return vformat(loc, detail::to_string_view(fmt),
+  return detail::vformat(loc, detail::to_string_view(format_str),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
+                         fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename OutputIt, typename S,
+template <typename OutputIt, typename S, typename Char = char_t<S>,
-          typename Char = detail::format_string_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& fmt,
+auto vformat_to(OutputIt out, const S& format_str,
-                typename detail::vformat_args<Char>::type args) -> OutputIt {
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, detail::to_string_view(fmt), args);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
-  return detail::get_iterator(buf, out);
+  return detail::get_iterator(buf);
 }
 
-template <typename OutputIt, typename S, typename... T,
+template <typename OutputIt, typename S, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          typename Char = char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                        !std::is_same<Char, char>::value &&
+                            detail::is_exotic_char<Char>::value)>
-                        !std::is_same<Char, wchar_t>::value)>
+inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
-inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
   return vformat_to(out, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          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& fmt,
+inline auto vformat_to(
-                       typename detail::vformat_args<Char>::type args)
+    OutputIt out, const Locale& loc, const S& format_str,
-    -> OutputIt {
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(format_str), args,
-  return detail::get_iterator(buf, out);
+             detail::locale_ref(loc));
+  return detail::get_iterator(buf);
 }
 
-template <typename Locale, typename OutputIt, typename S, typename... T,
+template <
-          typename Char = detail::format_string_char_t<S>,
+    typename OutputIt, typename Locale, typename S, typename... Args,
-          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
+    typename Char = char_t<S>,
-                        detail::is_locale<Locale>::value &&
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
-                        detail::is_exotic_char<Char>::value>
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
-                      T&&... args) ->
+                      Args&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(fmt),
+  return vformat_to(out, loc, to_string_view(format_str),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 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> fmt,
+inline auto vformat_to_n(
-                         typename detail::vformat_args<Char>::type args)
+    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> {
-  using traits = detail::fixed_buffer_traits;
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
-  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
+                                                                           n);
-  detail::vformat_to(buf, fmt, args);
+  detail::vformat_to(buf, format_str, args);
   return {buf.out(), buf.count()};
 }
 
-template <typename OutputIt, typename S, typename... T,
+template <typename OutputIt, typename S, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
+          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, T&&... args)
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
-    -> format_to_n_result<OutputIt> {
+                        const Args&... args) -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
-                      fmt::make_format_args<buffered_context<Char>>(args...));
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename S, typename... T,
+template <typename S, typename... Args, typename Char = char_t<S>,
-          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
-inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
-  auto buf = detail::counting_buffer<Char>();
+  detail::counting_buffer<Char> buf;
   detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmt::make_format_args<buffered_context<Char>>(args...));
+                     fmt::make_format_args<buffer_context<Char>>(args...));
   return buf.count();
 }
 
 inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  auto buf = wmemory_buffer();
+  wmemory_buffer buffer;
-  detail::vformat_to(buf, fmt, args);
+  detail::vformat_to(buffer, fmt, args);
-  buf.push_back(L'\0');
+  buffer.push_back(L'\0');
-  if (std::fputws(buf.data(), f) == -1)
+  if (std::fputws(buffer.data(), f) == -1)
     FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
@@ -313,61 +217,13 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
   return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
-template <typename... T>
+/**
-void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
-  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
+ */
-}
-
-template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
-  return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
-    -> std::wstring {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-template <typename... T>
-inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
-    -> std::wstring {
-  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(std::FILE* f, const text_style& ts,
-                          wformat_string<T...> fmt, const T&... args) {
-  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
-                          const T&... args) {
-  return print(stdout, ts, fmt, args...);
-}
-
-inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
-  auto buffer = basic_memory_buffer<wchar_t>();
-  detail::vformat_to(buffer, fmt, args);
-  detail::write_buffer(os, buffer);
-}
-
-template <typename... T>
-void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
-}
-
-template <typename... T>
-void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(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_END_EXPORT
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_XCHAR_H_

include/spdlog/fmt/chrono.h

@@ -7,17 +7,16 @@
 //
 // include bundled or external copy of fmtlib's chrono support
 //
-#include <spdlog/tweakme.h>
 
 #if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
+#        ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
-            #endif
+#            endif
-        #endif
+#        endif
-        #include <spdlog/fmt/bundled/chrono.h>
+#        include <spdlog/fmt/bundled/chrono.h>
-    #else
+#    else
-        #include <fmt/chrono.h>
+#        include <fmt/chrono.h>
-    #endif
+#    endif
 #endif

include/spdlog/fmt/compile.h

@@ -7,17 +7,16 @@
 //
 // include bundled or external copy of fmtlib's compile-time support
 //
-#include <spdlog/tweakme.h>
 
 #if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
+#        ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
-            #endif
+#            endif
-        #endif
+#        endif
-        #include <spdlog/fmt/bundled/compile.h>
+#        include <spdlog/fmt/bundled/compile.h>
-    #else
+#    else
-        #include <fmt/compile.h>
+#        include <fmt/compile.h>
-    #endif
+#    endif
 #endif

include/spdlog/fmt/fmt.h

@@ -9,22 +9,25 @@
 // Include a bundled header-only copy of fmtlib or an external one.
 // By default spdlog include its own copy.
 //
-#include <spdlog/tweakme.h>
 
 #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format
-    #include <format>
+#    include <format>
 #elif !defined(SPDLOG_FMT_EXTERNAL)
-    #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
+#    if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
-        #define FMT_HEADER_ONLY
+#        define FMT_HEADER_ONLY
-    #endif
+#    endif
-    #ifndef FMT_USE_WINDOWS_H
+#    ifndef FMT_USE_WINDOWS_H
-        #define FMT_USE_WINDOWS_H 0
+#        define FMT_USE_WINDOWS_H 0
-    #endif
+#    endif
+// enable the 'n' flag in for backward compatibility with fmt 6.x
+#    define FMT_DEPRECATED_N_SPECIFIER
+// enable ostream formatting for backward compatibility with fmt 8.x
+#    define FMT_DEPRECATED_OSTREAM
 
-    #include <spdlog/fmt/bundled/core.h>
+#    include <spdlog/fmt/bundled/core.h>
-    #include <spdlog/fmt/bundled/format.h>
+#    include <spdlog/fmt/bundled/format.h>
 
 #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
-    #include <fmt/core.h>
+#    include <fmt/core.h>
-    #include <fmt/format.h>
+#    include <fmt/format.h>
 #endif

include/spdlog/fmt/ostr.h

@@ -7,17 +7,16 @@
 //
 // include bundled or external copy of fmtlib's ostream support
 //
-#include <spdlog/tweakme.h>
 
 #if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
+#        ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
-            #endif
+#            endif
-        #endif
+#        endif
-        #include <spdlog/fmt/bundled/ostream.h>
+#        include <spdlog/fmt/bundled/ostream.h>
-    #else
+#    else
-        #include <fmt/ostream.h>
+#        include <fmt/ostream.h>
-    #endif
+#    endif
 #endif

include/spdlog/fmt/ranges.h

@@ -7,17 +7,16 @@
 //
 // include bundled or external copy of fmtlib's ranges support
 //
-#include <spdlog/tweakme.h>
 
 #if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
+#        ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
-            #endif
+#            endif
-        #endif
+#        endif
-        #include <spdlog/fmt/bundled/ranges.h>
+#        include <spdlog/fmt/bundled/ranges.h>
-    #else
+#    else
-        #include <fmt/ranges.h>
+#        include <fmt/ranges.h>
-    #endif
+#    endif
 #endif

include/spdlog/fmt/std.h

@@ -1,24 +0,0 @@
-//
-// 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 std support (for formatting e.g.
-// std::filesystem::path, std::thread::id, std::monostate, std::variant, ...)
-//
-#include <spdlog/tweakme.h>
-
-#if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
-            #endif
-        #endif
-        #include <spdlog/fmt/bundled/std.h>
-    #else
-        #include <fmt/std.h>
-    #endif
-#endif

include/spdlog/fmt/xchar.h

@@ -7,17 +7,16 @@
 //
 // include bundled or external copy of fmtlib's xchar support
 //
-#include <spdlog/tweakme.h>
 
 #if !defined(SPDLOG_USE_STD_FORMAT)
-    #if !defined(SPDLOG_FMT_EXTERNAL)
+#    if !defined(SPDLOG_FMT_EXTERNAL)
-        #ifdef SPDLOG_HEADER_ONLY
+#        ifdef SPDLOG_HEADER_ONLY
-            #ifndef FMT_HEADER_ONLY
+#            ifndef FMT_HEADER_ONLY
-                #define FMT_HEADER_ONLY
+#                define FMT_HEADER_ONLY
-            #endif
+#            endif
-        #endif
+#        endif
-        #include <spdlog/fmt/bundled/xchar.h>
+#        include <spdlog/fmt/bundled/xchar.h>
-    #else
+#    else
-        #include <fmt/xchar.h>
+#        include <fmt/xchar.h>
-    #endif
+#    endif
 #endif

include/spdlog/formatter.h

@@ -3,12 +3,13 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg.h>
 #include <spdlog/fmt/fmt.h>
+#include <spdlog/details/log_msg.h>
 
 namespace spdlog {
 
-class formatter {
+class formatter
+{
 public:
     virtual ~formatter() = default;
     virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0;

include/spdlog/logger-inl.h

@@ -4,12 +4,12 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/logger.h>
+#    include <spdlog/logger.h>
 #endif
 
+#include <spdlog/sinks/sink.h>
 #include <spdlog/details/backtracer.h>
 #include <spdlog/pattern_formatter.h>
-#include <spdlog/sinks/sink.h>
 
 #include <cstdio>
 
@@ -17,15 +17,15 @@ namespace spdlog {
 
 // public methods
 SPDLOG_INLINE logger::logger(const logger &other)
-    : name_(other.name_),
+    : name_(other.name_)
-      sinks_(other.sinks_),
+    , sinks_(other.sinks_)
-      level_(other.level_.load(std::memory_order_relaxed)),
+    , level_(other.level_.load(std::memory_order_relaxed))
-      flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
+    , flush_level_(other.flush_level_.load(std::memory_order_relaxed))
-      custom_err_handler_(other.custom_err_handler_),
+    , custom_err_handler_(other.custom_err_handler_)
-      tracer_(other.tracer_) {}
+    , tracer_(other.tracer_)
+{}
 
-SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT
+SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)),
-    : name_(std::move(other.name_)),
                                                                sinks_(std::move(other.sinks_)),
                                                                level_(other.level_.load(std::memory_order_relaxed)),
                                                                flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
@@ -34,12 +34,14 @@ SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT
 
 {}
 
-SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT
+{
     this->swap(other);
     return *this;
 }
 
-SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT {
+SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT
+{
     name_.swap(other.name_);
     sinks_.swap(other.sinks_);
 
@@ -57,121 +59,179 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT {
     std::swap(tracer_, other.tracer_);
 }
 
-SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); }
+SPDLOG_INLINE void swap(logger &a, logger &b)
+{
+    a.swap(b);
+}
 
-SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }
+SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
+{
+    level_.store(log_level);
+}
 
-SPDLOG_INLINE level::level_enum logger::level() const {
+SPDLOG_INLINE level::level_enum logger::level() const
+{
     return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
 }
 
-SPDLOG_INLINE const std::string &logger::name() const { return name_; }
+SPDLOG_INLINE const std::string &logger::name() const
+{
+    return name_;
+}
 
 // set formatting for the sinks in this logger.
 // each sink will get a separate instance of the formatter object.
-SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) {
+SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
-    for (auto it = sinks_.begin(); it != sinks_.end(); ++it) {
+{
-        if (std::next(it) == sinks_.end()) {
+    for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
+    {
+        if (std::next(it) == sinks_.end())
+        {
             // last element - we can be move it.
             (*it)->set_formatter(std::move(f));
             break; // to prevent clang-tidy warning
-        } else {
+        }
+        else
+        {
             (*it)->set_formatter(f->clone());
         }
     }
 }
 
-SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) {
+SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type)
+{
     auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
     set_formatter(std::move(new_formatter));
 }
 
 // create new backtrace sink and move to it all our child sinks
-SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); }
+SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages)
+{
+    tracer_.enable(n_messages);
+}
 
 // restore orig sinks and level and delete the backtrace sink
-SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); }
+SPDLOG_INLINE void logger::disable_backtrace()
+{
+    tracer_.disable();
+}
 
-SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); }
+SPDLOG_INLINE void logger::dump_backtrace()
+{
+    dump_backtrace_();
+}
 
 // flush functions
-SPDLOG_INLINE void logger::flush() { flush_(); }
+SPDLOG_INLINE void logger::flush()
+{
+    flush_();
+}
 
-SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); }
+SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
+{
+    flush_level_.store(log_level);
+}
 
-SPDLOG_INLINE level::level_enum logger::flush_level() const {
+SPDLOG_INLINE level::level_enum logger::flush_level() const
+{
     return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
 }
 
 // sinks
-SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const { return sinks_; }
+SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const
+{
+    return sinks_;
+}
 
-SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() { return sinks_; }
+SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
+{
+    return sinks_;
+}
 
 // error handler
-SPDLOG_INLINE void logger::set_error_handler(err_handler handler) {
+SPDLOG_INLINE void logger::set_error_handler(err_handler handler)
+{
     custom_err_handler_ = std::move(handler);
 }
 
 // create new logger with same sinks and configuration.
-SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) {
+SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
+{
     auto cloned = std::make_shared<logger>(*this);
     cloned->name_ = std::move(logger_name);
     return cloned;
 }
 
 // protected methods
-SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg,
+SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
-                                   bool log_enabled,
+{
-                                   bool traceback_enabled) {
+    if (log_enabled)
-    if (log_enabled) {
+    {
         sink_it_(log_msg);
     }
-    if (traceback_enabled) {
+    if (traceback_enabled)
+    {
         tracer_.push_back(log_msg);
     }
 }
 
-SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {
+SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
-    for (auto &sink : sinks_) {
+{
-        if (sink->should_log(msg.level)) {
+    for (auto &sink : sinks_)
-            SPDLOG_TRY { sink->log(msg); }
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
+                sink->log(msg);
+            }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
 
-    if (should_flush_(msg)) {
+    if (should_flush_(msg))
+    {
         flush_();
     }
 }
 
-SPDLOG_INLINE void logger::flush_() {
+SPDLOG_INLINE void logger::flush_()
-    for (auto &sink : sinks_) {
+{
-        SPDLOG_TRY { sink->flush(); }
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
+            sink->flush();
+        }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }
 
-SPDLOG_INLINE void logger::dump_backtrace_() {
+SPDLOG_INLINE void logger::dump_backtrace_()
+{
     using details::log_msg;
-    if (tracer_.enabled() && !tracer_.empty()) {
+    if (tracer_.enabled())
-        sink_it_(
+    {
-            log_msg{name(), level::info, "****************** Backtrace Start ******************"});
+        sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
         tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
-        sink_it_(
+        sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
-            log_msg{name(), level::info, "****************** Backtrace End ********************"});
     }
 }
 
-SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) {
+SPDLOG_INLINE bool 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);
 }
 
-SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
+SPDLOG_INLINE void logger::err_handler_(const std::string &msg)
-    if (custom_err_handler_) {
+{
+    if (custom_err_handler_)
+    {
         custom_err_handler_(msg);
-    } else {
+    }
+    else
+    {
         using std::chrono::system_clock;
         static std::mutex mutex;
         static std::chrono::system_clock::time_point last_report_time;
@@ -179,7 +239,8 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
         std::lock_guard<std::mutex> lk{mutex};
         auto now = system_clock::now();
         err_counter++;
-        if (now - last_report_time < std::chrono::seconds(1)) {
+        if (now - last_report_time < std::chrono::seconds(1))
+        {
             return;
         }
         last_report_time = now;
@@ -187,11 +248,9 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
         char date_buf[64];
         std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
 #if defined(USING_R) && defined(R_R_H) // if in R environment
-        REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(),
+        REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
-                 msg.c_str());
 #else
-        std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf,
+        std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
-                     name().c_str(), msg.c_str());
 #endif
     }
 }

include/spdlog/logger.h

@@ -15,58 +15,67 @@
 // formatted data, and support for different format per sink.
 
 #include <spdlog/common.h>
-#include <spdlog/details/backtracer.h>
 #include <spdlog/details/log_msg.h>
+#include <spdlog/details/backtracer.h>
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    #ifndef _WIN32
+#    ifndef _WIN32
-        #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+#        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
-    #endif
+#    endif
-    #include <spdlog/details/os.h>
+#    include <spdlog/details/os.h>
 #endif
 
 #include <vector>
 
 #ifndef SPDLOG_NO_EXCEPTIONS
-    #define SPDLOG_LOGGER_CATCH(location)                                                 \
+#    define SPDLOG_LOGGER_CATCH(location)                                                                                                  \
-        catch (const std::exception &ex) {                                                \
+        catch (const std::exception &ex)                                                                                                   \
-            if (location.filename) {                                                      \
+        {                                                                                                                                  \
-                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
+            if (location.filename)                                                                                                         \
-                                             location.filename, location.line));          \
+            {                                                                                                                              \
-            } else {                                                                      \
+                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line));              \
+            }                                                                                                                              \
+            else                                                                                                                           \
+            {                                                                                                                              \
                 err_handler_(ex.what());                                                                                                   \
             }                                                                                                                              \
         }                                                                                                                                  \
-        catch (...) {                                                                     \
+        catch (...)                                                                                                                        \
+        {                                                                                                                                  \
             err_handler_("Rethrowing unknown exception in logger");                                                                        \
             throw;                                                                                                                         \
         }
 #else
-    #define SPDLOG_LOGGER_CATCH(location)
+#    define SPDLOG_LOGGER_CATCH(location)
 #endif
 
 namespace spdlog {
 
-class SPDLOG_API logger {
+class SPDLOG_API logger
+{
 public:
     // Empty logger
     explicit logger(std::string name)
-        : name_(std::move(name)),
+        : name_(std::move(name))
-          sinks_() {}
+        , sinks_()
+    {}
 
     // Logger with range on sinks
-    template <typename It>
+    template<typename It>
     logger(std::string name, It begin, It end)
-        : name_(std::move(name)),
+        : name_(std::move(name))
-          sinks_(begin, end) {}
+        , sinks_(begin, end)
+    {}
 
     // Logger with single sink
     logger(std::string name, sink_ptr single_sink)
-        : logger(std::move(name), {std::move(single_sink)}) {}
+        : logger(std::move(name), {std::move(single_sink)})
+    {}
 
     // Logger with sinks init list
     logger(std::string name, sinks_init_list sinks)
-        : logger(std::move(name), sinks.begin(), sinks.end()) {}
+        : logger(std::move(name), sinks.begin(), sinks.end())
+    {}
 
     virtual ~logger() = default;
 
@@ -75,36 +84,37 @@ public:
     logger &operator=(logger other) SPDLOG_NOEXCEPT;
     void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;
 
-    template <typename... Args>
+    template<typename... Args>
-    void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
+    void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args)
-        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
+    {
+        log_(loc, lvl, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
+    void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args)
+    {
         log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename T>
+    template<typename T>
-    void log(level::level_enum lvl, const T &msg) {
+    void log(level::level_enum lvl, const T &msg)
+    {
         log(source_loc{}, lvl, msg);
     }
 
     // T cannot be statically converted to format string (including string_view/wstring_view)
-    template <class T,
+    template<class T, typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value, int>::type = 0>
-              typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value,
+    void log(source_loc loc, level::level_enum lvl, const T &msg)
-                                      int>::type = 0>
+    {
-    void log(source_loc loc, level::level_enum lvl, const T &msg) {
         log(loc, lvl, "{}", msg);
     }
 
-    void log(log_clock::time_point log_time,
+    void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg)
-             source_loc loc,
+    {
-             level::level_enum lvl,
-             string_view_t msg) {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
 
@@ -112,10 +122,12 @@ public:
         log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(source_loc loc, level::level_enum lvl, string_view_t msg) {
+    void log(source_loc loc, level::level_enum lvl, string_view_t msg)
+    {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
 
@@ -123,56 +135,66 @@ public:
         log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); }
+    void log(level::level_enum lvl, string_view_t msg)
+    {
+        log(source_loc{}, lvl, msg);
+    }
 
-    template <typename... Args>
+    template<typename... Args>
-    void trace(format_string_t<Args...> fmt, Args &&...args) {
+    void trace(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::trace, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void debug(format_string_t<Args...> fmt, Args &&...args) {
+    void debug(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::debug, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void info(format_string_t<Args...> fmt, Args &&...args) {
+    void info(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::info, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void warn(format_string_t<Args...> fmt, Args &&...args) {
+    void warn(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::warn, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void error(format_string_t<Args...> fmt, Args &&...args) {
+    void error(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::err, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void critical(format_string_t<Args...> fmt, Args &&...args) {
+    void critical(format_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::critical, fmt, std::forward<Args>(args)...);
     }
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    template <typename... Args>
+    template<typename... Args>
-    void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
+    void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args)
-        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
+    {
+        log_(loc, lvl, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
+    void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
     }
 
-    void log(log_clock::time_point log_time,
+    void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg)
-             source_loc loc,
+    {
-             level::level_enum lvl,
-             wstring_view_t msg) {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
 
@@ -182,10 +204,12 @@ public:
         log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) {
+    void log(source_loc loc, level::level_enum lvl, wstring_view_t msg)
+    {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
 
@@ -195,76 +219,95 @@ public:
         log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); }
+    void log(level::level_enum lvl, wstring_view_t msg)
+    {
+        log(source_loc{}, lvl, msg);
+    }
 
-    template <typename... Args>
+    template<typename... Args>
-    void trace(wformat_string_t<Args...> fmt, Args &&...args) {
+    void trace(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::trace, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void debug(wformat_string_t<Args...> fmt, Args &&...args) {
+    void debug(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::debug, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void info(wformat_string_t<Args...> fmt, Args &&...args) {
+    void info(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::info, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void warn(wformat_string_t<Args...> fmt, Args &&...args) {
+    void warn(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::warn, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void error(wformat_string_t<Args...> fmt, Args &&...args) {
+    void error(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::err, fmt, std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
+    template<typename... Args>
-    void critical(wformat_string_t<Args...> fmt, Args &&...args) {
+    void critical(wformat_string_t<Args...> fmt, Args &&... args)
+    {
         log(level::critical, fmt, std::forward<Args>(args)...);
     }
 #endif
 
-    template <typename T>
+    template<typename T>
-    void trace(const T &msg) {
+    void trace(const T &msg)
+    {
         log(level::trace, msg);
     }
 
-    template <typename T>
+    template<typename T>
-    void debug(const T &msg) {
+    void debug(const T &msg)
+    {
         log(level::debug, msg);
     }
 
-    template <typename T>
+    template<typename T>
-    void info(const T &msg) {
+    void info(const T &msg)
+    {
         log(level::info, msg);
     }
 
-    template <typename T>
+    template<typename T>
-    void warn(const T &msg) {
+    void warn(const T &msg)
+    {
         log(level::warn, msg);
     }
 
-    template <typename T>
+    template<typename T>
-    void error(const T &msg) {
+    void error(const T &msg)
+    {
         log(level::err, msg);
     }
 
-    template <typename T>
+    template<typename T>
-    void critical(const T &msg) {
+    void critical(const T &msg)
+    {
         log(level::critical, msg);
     }
 
     // return true logging is enabled for the given level.
-    bool should_log(level::level_enum msg_level) const {
+    bool should_log(level::level_enum msg_level) const
+    {
         return msg_level >= level_.load(std::memory_order_relaxed);
     }
 
     // return true if backtrace logging is enabled.
-    bool should_backtrace() const { return tracer_.enabled(); }
+    bool should_backtrace() const
+    {
+        return tracer_.enabled();
+    }
 
     void set_level(level::level_enum log_level);
 
@@ -313,19 +356,22 @@ protected:
     details::backtracer tracer_;
 
     // common implementation for after templated public api has been resolved
-    template <typename... Args>
+    template<typename... Args>
-    void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) {
+    void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&... args)
+    {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
-        SPDLOG_TRY {
+        SPDLOG_TRY
+        {
             memory_buf_t buf;
 #ifdef SPDLOG_USE_STD_FORMAT
-            fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...));
+            fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(std::forward<Args>(args)...));
 #else
-            fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...));
+            fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(std::forward<Args>(args)...));
 #endif
 
             details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
@@ -335,18 +381,25 @@ protected:
     }
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    template <typename... Args>
+    template<typename... Args>
-    void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) {
+    void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&... args)
+    {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
-        if (!log_enabled && !traceback_enabled) {
+        if (!log_enabled && !traceback_enabled)
+        {
             return;
         }
-        SPDLOG_TRY {
+        SPDLOG_TRY
+        {
             // format to wmemory_buffer and convert to utf8
             wmemory_buf_t wbuf;
-            fmt_lib::vformat_to(std::back_inserter(wbuf), fmt,
+#    ifdef SPDLOG_USE_STD_FORMAT
-                                fmt_lib::make_format_args<fmt_lib::wformat_context>(args...));
+            fmt_lib::vformat_to(
+                std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(std::forward<Args>(args)...));
+#    else
+            fmt::vformat_to(std::back_inserter(wbuf), fmt, fmt::make_format_args<fmt::wformat_context>(std::forward<Args>(args)...));
+#    endif
 
             memory_buf_t buf;
             details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);
@@ -355,6 +408,27 @@ protected:
         }
         SPDLOG_LOGGER_CATCH(loc)
     }
+
+    // T can be statically converted to wstring_view, and no formatting needed.
+    template<class T, typename std::enable_if<std::is_convertible<const T &, spdlog::wstring_view_t>::value, int>::type = 0>
+    void log_(source_loc loc, level::level_enum lvl, const T &msg)
+    {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled)
+        {
+            return;
+        }
+        SPDLOG_TRY
+        {
+            memory_buf_t buf;
+            details::os::wstr_to_utf8buf(msg, buf);
+            details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+            log_it_(log_msg, log_enabled, traceback_enabled);
+        }
+        SPDLOG_LOGGER_CATCH(loc)
+    }
+
 #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
     // log the given message (if the given log level is high enough),
@@ -375,5 +449,5 @@ void swap(logger &a, logger &b);
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "logger-inl.h"
+#    include "logger-inl.h"
 #endif

include/spdlog/mdc.h

@@ -1,50 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#if defined(SPDLOG_NO_TLS)
-    #error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined."
-#endif
-
-#include <map>
-#include <string>
-
-#include <spdlog/common.h>
-
-// MDC is a simple map of key->string values stored in thread local storage whose content will be printed by the loggers.
-// Note: Not supported in async mode (thread local storage - so the async thread pool have different copy).
-//
-// Usage example:
-// spdlog::mdc::put("mdc_key_1", "mdc_value_1");
-// spdlog::info("Hello, {}", "World!");  // => [2024-04-26 02:08:05.040] [info] [mdc_key_1:mdc_value_1] Hello, World!
-
-namespace spdlog {
-class SPDLOG_API mdc {
-public:
-    using mdc_map_t = std::map<std::string, std::string>;
-
-    static void put(const std::string &key, const std::string &value) {
-        get_context()[key] = value;
-    }
-
-    static std::string get(const std::string &key) {
-        auto &context = get_context();
-        auto it = context.find(key);
-        if (it != context.end()) {
-            return it->second;
-        }
-        return "";
-    }
-
-    static void remove(const std::string &key) { get_context().erase(key); }
-
-    static void clear() { get_context().clear(); }
-
-    static mdc_map_t &get_context() {
-        static thread_local mdc_map_t context;
-        return context;
-    }
-};
-
-}  // namespace spdlog

include/spdlog/pattern_formatter.h

@@ -13,39 +13,49 @@
 #include <memory>
 
 #include <string>
-#include <unordered_map>
 #include <vector>
+#include <unordered_map>
 
 namespace spdlog {
 namespace details {
 
 // padding information.
-struct padding_info {
+struct padding_info
-    enum class pad_side { left, right, center };
+{
+    enum class pad_side
+    {
+        left,
+        right,
+        center
+    };
 
     padding_info() = default;
     padding_info(size_t width, padding_info::pad_side side, bool truncate)
-        : width_(width),
+        : width_(width)
-          side_(side),
+        , side_(side)
-          truncate_(truncate),
+        , truncate_(truncate)
-          enabled_(true) {}
+        , enabled_(true)
+    {}
 
-    bool enabled() const { return enabled_; }
+    bool enabled() const
+    {
+        return enabled_;
+    }
     size_t width_ = 0;
     pad_side side_ = pad_side::left;
     bool truncate_ = false;
     bool enabled_ = false;
 };
 
-class SPDLOG_API flag_formatter {
+class SPDLOG_API flag_formatter
+{
 public:
     explicit flag_formatter(padding_info padinfo)
-        : padinfo_(padinfo) {}
+        : padinfo_(padinfo)
+    {}
     flag_formatter() = default;
     virtual ~flag_formatter() = default;
-    virtual void format(const details::log_msg &msg,
+    virtual void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0;
-                        const std::tm &tm_time,
-                        memory_buf_t &dest) = 0;
 
 protected:
     padding_info padinfo_;
@@ -53,27 +63,27 @@ protected:
 
 } // namespace details
 
-class SPDLOG_API custom_flag_formatter : public details::flag_formatter {
+class SPDLOG_API custom_flag_formatter : public details::flag_formatter
+{
 public:
     virtual std::unique_ptr<custom_flag_formatter> clone() const = 0;
 
-    void set_padding_info(const details::padding_info &padding) {
+    void set_padding_info(const details::padding_info &padding)
+    {
         flag_formatter::padinfo_ = padding;
     }
 };
 
-class SPDLOG_API pattern_formatter final : public formatter {
+class SPDLOG_API pattern_formatter final : public formatter
+{
 public:
     using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
 
-    explicit pattern_formatter(std::string pattern,
+    explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local,
-                               pattern_time_type time_type = pattern_time_type::local,
+        std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags());
-                               std::string eol = spdlog::details::os::default_eol,
-                               custom_flags custom_user_flags = custom_flags());
 
     // use default pattern is not given
-    explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local,
+    explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
-                               std::string eol = spdlog::details::os::default_eol);
 
     pattern_formatter(const pattern_formatter &other) = delete;
     pattern_formatter &operator=(const pattern_formatter &other) = delete;
@@ -81,8 +91,9 @@ public:
     std::unique_ptr<formatter> clone() const override;
     void format(const details::log_msg &msg, memory_buf_t &dest) override;
 
-    template <typename T, typename... Args>
+    template<typename T, typename... Args>
-    pattern_formatter &add_flag(char flag, Args &&...args) {
+    pattern_formatter &add_flag(char flag, Args &&... args)
+    {
         custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
         return *this;
     }
@@ -100,19 +111,18 @@ private:
     custom_flags custom_handlers_;
 
     std::tm get_time_(const details::log_msg &msg);
-    template <typename Padder>
+    template<typename Padder>
     void handle_flag_(char flag, details::padding_info padding);
 
     // Extract given pad spec (e.g. %8X)
     // Advance the given it pass the end of the padding spec found (if any)
     // Return padding.
-    static details::padding_info handle_padspec_(std::string::const_iterator &it,
+    static details::padding_info handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end);
-                                                 std::string::const_iterator end);
 
     void compile_pattern_(const std::string &pattern);
 };
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "pattern_formatter-inl.h"
+#    include "pattern_formatter-inl.h"
 #endif

include/spdlog/sinks/android_sink.h

@@ -5,45 +5,50 @@
 
 #ifdef __ANDROID__
 
-    #include <spdlog/details/fmt_helper.h>
+#    include <spdlog/details/fmt_helper.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/synchronous_factory.h>
+#    include <spdlog/sinks/base_sink.h>
-    #include <spdlog/sinks/base_sink.h>
+#    include <spdlog/details/synchronous_factory.h>
 
-    #include <android/log.h>
+#    include <android/log.h>
-    #include <chrono>
+#    include <chrono>
-    #include <mutex>
+#    include <mutex>
-    #include <string>
+#    include <string>
-    #include <thread>
+#    include <thread>
-    #include <type_traits>
+#    include <type_traits>
 
-    #if !defined(SPDLOG_ANDROID_RETRIES)
+#    if !defined(SPDLOG_ANDROID_RETRIES)
-        #define SPDLOG_ANDROID_RETRIES 2
+#        define SPDLOG_ANDROID_RETRIES 2
-    #endif
+#    endif
 
 namespace spdlog {
 namespace sinks {
 
 /*
  * Android sink
- * (logging using __android_log_write or __android_log_buf_write depending on the specified
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID)
- * BufferID)
  */
-template <typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
+template<typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
-class android_sink final : public base_sink<Mutex> {
+class android_sink final : public base_sink<Mutex>
+{
 public:
     explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
-        : tag_(std::move(tag)),
+        : tag_(std::move(tag))
-          use_raw_msg_(use_raw_msg) {}
+        , use_raw_msg_(use_raw_msg)
+    {}
 
 protected:
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
+    {
         const android_LogPriority priority = convert_to_android_(msg.level);
         memory_buf_t formatted;
-        if (use_raw_msg_) {
+        if (use_raw_msg_)
+        {
             details::fmt_helper::append_string_view(msg.payload, formatted);
-        } else {
+        }
+        else
+        {
             base_sink<Mutex>::formatter_->format(msg, formatted);
         }
         formatted.push_back('\0');
@@ -51,17 +56,16 @@ protected:
 
         // See system/core/liblog/logger_write.c for explanation of return value
         int ret = android_log(priority, tag_.c_str(), msg_output);
-        if (ret == -EPERM) {
-            return;  // !__android_log_is_loggable
-        }
         int retry_count = 0;
-        while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
+        while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
+        {
             details::os::sleep_for_millis(5);
             ret = android_log(priority, tag_.c_str(), msg_output);
             retry_count++;
         }
 
-        if (ret < 0) {
+        if (ret < 0)
+        {
             throw_spdlog_ex("logging to Android failed", ret);
         }
     }
@@ -69,24 +73,25 @@ protected:
     void flush_() override {}
 
 private:
-    // There might be liblog versions used, that do not support __android_log_buf_write. So we only
+    // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against
-    // compile and link against
+    // __android_log_buf_write, if user explicitely provides a non-default log buffer. Otherwise, when using the default log buffer, always
-    // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,
+    // log via __android_log_write.
-    // when using the default log buffer, always log via __android_log_write.
+    template<int ID = BufferID>
-    template <int ID = BufferID>
+    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
-    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
+    {
-        int prio, const char *tag, const char *text) {
         return __android_log_write(prio, tag, text);
     }
 
-    template <int ID = BufferID>
+    template<int ID = BufferID>
-    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
+    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(int prio, const char *tag, const char *text)
-        int prio, const char *tag, const char *text) {
+    {
         return __android_log_buf_write(ID, prio, tag, text);
     }
 
-    static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {
+    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
-        switch (level) {
+    {
+        switch (level)
+        {
         case spdlog::level::trace:
             return ANDROID_LOG_VERBOSE;
         case spdlog::level::debug:
@@ -111,24 +116,24 @@ private:
 using android_sink_mt = android_sink<std::mutex>;
 using android_sink_st = android_sink<details::null_mutex>;
 
-template <int BufferId = log_id::LOG_ID_MAIN>
+template<int BufferId = log_id::LOG_ID_MAIN>
 using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
-template <int BufferId = log_id::LOG_ID_MAIN>
+template<int BufferId = log_id::LOG_ID_MAIN>
 using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
 
 } // namespace sinks
 
 // Create and register android syslog logger
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name,
+inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
-                                                 const std::string &tag = "spdlog") {
+{
     return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name,
+inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
-                                                 const std::string &tag = "spdlog") {
+{
     return Factory::template create<sinks::android_sink_st>(logger_name, tag);
 }
 

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -4,41 +4,42 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/sinks/ansicolor_sink.h>
+#    include <spdlog/sinks/ansicolor_sink.h>
 #endif
 
-#include <spdlog/details/os.h>
 #include <spdlog/pattern_formatter.h>
+#include <spdlog/details/os.h>
 
 namespace spdlog {
 namespace sinks {
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
 SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
-    : target_file_(target_file),
+    : target_file_(target_file)
-      mutex_(ConsoleMutex::mutex()),
+    , mutex_(ConsoleMutex::mutex())
-      formatter_(details::make_unique<spdlog::pattern_formatter>())
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
 
 {
-    set_color_mode_(mode);
+    set_color_mode(mode);
-    colors_.at(level::trace) = to_string_(white);
+    colors_[level::trace] = to_string_(white);
-    colors_.at(level::debug) = to_string_(cyan);
+    colors_[level::debug] = to_string_(cyan);
-    colors_.at(level::info) = to_string_(green);
+    colors_[level::info] = to_string_(green);
-    colors_.at(level::warn) = to_string_(yellow_bold);
+    colors_[level::warn] = to_string_(yellow_bold);
-    colors_.at(level::err) = to_string_(red_bold);
+    colors_[level::err] = to_string_(red_bold);
-    colors_.at(level::critical) = to_string_(bold_on_red);
+    colors_[level::critical] = to_string_(bold_on_red);
-    colors_.at(level::off) = to_string_(reset);
+    colors_[level::off] = to_string_(reset);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level,
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
-                                                           string_view_t color) {
+{
     std::lock_guard<mutex_t> lock(mutex_);
-    colors_.at(static_cast<size_t>(color_level)) = to_string_(color);
+    colors_[static_cast<size_t>(color_level)] = to_string_(color);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
+{
     // Wrap the originally formatted message in color codes.
     // If color is not supported in the terminal, log as is instead.
     std::lock_guard<mutex_t> lock(mutex_);
@@ -46,61 +47,61 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
     msg.color_range_end = 0;
     memory_buf_t formatted;
     formatter_->format(msg, formatted);
-    if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
+    if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
+    {
         // before color range
         print_range_(formatted, 0, msg.color_range_start);
         // in color range
-        print_ccode_(colors_.at(static_cast<size_t>(msg.level)));
+        print_ccode_(colors_[static_cast<size_t>(msg.level)]);
         print_range_(formatted, msg.color_range_start, msg.color_range_end);
         print_ccode_(reset);
         // after color range
         print_range_(formatted, msg.color_range_end, formatted.size());
-    } else  // no color
+    }
+    else // no color
     {
         print_range_(formatted, 0, formatted.size());
     }
     fflush(target_file_);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush()
+{
     std::lock_guard<mutex_t> lock(mutex_);
     fflush(target_file_);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
+{
     std::lock_guard<mutex_t> lock(mutex_);
     formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-    std::unique_ptr<spdlog::formatter> sink_formatter) {
+{
     std::lock_guard<mutex_t> lock(mutex_);
     formatter_ = std::move(sink_formatter);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() const {
+SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color()
+{
     return should_do_colors_;
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
-    std::lock_guard<mutex_t> lock(mutex_);
+{
-    set_color_mode_(mode);
+    switch (mode)
-}
+    {
-
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode) {
-    switch (mode) {
     case color_mode::always:
         should_do_colors_ = true;
         return;
     case color_mode::automatic:
-            should_do_colors_ =
+        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
-                details::os::in_terminal(target_file_) && details::os::is_color_terminal();
         return;
     case color_mode::never:
         should_do_colors_ = false;
@@ -110,32 +111,35 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode
     }
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) const {
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
-    details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_);
+{
+    fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
-                                                              size_t start,
+{
-                                                              size_t end) const {
+    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
-    details::os::fwrite_bytes(formatted.data() + start, end - start, target_file_);
 }
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
+SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
+{
     return std::string(sv.data(), sv.size());
 }
 
 // ansicolor_stdout_sink
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
 SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
+    : ansicolor_sink<ConsoleMutex>(stdout, mode)
+{}
 
 // ansicolor_stderr_sink
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
 SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stderr, mode) {}
+    : ansicolor_sink<ConsoleMutex>(stderr, mode)
+{}
 
 } // namespace sinks
 } // namespace spdlog

include/spdlog/sinks/ansicolor_sink.h

@@ -3,13 +3,13 @@
 
 #pragma once
 
-#include <array>
-#include <memory>
-#include <mutex>
 #include <spdlog/details/console_globals.h>
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/sinks/sink.h>
+#include <memory>
+#include <mutex>
 #include <string>
+#include <array>
 
 namespace spdlog {
 namespace sinks {
@@ -21,8 +21,9 @@ namespace sinks {
  * If no color terminal detected, omit the escape codes.
  */
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-class ansicolor_sink : public sink {
+class ansicolor_sink : public sink
+{
 public:
     using mutex_t = typename ConsoleMutex::mutex_t;
     ansicolor_sink(FILE *target_file, color_mode mode);
@@ -36,11 +37,11 @@ public:
 
     void set_color(level::level_enum color_level, string_view_t color);
     void set_color_mode(color_mode mode);
-    bool should_color() const;
+    bool should_color();
 
     void log(const details::log_msg &msg) override;
     void flush() override;
-    void set_pattern(const std::string &pattern) final override;
+    void set_pattern(const std::string &pattern) final;
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
 
     // Formatting codes
@@ -84,20 +85,21 @@ private:
     bool should_do_colors_;
     std::unique_ptr<spdlog::formatter> formatter_;
     std::array<std::string, level::n_levels> colors_;
-    void set_color_mode_(color_mode mode);
+    void print_ccode_(const string_view_t &color_code);
-    void print_ccode_(const string_view_t &color_code) const;
+    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
-    void print_range_(const memory_buf_t &formatted, size_t start, size_t end) const;
     static std::string to_string_(const string_view_t &sv);
 };
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> {
+class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex>
+{
 public:
     explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
 };
 
-template <typename ConsoleMutex>
+template<typename ConsoleMutex>
-class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> {
+class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex>
+{
 public:
     explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
 };
@@ -112,5 +114,5 @@ using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmute
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "ansicolor_sink-inl.h"
+#    include "ansicolor_sink-inl.h"
 #endif

include/spdlog/sinks/base_sink-inl.h

@@ -4,56 +4,60 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/sinks/base_sink.h>
+#    include <spdlog/sinks/base_sink.h>
 #endif
 
 #include <spdlog/common.h>
 #include <spdlog/pattern_formatter.h>
 
 #include <memory>
-#include <mutex>
 
-template <typename Mutex>
+template<typename Mutex>
 SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
-    : formatter_{details::make_unique<spdlog::pattern_formatter>()} {}
+    : formatter_{details::make_unique<spdlog::pattern_formatter>()}
+{}
 
-template <typename Mutex>
+template<typename Mutex>
-SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter)
-    std::unique_ptr<spdlog::formatter> formatter)
+    : formatter_{std::move(formatter)}
-    : formatter_{std::move(formatter)} {}
+{}
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) {
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
+{
     std::lock_guard<Mutex> lock(mutex_);
     sink_it_(msg);
 }
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() {
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush()
+{
     std::lock_guard<Mutex> lock(mutex_);
     flush_();
 }
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) {
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
+{
     std::lock_guard<Mutex> lock(mutex_);
     set_pattern_(pattern);
 }
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
+{
     std::lock_guard<Mutex> lock(mutex_);
     set_formatter_(std::move(sink_formatter));
 }
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) {
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
+{
     set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
 }
 
-template <typename Mutex>
+template<typename Mutex>
-void SPDLOG_INLINE
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
-spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) {
+{
     formatter_ = std::move(sink_formatter);
 }

include/spdlog/sinks/base_sink.h

@@ -15,8 +15,9 @@
 
 namespace spdlog {
 namespace sinks {
-template <typename Mutex>
+template<typename Mutex>
-class SPDLOG_API base_sink : public sink {
+class SPDLOG_API base_sink : public sink
+{
 public:
     base_sink();
     explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
@@ -28,10 +29,10 @@ public:
     base_sink &operator=(const base_sink &) = delete;
     base_sink &operator=(base_sink &&) = delete;
 
-    void log(const details::log_msg &msg) final override;
+    void log(const details::log_msg &msg) final;
-    void flush() final override;
+    void flush() final;
-    void set_pattern(const std::string &pattern) final override;
+    void set_pattern(const std::string &pattern) final;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
 
 protected:
     // sink formatter
@@ -47,5 +48,5 @@ protected:
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "base_sink-inl.h"
+#    include "base_sink-inl.h"
 #endif

include/spdlog/sinks/basic_file_sink-inl.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-    #include <spdlog/sinks/basic_file_sink.h>
+#    include <spdlog/sinks/basic_file_sink.h>
 #endif
 
 #include <spdlog/common.h>
@@ -13,34 +13,30 @@
 namespace spdlog {
 namespace sinks {
 
-template <typename Mutex>
+template<typename Mutex>
-SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename,
+SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers)
-                                                      bool truncate,
+    : file_helper_{event_handlers}
-                                                      const file_event_handlers &event_handlers)
+{
-    : file_helper_{event_handlers} {
     file_helper_.open(filename, truncate);
 }
 
-template <typename Mutex>
+template<typename Mutex>
-SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const {
+SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const
+{
     return file_helper_.filename();
 }
 
-template <typename Mutex>
+template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::truncate() {
+SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
-    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+{
-    file_helper_.reopen(true);
-}
-
-template <typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
     memory_buf_t formatted;
     base_sink<Mutex>::formatter_->format(msg, formatted);
     file_helper_.write(formatted);
 }
 
-template <typename Mutex>
+template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() {
+SPDLOG_INLINE void basic_file_sink<Mutex>::flush_()
+{
     file_helper_.flush();
 }
 

include/spdlog/sinks/basic_file_sink.h

@@ -5,8 +5,8 @@
 
 #include <spdlog/details/file_helper.h>
 #include <spdlog/details/null_mutex.h>
-#include <spdlog/details/synchronous_factory.h>
 #include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
 
 #include <mutex>
 #include <string>
@@ -16,14 +16,12 @@ namespace sinks {
 /*
  * Trivial file sink with single file as target
  */
-template <typename Mutex>
+template<typename Mutex>
-class basic_file_sink final : public base_sink<Mutex> {
+class basic_file_sink final : public base_sink<Mutex>
+{
 public:
-    explicit basic_file_sink(const filename_t &filename,
+    explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {});
-                             bool truncate = false,
-                             const file_event_handlers &event_handlers = {});
     const filename_t &filename() const;
-    void truncate();
 
 protected:
     void sink_it_(const details::log_msg &msg) override;
@@ -41,26 +39,22 @@ using basic_file_sink_st = basic_file_sink<details::null_mutex>;
 //
 // factory functions
 //
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
+inline std::shared_ptr<logger> basic_logger_mt(
-                                               const filename_t &filename,
+    const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
-                                               bool truncate = false,
+{
-                                               const file_event_handlers &event_handlers = {}) {
+    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, event_handlers);
-    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate,
-                                                               event_handlers);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
+inline std::shared_ptr<logger> basic_logger_st(
-                                               const filename_t &filename,
+    const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
-                                               bool truncate = false,
+{
-                                               const file_event_handlers &event_handlers = {}) {
+    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, event_handlers);
-    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate,
-                                                               event_handlers);
 }
 
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-    #include "basic_file_sink-inl.h"
+#    include "basic_file_sink-inl.h"
 #endif

include/spdlog/sinks/callback_sink.h

@@ -1,56 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/synchronous_factory.h>
-#include <spdlog/sinks/base_sink.h>
-
-#include <mutex>
-#include <string>
-
-namespace spdlog {
-
-// callbacks type
-typedef std::function<void(const details::log_msg &msg)> custom_log_callback;
-
-namespace sinks {
-/*
- * Trivial callback sink, gets a callback function and calls it on each log
- */
-template <typename Mutex>
-class callback_sink final : public base_sink<Mutex> {
-public:
-    explicit callback_sink(const custom_log_callback &callback)
-        : callback_{callback} {}
-
-protected:
-    void sink_it_(const details::log_msg &msg) override { callback_(msg); }
-    void flush_() override{}
-
-private:
-    custom_log_callback callback_;
-};
-
-using callback_sink_mt = callback_sink<std::mutex>;
-using callback_sink_st = callback_sink<details::null_mutex>;
-
-}  // namespace sinks
-
-//
-// factory functions
-//
-template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name,
-                                                  const custom_log_callback &callback) {
-    return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
-}
-
-template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name,
-                                                  const custom_log_callback &callback) {
-    return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
-}
-
-}  // namespace spdlog

include/spdlog/sinks/daily_file_sink.h

@@ -4,20 +4,19 @@
 #pragma once
 
 #include <spdlog/common.h>
-#include <spdlog/details/circular_q.h>
 #include <spdlog/details/file_helper.h>
 #include <spdlog/details/null_mutex.h>
-#include <spdlog/details/os.h>
-#include <spdlog/details/synchronous_factory.h>
-#include <spdlog/fmt/chrono.h>
 #include <spdlog/fmt/fmt.h>
+#include <spdlog/fmt/chrono.h>
 #include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/synchronous_factory.h>
 
 #include <chrono>
 #include <cstdio>
-#include <iomanip>
+#include <ctime>
 #include <mutex>
-#include <sstream>
 #include <string>
 
 namespace spdlog {
@@ -26,64 +25,112 @@ namespace sinks {
 /*
  * Generator of daily log file names in format basename.YYYY-MM-DD.ext
  */
-struct daily_filename_calculator {
+struct daily_filename_calculator
+{
     // Create filename for the form basename.YYYY-MM-DD
-    static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+    {
         filename_t basename, ext;
         std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
-        return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")),
+        return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900,
-                               basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+            now_tm.tm_mon + 1, now_tm.tm_mday, ext);
-                               ext);
     }
 };
 
 /*
  * Generator of daily log file names with strftime format.
  * Usages:
- *    auto sink =
+ *    auto sink =  std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour, minute);"
- * std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour,
+ *    auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour,  minute)"
- * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log",
- * hour,  minute)"
  *
  */
-struct daily_filename_format_calculator {
+struct daily_filename_format_calculator
-    static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) {
+{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
-        std::wstringstream stream;
+    {
-#else
+#ifdef SPDLOG_USE_STD_FORMAT
-        std::stringstream stream;
+        // adapted from fmtlib: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/chrono.h#L522-L546
-#endif
+
-        stream << std::put_time(&now_tm, file_path.c_str());
+        filename_t tm_format;
-        return stream.str();
+        tm_format.append(filename);
+        // By appending an extra space we can distinguish an empty result that
+        // indicates insufficient buffer size from a guaranteed non-empty result
+        // https://github.com/fmtlib/fmt/issues/2238
+        tm_format.push_back(' ');
+
+        const size_t MIN_SIZE = 10;
+        filename_t buf;
+        buf.resize(MIN_SIZE);
+        for (;;)
+        {
+            size_t count = strftime(buf.data(), buf.size(), tm_format.c_str(), &now_tm);
+            if (count != 0)
+            {
+                // Remove the extra space.
+                buf.resize(count - 1);
+                break;
             }
+            buf.resize(buf.size() * 2);
+        }
+
+        return buf;
+#else
+        // generate fmt datetime format string, e.g. {:%Y-%m-%d}.
+        filename_t fmt_filename = fmt::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{{:{}}}")), filename);
+
+        // MSVC doesn't allow fmt::runtime(..) with wchar, with fmtlib versions < 9.1.x
+#    if defined(_MSC_VER) && defined(SPDLOG_WCHAR_FILENAMES) && FMT_VERSION < 90101
+        return fmt::format(fmt_filename, now_tm);
+#    else
+        return fmt::format(SPDLOG_FMT_RUNTIME(fmt_filename), now_tm);
+#    endif
+
+#endif
+    }
+
+private:
+#if defined __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
+
+    static size_t strftime(char *str, size_t count, const char *format, const std::tm *time)
+    {
+        return std::strftime(str, count, format, time);
+    }
+
+    static size_t strftime(wchar_t *str, size_t count, const wchar_t *format, const std::tm *time)
+    {
+        return std::wcsftime(str, count, format, time);
+    }
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
 };
 
 /*
  * Rotating file sink based on date.
  * If truncate != false , the created file will be truncated.
  * If max_files > 0, retain only the last max_files and delete previous.
- * Note that old log files from previous executions will not be deleted by this class,
- * rotation and deletion is only applied while the program is running.
  */
-template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
+template<typename Mutex, typename FileNameCalc = daily_filename_calculator>
-class daily_file_sink final : public base_sink<Mutex> {
+class daily_file_sink final : public base_sink<Mutex>
+{
 public:
     // create daily file sink which rotates on given time
-    daily_file_sink(filename_t base_filename,
+    daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0,
-                    int rotation_hour,
-                    int rotation_minute,
-                    bool truncate = false,
-                    uint16_t max_files = 0,
         const file_event_handlers &event_handlers = {})
-        : base_filename_(std::move(base_filename)),
+        : base_filename_(std::move(base_filename))
-          rotation_h_(rotation_hour),
+        , rotation_h_(rotation_hour)
-          rotation_m_(rotation_minute),
+        , rotation_m_(rotation_minute)
-          file_helper_{event_handlers},
+        , file_helper_{event_handlers}
-          truncate_(truncate),
+        , truncate_(truncate)
-          max_files_(max_files),
+        , max_files_(max_files)
-          filenames_q_() {
+        , filenames_q_()
-        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
+    {
-            rotation_minute > 59) {
+        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
+        {
             throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
         }
 
@@ -92,21 +139,25 @@ public:
         file_helper_.open(filename, truncate_);
         rotation_tp_ = next_rotation_tp_();
 
-        if (max_files_ > 0) {
+        if (max_files_ > 0)
+        {
             init_filenames_q_();
         }
     }
 
-    filename_t filename() {
+    filename_t filename()
+    {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
         return file_helper_.filename();
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
+    {
         auto time = msg.time;
         bool should_rotate = time >= rotation_tp_;
-        if (should_rotate) {
+        if (should_rotate)
+        {
             auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
             file_helper_.open(filename, truncate_);
             rotation_tp_ = next_rotation_tp_();
@@ -116,46 +167,57 @@ protected:
         file_helper_.write(formatted);
 
         // Do the cleaning only at the end because it might throw on failure.
-        if (should_rotate && max_files_ > 0) {
+        if (should_rotate && max_files_ > 0)
+        {
             delete_old_();
         }
     }
 
-    void flush_() override { file_helper_.flush(); }
+    void flush_() override
+    {
+        file_helper_.flush();
+    }
 
 private:
-    void init_filenames_q_() {
+    void init_filenames_q_()
+    {
         using details::os::path_exists;
 
         filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
         std::vector<filename_t> filenames;
         auto now = log_clock::now();
-        while (filenames.size() < max_files_) {
+        while (filenames.size() < max_files_)
+        {
             auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
-            if (!path_exists(filename)) {
+            if (!path_exists(filename))
+            {
                 break;
             }
             filenames.emplace_back(filename);
             now -= std::chrono::hours(24);
         }
-        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
+        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter)
+        {
             filenames_q_.push_back(std::move(*iter));
         }
     }
 
-    tm now_tm(log_clock::time_point tp) {
+    tm now_tm(log_clock::time_point tp)
+    {
         time_t tnow = log_clock::to_time_t(tp);
         return spdlog::details::os::localtime(tnow);
     }
 
-    log_clock::time_point next_rotation_tp_() {
+    log_clock::time_point next_rotation_tp_()
+    {
         auto now = log_clock::now();
         tm date = now_tm(now);
         date.tm_hour = rotation_h_;
         date.tm_min = rotation_m_;
         date.tm_sec = 0;
         auto rotation_time = log_clock::from_time_t(std::mktime(&date));
-        if (rotation_time > now) {
+        if (rotation_time > now)
+        {
             return rotation_time;
         }
         return {rotation_time + std::chrono::hours(24)};
@@ -163,19 +225,21 @@ private:
 
     // Delete the file N rotations ago.
     // Throw spdlog_ex on failure to delete the old file.
-    void delete_old_() {
+    void delete_old_()
+    {
         using details::os::filename_to_str;
         using details::os::remove_if_exists;
 
         filename_t current_file = file_helper_.filename();
-        if (filenames_q_.full()) {
+        if (filenames_q_.full())
+        {
             auto old_filename = std::move(filenames_q_.front());
             filenames_q_.pop_front();
             bool ok = remove_if_exists(old_filename) == 0;
-            if (!ok) {
+            if (!ok)
+            {
                 filenames_q_.push_back(std::move(current_file));
-                throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename),
+                throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno);
-                                errno);
             }
         }
         filenames_q_.push_back(std::move(current_file));
@@ -194,60 +258,39 @@ private:
 using daily_file_sink_mt = daily_file_sink<std::mutex>;
 using daily_file_sink_st = daily_file_sink<details::null_mutex>;
 using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>;
-using daily_file_format_sink_st =
+using daily_file_format_sink_st = daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
-    daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
 
 } // namespace sinks
 
 //
 // factory functions
 //
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
+inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
-                                               const filename_t &filename,
+    bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-                                               int hour = 0,
+{
-                                               int minute = 0,
+    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
-                                               bool truncate = false,
-                                               uint16_t max_files = 0,
-                                               const file_event_handlers &event_handlers = {}) {
-    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute,
-                                                               truncate, max_files, event_handlers);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> daily_logger_format_mt(
+inline std::shared_ptr<logger> daily_logger_format_mt(const std::string &logger_name, const filename_t &filename, int hour = 0,
-    const std::string &logger_name,
+    int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-    const filename_t &filename,
+{
-    int hour = 0,
-    int minute = 0,
-    bool truncate = false,
-    uint16_t max_files = 0,
-    const file_event_handlers &event_handlers = {}) {
     return Factory::template create<sinks::daily_file_format_sink_mt>(
         logger_name, filename, hour, minute, truncate, max_files, event_handlers);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
+inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
-                                               const filename_t &filename,
+    bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-                                               int hour = 0,
+{
-                                               int minute = 0,
+    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
-                                               bool truncate = false,
-                                               uint16_t max_files = 0,
-                                               const file_event_handlers &event_handlers = {}) {
-    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute,
-                                                               truncate, max_files, event_handlers);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> daily_logger_format_st(
+inline std::shared_ptr<logger> daily_logger_format_st(const std::string &logger_name, const filename_t &filename, int hour = 0,
-    const std::string &logger_name,
+    int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-    const filename_t &filename,
+{
-    int hour = 0,
-    int minute = 0,
-    bool truncate = false,
-    uint16_t max_files = 0,
-    const file_event_handlers &event_handlers = {}) {
     return Factory::template create<sinks::daily_file_format_sink_st>(
         logger_name, filename, hour, minute, truncate, max_files, event_handlers);
 }

include/spdlog/sinks/dist_sink.h

@@ -19,55 +19,71 @@
 namespace spdlog {
 namespace sinks {
 
-template <typename Mutex>
+template<typename Mutex>
-class dist_sink : public base_sink<Mutex> {
+class dist_sink : public base_sink<Mutex>
+{
 public:
     dist_sink() = default;
     explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
-        : sinks_(sinks) {}
+        : sinks_(sinks)
+    {}
 
     dist_sink(const dist_sink &) = delete;
     dist_sink &operator=(const dist_sink &) = delete;
 
-    void add_sink(std::shared_ptr<sink> sub_sink) {
+    void add_sink(std::shared_ptr<sink> sink)
+    {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        sinks_.push_back(sub_sink);
+        sinks_.push_back(sink);
     }
 
-    void remove_sink(std::shared_ptr<sink> sub_sink) {
+    void remove_sink(std::shared_ptr<sink> sink)
+    {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end());
+        sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
     }
 
-    void set_sinks(std::vector<std::shared_ptr<sink>> sinks) {
+    void set_sinks(std::vector<std::shared_ptr<sink>> sinks)
+    {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
         sinks_ = std::move(sinks);
     }
 
-    std::vector<std::shared_ptr<sink>> &sinks() { return sinks_; }
+    std::vector<std::shared_ptr<sink>> &sinks()
+    {
+        return sinks_;
+    }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
-        for (auto &sub_sink : sinks_) {
+    {
-            if (sub_sink->should_log(msg.level)) {
+        for (auto &sub_sink : sinks_)
+        {
+            if (sub_sink->should_log(msg.level))
+            {
                 sub_sink->log(msg);
             }
         }
     }
 
-    void flush_() override {
+    void flush_() override
-        for (auto &sub_sink : sinks_) {
+    {
+        for (auto &sub_sink : sinks_)
+        {
             sub_sink->flush();
         }
     }
 
-    void set_pattern_(const std::string &pattern) override {
+    void set_pattern_(const std::string &pattern) override
+    {
         set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
     }
 
-    void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override {
+    void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
+    {
         base_sink<Mutex>::formatter_ = std::move(sink_formatter);
-        for (auto &sub_sink : sinks_) {
+        for (auto &sub_sink : sinks_)
+        {
             sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone());
         }
     }

include/spdlog/sinks/dup_filter_sink.h

@@ -4,13 +4,13 @@
 #pragma once
 
 #include "dist_sink.h"
-#include <spdlog/details/log_msg.h>
 #include <spdlog/details/null_mutex.h>
+#include <spdlog/details/log_msg.h>
 
-#include <chrono>
 #include <cstdio>
 #include <mutex>
 #include <string>
+#include <chrono>
 
 // Duplicate message removal sink.
 // Skip the message if previous one is identical and less than "max_skip_duration" have passed
@@ -20,8 +20,8 @@
 //     #include <spdlog/sinks/dup_filter_sink.h>
 //
 //     int main() {
-//         auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5),
+//         auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5));
-//         level::info); dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
+//         dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
 //         spdlog::logger l("logger", dup_filter);
 //         l.info("Hello");
 //         l.info("Hello");
@@ -36,36 +36,38 @@
 
 namespace spdlog {
 namespace sinks {
-template <typename Mutex>
+template<typename Mutex>
-class dup_filter_sink : public dist_sink<Mutex> {
+class dup_filter_sink : public dist_sink<Mutex>
+{
 public:
-    template <class Rep, class Period>
+    template<class Rep, class Period>
     explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration)
-        : max_skip_duration_{max_skip_duration} {}
+        : max_skip_duration_{max_skip_duration}
+    {}
 
 protected:
     std::chrono::microseconds max_skip_duration_;
     log_clock::time_point last_msg_time_;
     std::string last_msg_payload_;
     size_t skip_counter_ = 0;
-    level::level_enum skipped_msg_log_level_ = spdlog::level::level_enum::off;
 
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
+    {
         bool filtered = filter_(msg);
-        if (!filtered) {
+        if (!filtered)
+        {
             skip_counter_ += 1;
-            skipped_msg_log_level_ = msg.level;
             return;
         }
 
         // log the "skipped.." message
-        if (skip_counter_ > 0) {
+        if (skip_counter_ > 0)
+        {
             char buf[64];
-            auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..",
+            auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast<unsigned>(skip_counter_));
-                                       static_cast<unsigned>(skip_counter_));
+            if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf))
-            if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) {
+            {
-                details::log_msg skipped_msg{msg.source, msg.logger_name, skipped_msg_log_level_,
+                details::log_msg skipped_msg{msg.logger_name, level::info, string_view_t{buf, static_cast<size_t>(msg_size)}};
-                                             string_view_t{buf, static_cast<size_t>(msg_size)}};
                 dist_sink<Mutex>::sink_it_(skipped_msg);
             }
         }
@@ -78,7 +80,8 @@ protected:
     }
 
     // return whether the log msg should be displayed (true) or skipped (false)
-    bool filter_(const details::log_msg &msg) {
+    bool filter_(const details::log_msg &msg)
+    {
         auto filter_duration = msg.time - last_msg_time_;
         return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
     }

include/spdlog/sinks/hourly_file_sink.h

@@ -4,13 +4,13 @@
 #pragma once
 
 #include <spdlog/common.h>
-#include <spdlog/details/circular_q.h>
 #include <spdlog/details/file_helper.h>
 #include <spdlog/details/null_mutex.h>
-#include <spdlog/details/os.h>
-#include <spdlog/details/synchronous_factory.h>
 #include <spdlog/fmt/fmt.h>
 #include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/synchronous_factory.h>
 
 #include <chrono>
 #include <cstdio>
@@ -24,14 +24,15 @@ namespace sinks {
 /*
  * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext
  */
-struct hourly_filename_calculator {
+struct hourly_filename_calculator
+{
     // Create filename for the form basename.YYYY-MM-DD-H
-    static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
+    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+    {
         filename_t basename, ext;
         std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
-        return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename,
+        return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1,
-                               now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+            now_tm.tm_mday, now_tm.tm_hour, ext);
-                               now_tm.tm_hour, ext);
     }
 };
 
@@ -39,44 +40,47 @@ struct hourly_filename_calculator {
  * Rotating file sink based on time.
  * If truncate != false , the created file will be truncated.
  * If max_files > 0, retain only the last max_files and delete previous.
- * Note that old log files from previous executions will not be deleted by this class,
- * rotation and deletion is only applied while the program is running.
  */
-template <typename Mutex, typename FileNameCalc = hourly_filename_calculator>
+template<typename Mutex, typename FileNameCalc = hourly_filename_calculator>
-class hourly_file_sink final : public base_sink<Mutex> {
+class hourly_file_sink final : public base_sink<Mutex>
+{
 public:
     // create hourly file sink which rotates on given time
-    hourly_file_sink(filename_t base_filename,
+    hourly_file_sink(
-                     bool truncate = false,
+        filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-                     uint16_t max_files = 0,
+        : base_filename_(std::move(base_filename))
-                     const file_event_handlers &event_handlers = {})
+        , file_helper_{event_handlers}
-        : base_filename_(std::move(base_filename)),
+        , truncate_(truncate)
-          file_helper_{event_handlers},
+        , max_files_(max_files)
-          truncate_(truncate),
+        , filenames_q_()
-          max_files_(max_files),
+    {
-          filenames_q_() {
         auto now = log_clock::now();
         auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
         file_helper_.open(filename, truncate_);
         remove_init_file_ = file_helper_.size() == 0;
         rotation_tp_ = next_rotation_tp_();
 
-        if (max_files_ > 0) {
+        if (max_files_ > 0)
+        {
             init_filenames_q_();
         }
     }
 
-    filename_t filename() {
+    filename_t filename()
+    {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
         return file_helper_.filename();
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
+    {
         auto time = msg.time;
         bool should_rotate = time >= rotation_tp_;
-        if (should_rotate) {
+        if (should_rotate)
-            if (remove_init_file_) {
+        {
+            if (remove_init_file_)
+            {
                 file_helper_.close();
                 details::os::remove(file_helper_.filename());
             }
@@ -90,45 +94,56 @@ protected:
         file_helper_.write(formatted);
 
         // Do the cleaning only at the end because it might throw on failure.
-        if (should_rotate && max_files_ > 0) {
+        if (should_rotate && max_files_ > 0)
+        {
             delete_old_();
         }
     }
 
-    void flush_() override { file_helper_.flush(); }
+    void flush_() override
+    {
+        file_helper_.flush();
+    }
 
 private:
-    void init_filenames_q_() {
+    void init_filenames_q_()
+    {
         using details::os::path_exists;
 
         filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
         std::vector<filename_t> filenames;
         auto now = log_clock::now();
-        while (filenames.size() < max_files_) {
+        while (filenames.size() < max_files_)
+        {
             auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
-            if (!path_exists(filename)) {
+            if (!path_exists(filename))
+            {
                 break;
             }
             filenames.emplace_back(filename);
             now -= std::chrono::hours(1);
         }
-        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
+        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter)
+        {
             filenames_q_.push_back(std::move(*iter));
         }
     }
 
-    tm now_tm(log_clock::time_point tp) {
+    tm now_tm(log_clock::time_point tp)
+    {
         time_t tnow = log_clock::to_time_t(tp);
         return spdlog::details::os::localtime(tnow);
     }
 
-    log_clock::time_point next_rotation_tp_() {
+    log_clock::time_point next_rotation_tp_()
+    {
         auto now = log_clock::now();
         tm date = now_tm(now);
         date.tm_min = 0;
         date.tm_sec = 0;
         auto rotation_time = log_clock::from_time_t(std::mktime(&date));
-        if (rotation_time > now) {
+        if (rotation_time > now)
+        {
             return rotation_time;
         }
         return {rotation_time + std::chrono::hours(1)};
@@ -136,19 +151,21 @@ private:
 
     // Delete the file N rotations ago.
     // Throw spdlog_ex on failure to delete the old file.
-    void delete_old_() {
+    void delete_old_()
+    {
         using details::os::filename_to_str;
         using details::os::remove_if_exists;
 
         filename_t current_file = file_helper_.filename();
-        if (filenames_q_.full()) {
+        if (filenames_q_.full())
+        {
             auto old_filename = std::move(filenames_q_.front());
             filenames_q_.pop_front();
             bool ok = remove_if_exists(old_filename) == 0;
-            if (!ok) {
+            if (!ok)
+            {
                 filenames_q_.push_back(std::move(current_file));
-                SPDLOG_THROW(spdlog_ex(
+                SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno));
-                    "Failed removing hourly file " + filename_to_str(old_filename), errno));
             }
         }
         filenames_q_.push_back(std::move(current_file));
@@ -171,23 +188,17 @@ using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
 //
 // factory functions
 //
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name,
+inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false,
-                                                const filename_t &filename,
+    uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-                                                bool truncate = false,
+{
-                                                uint16_t max_files = 0,
+    return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, max_files, event_handlers);
-                                                const file_event_handlers &event_handlers = {}) {
-    return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate,
-                                                                max_files, event_handlers);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name,
+inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false,
-                                                const filename_t &filename,
+    uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
-                                                bool truncate = false,
+{
-                                                uint16_t max_files = 0,
+    return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, max_files, event_handlers);
-                                                const file_event_handlers &event_handlers = {}) {
-    return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate,
-                                                                max_files, event_handlers);
 }
 } // namespace spdlog

include/spdlog/sinks/kafka_sink.h

@@ -1,119 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-//
-// Custom sink for kafka
-// Building and using requires librdkafka library.
-// For building librdkafka library check the url below
-// https://github.com/confluentinc/librdkafka
-//
-
-#include "spdlog/async.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/details/synchronous_factory.h"
-#include "spdlog/sinks/base_sink.h"
-#include <mutex>
-#include <spdlog/common.h>
-
-// kafka header
-#include <librdkafka/rdkafkacpp.h>
-
-namespace spdlog {
-namespace sinks {
-
-struct kafka_sink_config {
-    std::string server_addr;
-    std::string produce_topic;
-    int32_t flush_timeout_ms = 1000;
-
-    kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)
-        : server_addr{std::move(addr)},
-          produce_topic{std::move(topic)},
-          flush_timeout_ms(flush_timeout_ms) {}
-};
-
-template <typename Mutex>
-class kafka_sink : public base_sink<Mutex> {
-public:
-    kafka_sink(kafka_sink_config config)
-        : config_{std::move(config)} {
-        try {
-            std::string errstr;
-            conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL));
-            RdKafka::Conf::ConfResult confRes =
-                conf_->set("bootstrap.servers", config_.server_addr, errstr);
-            if (confRes != RdKafka::Conf::CONF_OK) {
-                throw_spdlog_ex(
-                    fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr));
-            }
-
-            tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC));
-            if (tconf_ == nullptr) {
-                throw_spdlog_ex(fmt_lib::format("create topic config failed"));
-            }
-
-            producer_.reset(RdKafka::Producer::create(conf_.get(), errstr));
-            if (producer_ == nullptr) {
-                throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr));
-            }
-            topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic,
-                                                tconf_.get(), errstr));
-            if (topic_ == nullptr) {
-                throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr));
-            }
-        } catch (const std::exception &e) {
-            throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what()));
-        }
-    }
-
-    ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); }
-
-protected:
-    void sink_it_(const details::log_msg &msg) override {
-        producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY,
-                           (void *)msg.payload.data(), msg.payload.size(), NULL, NULL);
-    }
-
-    void flush_() override { producer_->flush(config_.flush_timeout_ms); }
-
-private:
-    kafka_sink_config config_;
-    std::unique_ptr<RdKafka::Producer> producer_ = nullptr;
-    std::unique_ptr<RdKafka::Conf> conf_ = nullptr;
-    std::unique_ptr<RdKafka::Conf> tconf_ = nullptr;
-    std::unique_ptr<RdKafka::Topic> topic_ = nullptr;
-};
-
-using kafka_sink_mt = kafka_sink<std::mutex>;
-using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>;
-
-}  // namespace sinks
-
-template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name,
-                                               spdlog::sinks::kafka_sink_config config) {
-    return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
-}
-
-template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name,
-                                               spdlog::sinks::kafka_sink_config config) {
-    return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
-}
-
-template <typename Factory = spdlog::async_factory>
-inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(
-    std::string logger_name, spdlog::sinks::kafka_sink_config config) {
-    return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
-}
-
-template <typename Factory = spdlog::async_factory>
-inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(
-    std::string logger_name, spdlog::sinks::kafka_sink_config config) {
-    return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
-}
-
-}  // namespace spdlog

include/spdlog/sinks/mongo_sink.h

@@ -25,46 +25,51 @@
 
 namespace spdlog {
 namespace sinks {
-template <typename Mutex>
+template<typename Mutex>
-class mongo_sink : public base_sink<Mutex> {
+class mongo_sink : public base_sink<Mutex>
+{
 public:
-    mongo_sink(const std::string &db_name,
+    mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
-               const std::string &collection_name,
+    try : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri)
-               const std::string &uri = "mongodb://localhost:27017") try
+    {}
-        : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri) {
+    catch (const std::exception &e)
-    } catch (const std::exception &e) {
+    {
         throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
     }
 
-    mongo_sink(std::shared_ptr<mongocxx::instance> instance,
+    mongo_sink(std::shared_ptr<mongocxx::instance> instance, const std::string &db_name, const std::string &collection_name,
-               const std::string &db_name,
-               const std::string &collection_name,
         const std::string &uri = "mongodb://localhost:27017")
-        : instance_(std::move(instance)),
+        : instance_(std::move(instance))
-          db_name_(db_name),
+        , db_name_(db_name)
-          coll_name_(collection_name) {
+        , coll_name_(collection_name)
-        try {
+    {
+        try
+        {
             client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
-        } catch (const std::exception &e) {
+        }
+        catch (const std::exception &e)
+        {
             throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
         }
     }
 
-    ~mongo_sink() { flush_(); }
+    ~mongo_sink()
+    {
+        flush_();
+    }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override {
+    void sink_it_(const details::log_msg &msg) override
+    {
         using bsoncxx::builder::stream::document;
         using bsoncxx::builder::stream::finalize;
 
-        if (client_ != nullptr) {
+        if (client_ != nullptr)
-            auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level"
+        {
-                                  << level::to_string_view(msg.level).data() << "level_num"
+            auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data()
-                                  << msg.level << "message"
+                                  << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end())
-                                  << std::string(msg.payload.begin(), msg.payload.end())
+                                  << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id"
-                                  << "logger_name"
+                                  << static_cast<int>(msg.thread_id) << finalize;
-                                  << std::string(msg.logger_name.begin(), msg.logger_name.end())
-                                  << "thread_id" << static_cast<int>(msg.thread_id) << finalize;
             client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
         }
     }
@@ -85,24 +90,18 @@ using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;
 
 } // namespace sinks
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> mongo_logger_mt(
+inline std::shared_ptr<logger> mongo_logger_mt(const std::string &logger_name, const std::string &db_name,
-    const std::string &logger_name,
+    const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
-    const std::string &db_name,
+{
-    const std::string &collection_name,
+    return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name, uri);
-    const std::string &uri = "mongodb://localhost:27017") {
-    return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name,
-                                                          uri);
 }
 
-template <typename Factory = spdlog::synchronous_factory>
+template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> mongo_logger_st(
+inline std::shared_ptr<logger> mongo_logger_st(const std::string &logger_name, const std::string &db_name,
-    const std::string &logger_name,
+    const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017")
-    const std::string &db_name,
+{
-    const std::string &collection_name,
+    return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name, uri);
-    const std::string &uri = "mongodb://localhost:27017") {
-    return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name,
-                                                          uri);
 }
 
 } // namespace spdlog