Fix warning C4530 (#3393)

* Fix warning C4530

* Rename FMT_EXCEPTIONS to FMT_USE_EXCEPTIONS

.clang-format

@@ -1,109 +1,19 @@
 ---
 Language:        Cpp
-# BasedOnStyle:  LLVM
+BasedOnStyle:  Google
 AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
+Standard:        c++17
-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
-IndentWrappedFunctionNames: false
+TabWidth:        4
-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
-IndentPPDirectives: AfterHash
+ColumnLimit:     100
+AlignAfterOpenBracket: Align
+BinPackParameters: false
+AlignEscapedNewlines: Left
+AlwaysBreakTemplateDeclarations: Yes
+PackConstructorInitializers: Never
+BreakConstructorInitializersBeforeComma: false
+IndentPPDirectives: BeforeHash
+SortIncludes:    Never
 ...
 

.clang-tidy

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

.git-blame-ignore-revs

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

.github/workflows/linux.yml

@@ -0,0 +1,87 @@
+name: linux
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  # -----------------------------------------------------------------------
+  # Linux build matrix
+  # -----------------------------------------------------------------------
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - { 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: 12, build_type: Debug, cppstd: 17 }
+          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, tsan: ON }
+    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' || '' }})"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup
+        run: |
+          apt-get update
+          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
+          ./install-cmake.sh --prefix=/usr/local --skip-license
+      - name: Setup Compiler
+        if: matrix.config.compiler == 'clang'
+        run: |
+          scripts/ci_setup_clang.sh "${{ matrix.config.version }}"
+          echo "CXXFLAGS=-stdlib=libc++" >> $GITHUB_ENV          
+          echo "CC=clang-${{ matrix.config.version }}" >> $GITHUB_ENV
+          echo "CXX=clang++-${{ matrix.config.version }}" >> $GITHUB_ENV
+      - name: Build
+        run: |
+          mkdir -p build && cd build
+          cmake .. \
+            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
+            -DCMAKE_CXX_STANDARD=${{ matrix.config.cppstd }} \
+            -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.examples || 'ON' }} \
+            -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.examples || 'ON' }} \
+            -DSPDLOG_BUILD_WARNINGS=ON \
+            -DSPDLOG_BUILD_BENCH=OFF \
+            -DSPDLOG_BUILD_TESTS=ON \
+            -DSPDLOG_BUILD_TESTS_HO=OFF \
+            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'OFF' }} \
+            -DSPDLOG_SANITIZE_THREAD=${{ matrix.config.tsan || 'OFF' }}
+          make -j 4
+          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
+      - name: Build
+        run: |
+          mkdir -p build && cd build
+          cmake .. \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_STANDARD=11 \
+            -DSPDLOG_BUILD_EXAMPLE=ON \
+            -DSPDLOG_BUILD_EXAMPLE_HO=ON \
+            -DSPDLOG_BUILD_WARNINGS=ON \
+            -DSPDLOG_BUILD_BENCH=OFF \
+            -DSPDLOG_BUILD_TESTS=ON \
+            -DSPDLOG_BUILD_TESTS_HO=OFF \
+            -DSPDLOG_SANITIZE_ADDRESS=OFF
+          make -j 4
+          ctest -j 4 --output-on-failure

.github/workflows/macos.yml

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,148 @@
+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

@@ -1,4 +1,6 @@
 # Auto generated files
+[Dd]ebug/
+[Rr]elease/
 build/*
 *.slo
 *.lo
@@ -55,6 +57,7 @@ example/*
 
 # generated files
 generated
+version.rc
 
 # Cmake
 CMakeCache.txt
@@ -67,9 +70,14 @@ install_manifest.txt
 /tests/tests.VC.db
 /tests/tests
 /tests/logs/*
+spdlogConfig.cmake
+spdlogConfigVersion.cmake
+compile_commands.json
 
 # idea
 .idea/
+.cache/
+.vscode/
 cmake-build-*/
 *.db
 *.ipch
@@ -81,3 +89,10 @@ cmake-build-*/
 *.tcl
 *.user
 *.sln
+
+# macos
+*.DS_store
+*.xcodeproj/
+/.vs
+/out/build
+/CMakeSettings.json

.travis.yml

@@ -1,152 +0,0 @@
-# Adapted from various sources, including:
-# - Louis Dionne's Hana: https://github.com/ldionne/hana
-# - Paul Fultz II's FIT: https://github.com/pfultz2/Fit
-# - Eric Niebler's range-v3: https://github.com/ericniebler/range-v3
-sudo: required
-language: cpp
-
-# gcc t
-addons: &gcc48
-  apt:
-    packages:
-      - g++-4.8
-    sources:
-      - ubuntu-toolchain-r-test
-
-# gcc 7.0
-addons: &gcc7
-  apt:
-    packages:
-      - g++-7
-    sources:
-      - ubuntu-toolchain-r-test
-
-
-# gcc 9.0
-addons: &gcc9
-  apt:
-    packages:
-      - g++-9
-    sources:
-      - ubuntu-toolchain-r-test
-      
-# gcc 11.0
-addons: &gcc11
-  apt:
-    packages:
-      - g++-11
-    sources:
-      - ubuntu-toolchain-r-test
-
-
-# Clang 3.5
-addons: &clang35
-  apt:
-    packages:
-      - clang-3.5
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise-3.5
-      
-
-addons: &clang10
-  apt:
-    packages:
-      - clang-10
-      - lldb-10
-      - lld-10
-    sources:
-      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main"
-        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
-        
-addons: &clang12
-  apt:
-    packages:
-      - clang-12
-      - lldb-12
-      - lld-12
-    sources:
-      - sourceline: "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main"
-        key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"        
-
-
-matrix:
-  include:
-    # Test gcc-4.8: C++11, Build=Release
-    - env: GCC_VERSION=4.8 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *gcc48
-      
-    # Test gcc-7: C++11, Build=Release
-    - env: GCC_VERSION=7 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *gcc7
-      
-    # Test gcc-9: C++17, Build=Release
-    - env: GCC_VERSION=9 BUILD_TYPE=Release CPP=17
-      os: linux
-      addons: *gcc9
-
-    # Test gcc-11.0: C++20, Build=Debug
-    - env: GCC_VERSION=11 BUILD_TYPE=Debug CPP=20 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *gcc11
-      
-    # Test clang-3.5: C++11, Build=Release
-    - env: CLANG_VERSION=3.5 BUILD_TYPE=Release CPP=11
-      os: linux
-      addons: *clang35
-
-    # Text osx
-    - env: BUILD_TYPE=Release CPP=11 ASAN=Off TSAN=Off
-      os: osx
-
-    # Test clang-10.0: C++11, Build=Release
-    - env: CLANG_VERSION=10 BUILD_TYPE=Release CPP=11 ASAN=On
-      os: linux
-      dist: bionic
-      addons: *clang10
-      
-    # Test clang-10.0: C++17, Build=Debug
-    - env: CLANG_VERSION=10 BUILD_TYPE=Debug CPP=17 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *clang10
-      
-            
-    # Test clang-12.0: C++17, Build=Debug
-    - env: CLANG_VERSION=12 BUILD_TYPE=Debug CPP=17 ASAN=Off
-      os: linux
-      dist: bionic
-      addons: *clang12
-          
-                        
-before_script:
-  - if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
-  - if [ -n "$CLANG_VERSION" ]; then export CXX="clang++-${CLANG_VERSION}" CC="clang-${CLANG_VERSION}"; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export CXX="clang++" CC="clang"; fi
-  - which $CXX
-  - which $CC
-  - $CXX --version
-  - cmake --version
-
-script:
-  - cd ${TRAVIS_BUILD_DIR}
-  - mkdir -p build && cd build
-  - |
-    cmake .. \
-      --warn-uninitialized \
-      -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-      -DCMAKE_CXX_STANDARD=$CPP \
-      -DSPDLOG_BUILD_EXAMPLE=ON \
-      -DSPDLOG_BUILD_EXAMPLE_HO=ON \
-      -DSPDLOG_BUILD_WARNINGS=ON \
-      -DSPDLOG_BUILD_BENCH=OFF \
-      -DSPDLOG_BUILD_TESTS=ON \
-      -DSPDLOG_BUILD_TESTS_HO=OFF \
-      -DSPDLOG_SANITIZE_ADDRESS=$ASAN 
-      
-  - make VERBOSE=1 -j2
-  - ctest -j2 --output-on-failure
-  

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.10)
+cmake_minimum_required(VERSION 3.10...3.21)
 
 # ---------------------------------------------------------------------------------------
 # Start spdlog project
@@ -15,50 +15,42 @@ message(STATUS "Build spdlog: ${SPDLOG_VERSION}")
 
 include(GNUInstallDirs)
 
-# ---------------------------------------------------------------------------------------
-# Set CMake policies to support later version behaviour
-# ---------------------------------------------------------------------------------------
-if(POLICY CMP0077)
-    cmake_policy(SET CMP0077 NEW) # option() honors variables already set
-endif()
-
 # ---------------------------------------------------------------------------------------
 # Set default build to release
 # ---------------------------------------------------------------------------------------
-if(NOT CMAKE_BUILD_TYPE)
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if(NOT CMAKE_CXX_STANDARD)
+if (SPDLOG_USE_STD_FORMAT)
+    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")
+if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS" OR CMAKE_SYSTEM_NAME MATCHES "MINGW")
     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)
 
@@ -68,6 +60,9 @@ option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
 # precompiled headers option
 option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)
 
+# build position independent code
+option(SPDLOG_BUILD_PIC "Build position independent code (-fPIC)" OFF)
+
 # example options
 option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
 option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
@@ -81,99 +76,135 @@ 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_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)
+    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
+endif ()
+
+if (SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
+    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
+endif ()
 
 # misc tweakme options
-if(WIN32)
+if (WIN32)
     option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
     option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-else()
+    option(SPDLOG_WCHAR_CONSOLE "Support wchar output to console" OFF)
+else ()
     set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
     set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
-endif()
+    set(SPDLOG_WCHAR_CONSOLE OFF CACHE BOOL "non supported option" FORCE)
+endif ()
 
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+if (MSVC)
+    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)
 option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
 option(
-    SPDLOG_NO_ATOMIC_LEVELS
+        SPDLOG_NO_ATOMIC_LEVELS
-    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
+        "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
-    OFF)
+        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
-if(${CMAKE_VERSION} VERSION_GREATER "3.5")
+option(SPDLOG_TIDY "run clang-tidy" OFF)
-    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)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif ()
 
 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
-# Static/Shared library (shared not supported in windows yet)
+# Static/Shared library
 # ---------------------------------------------------------------------------------------
 set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)
 
-if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+if (NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-    list(APPEND SPDLOG_SRCS src/fmt.cpp)
+    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(MSVC)
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
         target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
-                                             /wd4275>)
+                /wd4275>)
-    endif()
+    endif ()
-    if(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_EXPORT PUBLIC FMT_SHARED)
+        target_compile_definitions(spdlog PRIVATE FMT_LIB_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 PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-                                         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+        "$<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 ${SPDLOG_VERSION_MAJOR})
+set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
+        ${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
@@ -181,92 +212,134 @@ endif()
 add_library(spdlog_header_only INTERFACE)
 add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
 
-target_include_directories(spdlog_header_only INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+target_include_directories(
-                                                        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+        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-nly
+    # use external fmt-header-only
-    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})
-foreach(
+set(SPDLOG_UTF8_TO_WCHAR_CONSOLE ${SPDLOG_WCHAR_CONSOLE})
-    SPDLOG_OPTION
+foreach (
-    SPDLOG_WCHAR_TO_UTF8_SUPPORT
+        SPDLOG_OPTION
-    SPDLOG_WCHAR_FILENAMES
+        SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    SPDLOG_NO_EXCEPTIONS
+        SPDLOG_UTF8_TO_WCHAR_CONSOLE
-    SPDLOG_CLOCK_COARSE
+        SPDLOG_WCHAR_FILENAMES
-    SPDLOG_PREVENT_CHILD_FD
+        SPDLOG_NO_EXCEPTIONS
-    SPDLOG_NO_THREAD_ID
+        SPDLOG_CLOCK_COARSE
-    SPDLOG_NO_TLS
+        SPDLOG_PREVENT_CHILD_FD
-    SPDLOG_NO_ATOMIC_LEVELS
+        SPDLOG_NO_THREAD_ID
-    SPDLOG_DISABLE_DEFAULT_LOGGER)
+        SPDLOG_NO_TLS
-    if(${SPDLOG_OPTION})
+        SPDLOG_NO_ATOMIC_LEVELS
+        SPDLOG_DISABLE_DEFAULT_LOGGER
+        SPDLOG_USE_STD_FORMAT)
+    if (${SPDLOG_OPTION})
         target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
         target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
-    endif()
+    endif ()
-endforeach()
+endforeach ()
 
-if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC)
+if (MSVC)
-    target_compile_options(spdlog PRIVATE -fno-exceptions)
+    target_compile_options(spdlog PRIVATE "/Zc:__cplusplus")
-endif()
+    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 ()
+        target_compile_options(spdlog PRIVATE /EHs-c-)
+        target_compile_definitions(spdlog PRIVATE _HAS_EXCEPTIONS=0)
+    endif ()
+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")
@@ -281,20 +354,30 @@ if(SPDLOG_INSTALL)
     # ---------------------------------------------------------------------------------------
     install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
     install(
-        TARGETS spdlog spdlog_header_only
+            TARGETS spdlog spdlog_header_only
-        EXPORT spdlog
+            EXPORT spdlog
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-    if(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 ()
+        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+    endif ()
+    if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+    else ()
+        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+    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}")
@@ -304,11 +387,12 @@ if(SPDLOG_INSTALL)
     # ---------------------------------------------------------------------------------------
     # Install CMake config files
     # ---------------------------------------------------------------------------------------
+    export(TARGETS spdlog spdlog_header_only 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}"
+    configure_package_config_file("${project_config_in}" "${project_config_out}" INSTALL_DESTINATION ${export_dest_dir})
-        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}")
@@ -317,4 +401,4 @@ if(SPDLOG_INSTALL)
     # Support creation of installable packages
     # ---------------------------------------------------------------------------------------
     include(cmake/spdlogCPack.cmake)
-endif()
+endif ()

INSTALL

@@ -1,24 +1,27 @@
-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 src/spdlog.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
+Or copy files src/*.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://github.com/fmtlib/fmt/blob/master/LICENSE.rst
+and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
 

README.md

@@ -1,58 +1,67 @@
 # spdlog
 
-Very fast, header-only/compiled, C++ logging library. [![Build Status](https://travis-ci.com/gabime/spdlog.svg?branch=v1.x)](https://travis-ci.com/gabime/spdlog)  [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
+ 
+[![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](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
+Copy the include [folder](include/spdlog) to your build tree and use a C++11 compiler.
 
-#### Static lib version (recommended - much faster compile times)
+#### Compiled version (recommended - much faster compile times)
 ```console
 $ git clone https://github.com/gabime/spdlog.git
 $ cd spdlog && mkdir build && cd build
-$ cmake .. && make -j
+$ cmake .. && cmake --build .
 ```
-      
+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`
 * Homebrew: `brew install spdlog`
 * MacPorts: `sudo port install spdlog`
-* FreeBSD:  `cd /usr/ports/devel/spdlog/ && make install clean`
+* FreeBSD:  `pkg install spdlog`
 * Fedora: `dnf install spdlog`
 * 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: `spdlog/[>=1.4.1]`
+* conan: `conan install --requires=spdlog/[*]`
 * conda: `conda install -c conda-forge spdlog`
 * build2: ```depends: spdlog ^1.8.2```
 
 
-
 ## 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/3.-Custom-formatting) formatting.
+* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
 * Multi/Single threaded loggers.
 * Various log targets:
-    * Rotating log files.
+  * Rotating log files.
-    * Daily log files.
+  * Daily log files.
-    * Console logging (colors supported).
+  * Console logging (colors supported).
-    * syslog.
+  * syslog.
-    * Windows event log.
+  * Windows event log.
-    * Windows debugger (```OutputDebugString(..)```).
+  * Windows debugger (```OutputDebugString(..)```).
-    * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
+  * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).
-* Log filtering - log levels can be modified in runtime as well as in compile time.
+  * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets.
-* Support for loading log levels from argv or from environment var.
+* Log filtering - log levels can be modified at runtime as well as compile time.
-* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display later on demand.
+* Support for loading log levels from argv or environment var.
+* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
 
 ## Usage samples
 
@@ -78,7 +87,8 @@ int main()
     spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
     
     // Compile time log levels
-    // define SPDLOG_ACTIVE_LEVEL to desired level
+    // Note that this does not change the current log level, it will only
+    // 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");
 }
@@ -91,7 +101,7 @@ int main()
 #include "spdlog/sinks/stdout_color_sinks.h"
 void stdout_example()
 {
-    // create color multi threaded logger
+    // create a 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)");
@@ -120,7 +130,7 @@ void basic_logfile_example()
 #include "spdlog/sinks/rotating_file_sink.h"
 void rotating_example()
 {
-    // Create a file rotating logger with 5mb size max and 3 rotated files
+    // Create a file rotating logger with 5 MB 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);
@@ -134,7 +144,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 on 2:30am
+    // Create a daily logger - a new file is created every day at 2:30 am
     auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
 }
 
@@ -144,10 +154,10 @@ void daily_example()
 #### Backtrace support
 ```c++
 // Debug messages can be stored in a ring buffer instead of being logged immediately.
-// This is useful in order to display debug logs only when really needed (e.g. when error happens).
+// This is useful to display debug logs only when needed (e.g. when an error happens).
-// When needed, call dump_backtrace() to see them.
+// When needed, call dump_backtrace() to dump them to your log.
 
-spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. Older messages will be dropped.
+spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. 
 // or my_logger->enable_backtrace(32)..
 for(int i = 0; i < 100; i++)
 {
@@ -155,7 +165,6 @@ 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)..
 ```
 
@@ -163,7 +172,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));
 
 ```
@@ -191,7 +200,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 to lines.
+// {:n} - don't split the output into lines.
 // {:a} - show ASCII if :n is not set.
 
 #include "spdlog/fmt/bin_to_hex.h"
@@ -211,11 +220,11 @@ void binary_example()
 ```
 
 ---
-#### Logger with multi sinks - each with different format and log level
+#### Logger with multi sinks - each with a different format and log level
 ```c++
 
-// create logger with 2 targets with different log levels and formats.
+// create a 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>();
@@ -232,6 +241,27 @@ 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++
@@ -251,6 +281,7 @@ 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"
 
@@ -266,29 +297,26 @@ void multi_sink_example2()
 ```
  
 ---
-#### User defined types
+#### User-defined types
 ```c++
-// user defined types logging by implementing operator<<
+template<>
-#include "spdlog/fmt/ostr.h" // must be included
+struct fmt::formatter<my_type> : fmt::formatter<std::string>
-struct my_type
 {
-    int i;
+    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
     {
-        return os << "[my_type i=" << c.i << "]";
+        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
     }
 };
 
 void user_defined_example()
 {
-    spdlog::get("console")->info("user defined type: {}", my_type{14});
+    spdlog::info("user defined type: {}", my_type(14));
 }
 
 ```
 
 ---
-#### 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.
@@ -353,14 +381,17 @@ void android_example()
 ```
 
 ---
-#### Load log levels from env variable or from argv
+#### Load log levels from the env variable or argv
 
 ```c++
 #include "spdlog/cfg/env.h"
 int main (int argc, char *argv[])
 {
     spdlog::cfg::load_env_levels();
-    // or from command line:
+    // or specify the env variable name:
+    // 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);
@@ -373,10 +404,70 @@ $ export SPDLOG_LEVEL=info,mylogger=trace
 $ ./example
 ```
 
+
+---
+#### Log file open/close event handlers
+```c++
+// You can get callbacks from spdlog before/after a 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.
+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) { spdlog::info("Before opening {}", filename); };
+    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("After opening\n", fstream); };
+    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("Before closing\n", fstream); };
+    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
+    auto my_logger = spdlog::basic_logger_st("some_logger", "logs/events-sample.txt", true, handlers);        
+}
+```
+
+---
+#### Replace the Default Logger
+```c++
+void replace_default_logger_example()
+{
+    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
+    spdlog::set_default_logger(new_logger);
+    spdlog::info("new logger log message");
+}
+```
+
+---
+#### 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](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
 ```
@@ -428,7 +519,8 @@ Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/ben
 ```
 
 ## 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,61 +2,72 @@ version: 1.0.{build}
 image: Visual Studio 2017
 environment:
   matrix:
-    - GENERATOR: '"Visual Studio 14 2015"'
-      BUILD_TYPE: Debug
-      BUILD_SHARED: 'OFF'
-      WCHAR: 'OFF'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-    - GENERATOR: '"Visual Studio 14 2015"'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'OFF'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-    - GENERATOR: '"Visual Studio 14 2015 Win64"'
-      BUILD_TYPE: Debug
-      BUILD_SHARED: 'OFF'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-    - GENERATOR: '"Visual Studio 14 2015 Win64"'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'OFF'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
     - GENERATOR: '"Visual Studio 15 2017 Win64"'
       BUILD_TYPE: Debug
       BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
       WCHAR: 'ON'
       WCHAR_FILES: 'OFF'
       BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
     - GENERATOR: '"Visual Studio 15 2017 Win64"'
       BUILD_TYPE: Release
       BUILD_SHARED: 'OFF'
+      FATAL_ERRORS: 'OFF'
       WCHAR: 'OFF'
       WCHAR_FILES: 'OFF'
       BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
     - GENERATOR: '"Visual Studio 15 2017 Win64"'
       BUILD_TYPE: Release
       BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
       WCHAR: 'OFF'
       WCHAR_FILES: 'OFF'
       BUILD_EXAMPLE: 'ON'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
     - GENERATOR: '"Visual Studio 15 2017 Win64"'
       BUILD_TYPE: Release
       BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'OFF'
       WCHAR: 'ON'
       WCHAR_FILES: 'ON'
       BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 11
     - GENERATOR: '"Visual Studio 16 2019" -A x64'
       BUILD_TYPE: Release
       BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
       WCHAR: 'OFF'
       WCHAR_FILES: 'OFF'
       BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'OFF'
+      CXX_STANDARD: 17
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - GENERATOR: '"Visual Studio 17 2022" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'OFF'
+      WCHAR_FILES: 'OFF'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'ON'
+      CXX_STANDARD: 20
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+    - GENERATOR: '"Visual Studio 17 2022" -A x64'
+      BUILD_TYPE: Release
+      BUILD_SHARED: 'ON'
+      FATAL_ERRORS: 'ON'
+      WCHAR: 'ON'
+      WCHAR_FILES: 'ON'
+      BUILD_EXAMPLE: 'OFF'
+      USE_STD_FORMAT: 'ON'
+      CXX_STANDARD: 20
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
 build_script:
   - cmd: >-
       set
@@ -67,12 +78,12 @@ build_script:
 
       set PATH=%PATH%;C:\Program Files\Git\usr\bin
 
-      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=ON ..
+      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=%FATAL_ERRORS% -D SPDLOG_USE_STD_FORMAT=%USE_STD_FORMAT% -D CMAKE_CXX_STANDARD=%CXX_STANDARD% ..
 
       cmake --build . --config %BUILD_TYPE%
 
 before_test:
-  - set PATH=%PATH%;C:\projects\spdlog\build\%BUILD_TYPE%
+  - set PATH=%PATH%;C:\projects\spdlog\build\_deps\catch2-build\src\%BUILD_TYPE%;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.10)
+cmake_minimum_required(VERSION 3.11)
 project(spdlog_bench CXX)
 
 if(NOT TARGET spdlog)
@@ -12,18 +12,15 @@ 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
-        # User can fetch googlebenchmark
+    message(STATUS "Downloading GoogleBenchmark")
-        message(STATUS "Downloading GoogleBenchmark")
+    include(FetchContent)
-        include(FetchContent)
-        set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE INTERNAL "")
-        # Do not build and run googlebenchmark tests
-        FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.5.2)
 
-        FetchContent_MakeAvailable(googlebenchmark)
+    # disable tests
-    else()
+    set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL "")
-        message(FATAL_ERROR "GoogleBenchmark is missing. Use CMake >= 3.11 or download it")
+    # Do not build and run googlebenchmark tests
-    endif()
+    FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0)
+    FetchContent_MakeAvailable(googlebenchmark)
 endif()
 
 add_executable(bench bench.cpp)

bench/async_bench.cpp

@@ -10,10 +10,12 @@
 #include "spdlog/async.h"
 #include "spdlog/sinks/basic_file_sink.h"
 
-#ifdef SPDLOG_FMT_EXTERNAL
+#if defined(SPDLOG_USE_STD_FORMAT)
-#    include <fmt/format.h>
+    #include <format>
+#elif defined(SPDLOG_FMT_EXTERNAL)
+    #include <fmt/format.h>
 #else
-#    include "spdlog/fmt/bundled/format.h"
+    #include "spdlog/fmt/bundled/format.h"
 #endif
 
 #include "utils.h"
@@ -32,81 +34,69 @@ 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
+#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,
-        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count, expected_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)
+        if (argc > 1) howmany = atoi(argv[1]);
-            howmany = atoi(argv[1]);
+        if (argc > 2) threads = atoi(argv[2]);
-        if (argc > 2)
+        if (argc > 3) {
-            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)
+        if (argc > 4) iters = atoi(argv[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, (queue_size * slot_size) / 1024);
+        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size,
+                     (queue_size * slot_size) / 1024);
         spdlog::info("Total iters  : {:L}", iters);
         spdlog::info("-------------------------------------------------");
 
@@ -115,11 +105,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>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
+            auto logger = std::make_shared<async_logger>(
+                "async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
             bench_mt(howmany, std::move(logger), threads);
             // verify_file(filename, howmany);
         }
@@ -130,18 +120,16 @@ 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), async_overflow_policy::overrun_oldest);
+                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp),
+                                               async_overflow_policy::overrun_oldest);
             bench_mt(howmany, std::move(logger), threads);
         }
         spdlog::shutdown();
-    }
+    } catch (std::exception &ex) {
-    catch (std::exception &ex)
-    {
         std::cerr << "Error: " << ex.what() << std::endl;
         perror("Last error");
         return 1;
@@ -149,34 +137,30 @@ 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<thread> threads;
+    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(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
+            threads.push_back(
+                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

@@ -12,15 +12,17 @@
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
 
-#ifdef SPDLOG_FMT_EXTERNAL
+#if defined(SPDLOG_USE_STD_FORMAT)
-#    include <fmt/locale.h>
+    #include <format>
+#elif defined(SPDLOG_FMT_EXTERNAL)
+    #include <fmt/format.h>
 #else
-#    include "spdlog/fmt/bundled/format.h"
+    #include "spdlog/fmt/bundled/format.h"
 #endif
 
 #include "utils.h"
 #include <atomic>
-#include <cstdlib> // EXIT_FAILURE
+#include <cstdlib>  // EXIT_FAILURE
 #include <memory>
 #include <string>
 #include <thread>
@@ -35,22 +37,25 @@ 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(fmt::format(std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
+    spdlog::info(spdlog::fmt_lib::format(
+        std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
     spdlog::info("**************************************************************");
 
     auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
     bench_mt(iters, std::move(basic_mt), threads);
-    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
+    auto basic_mt_tracing =
+        spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
     basic_mt_tracing->enable_backtrace(32);
     bench_mt(iters, std::move(basic_mt_tracing), threads);
 
     spdlog::info("");
-    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
+    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size,
+                                                  rotating_files);
     bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
+    auto rotating_mt_tracing = spdlog::rotating_logger_mt(
+        "rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
     rotating_mt_tracing->enable_backtrace(32);
     bench_mt(iters, std::move(rotating_mt_tracing), threads);
 
@@ -71,22 +76,25 @@ 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(fmt::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
+    spdlog::info(
+        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 = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
+    auto basic_st_tracing =
+        spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
     bench(iters, std::move(basic_st_tracing));
 
     spdlog::info("");
-    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
+    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size,
+                                                  rotating_files);
     bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
+    auto rotating_st_tracing = spdlog::rotating_logger_st(
+        "rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
     rotating_st_tracing->enable_backtrace(32);
     bench(iters, std::move(rotating_st_tracing));
 
@@ -108,63 +116,54 @@ 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(
-            throw std::runtime_error(fmt::format("Number of threads exceeds maximum({})", max_threads));
+                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::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-        fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
+                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
+                                         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;
@@ -172,25 +171,23 @@ 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::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-        fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
+                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
+                                         delta_d, size_t(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 
@@ -213,7 +210,8 @@ 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 / delta_d));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
+delta_d));
 }
 
 void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
@@ -222,11 +220,12 @@ 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 metus cursus "
+    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra
-                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+metus cursus " "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus
-                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+volutpat mi, eu consequat sem " "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam
-                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+non dapibus eros. Donec fringilla dui sed " "augue pretium, nec scelerisque est maximus. Nullam
-                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
+convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu
+odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
 
     auto orig_default = spdlog::default_logger();
     spdlog::set_default_logger(log);
@@ -240,7 +239,8 @@ void bench_c_string(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 / delta_d));
+    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
+delta_d));
 }
 
 */

bench/formatter-bench.cpp

@@ -8,31 +8,28 @@
 #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 = "Hello. This is some message with length of 80                                   ";
+    const char *text =
+        "Hello. This is some message with length of 80                                   ";
 
     spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
     spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
 
-    for (auto _ : state)
+    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);
 
@@ -50,29 +47,23 @@ 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)
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)->Iterations(2500000);
+            ->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,66 +16,72 @@
 #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 =
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
+        "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, "
-                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
+        "eu consequat sem "
-                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
+        "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec "
-                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
+        "fringilla dui sed "
+        "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, "
+        "nisi turpis ornare "
+        "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue "
+        "nibh turpis duis.";
 
-    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) {
-void bench_logger_fmt_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
+    spdlog::set_default_logger(std::move(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(i);       // prevent unused warnings
-    benchmark::DoNotOptimize(logger); // 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))->UseRealTime();
+    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))
+        ->UseRealTime();
     spdlog::drop("/dev/null_st");
 
     auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
+    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))
+        ->UseRealTime();
     spdlog::drop("/dev/null_mt");
 }
-#endif // __linux__
+#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;
 
@@ -86,77 +92,108 @@ int main(int argc, char *argv[])
     auto full_bench = argc > 1 && std::string(argv[1]) == "full";
 
     // disabled loggers
-    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    auto disabled_logger =
+        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
     disabled_logger->set_level(spdlog::level::off);
     benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-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 = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    auto tracing_disabled_logger =
+        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
     tracing_disabled_logger->enable_backtrace(64);
-    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger,
+                                 tracing_disabled_logger);
 
-    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    auto null_logger_st =
-    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
+        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string,
+                                 std::move(null_logger_st));
     benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    benchmark::RegisterBenchmark("null_sink_fmt_string", bench_logger_fmt_string, null_logger_st);
+    benchmark::RegisterBenchmark("null_sink_st (global logger)", bench_global_logger,
+                                 null_logger_st);
     // with backtrace of 64
-    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    auto tracing_null_logger_st =
+        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
     tracing_null_logger_st->enable_backtrace(64);
     benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
 
-#ifdef __linux
+#ifdef __linux__
     bench_dev_null();
-#endif // __linux__
+#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 = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
+        auto tracing_basic_st =
+            spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
         tracing_basic_st->enable_backtrace(64);
-        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
+        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger,
+                                     std::move(tracing_basic_st))
+            ->UseRealTime();
         spdlog::drop("tracing_basic_st");
 
         // rotating st
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log",
-        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
+                                                      file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))
+            ->UseRealTime();
         spdlog::drop("rotating_st");
         // with backtrace of 64
-        auto tracing_rotating_st =
+        auto tracing_rotating_st = spdlog::rotating_logger_st(
-            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
+            "tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size,
-        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
+            rotating_files);
+        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger,
+                                     std::move(tracing_rotating_st))
+            ->UseRealTime();
         spdlog::drop("tracing_rotating_st");
 
         // daily st
         auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
         benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
         spdlog::drop("daily_st");
-        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
+        auto tracing_daily_st =
-        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
+            spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger,
+                                     std::move(tracing_daily_st))
+            ->UseRealTime();
         spdlog::drop("tracing_daily_st");
 
         //
         // Multi threaded bench, 10 loggers using same logger concurrently
         //
-        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+        auto null_logger_mt =
-        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
+            std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)
+            ->Threads(n_threads)
+            ->UseRealTime();
 
         // basic_mt
         auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
-        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
+        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))
+            ->Threads(n_threads)
+            ->UseRealTime();
         spdlog::drop("basic_mt");
 
         // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log",
-        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
+                                                      file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))
+            ->Threads(n_threads)
+            ->UseRealTime();
         spdlog::drop("rotating_mt");
 
         // daily mt
         auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
-        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
+        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))
+            ->Threads(n_threads)
+            ->UseRealTime();
         spdlog::drop("daily_mt");
     }
 
@@ -164,13 +201,19 @@ 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), spdlog::async_overflow_policy::overrun_oldest);
+        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp),
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
+        spdlog::async_overflow_policy::overrun_oldest);
+    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), spdlog::async_overflow_policy::overrun_oldest);
+        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp),
+        spdlog::async_overflow_policy::overrun_oldest);
     async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
+    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)
+        ->Threads(n_threads)
+        ->UseRealTime();
 
     benchmark::Initialize(&argc, argv);
     benchmark::RunSpecifiedBenchmarks();

bench/utils.h

@@ -11,9 +11,8 @@
 
 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);
@@ -21,9 +20,8 @@ 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);
@@ -31,4 +29,4 @@ inline std::string format(const double &value)
     return ss.str();
 }
 
-} // namespace utils
+}  // namespace utils

cmake/spdlog.pc.in

@@ -1,7 +1,7 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=${prefix}
-includedir=${prefix}/include
+includedir=@PKG_CONFIG_INCLUDEDIR@
-libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
+libdir=@PKG_CONFIG_LIBDIR@
 
 Name: lib@PROJECT_NAME@
 Description: Fast C++ logging library.

cmake/spdlogConfig.cmake.in

@@ -6,9 +6,10 @@
 find_package(Threads REQUIRED)
 
 set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)
+set(SPDLOG_FMT_EXTERNAL_HO @SPDLOG_FMT_EXTERNAL_HO@)
 set(config_targets_file @config_targets_file@)
 
-if(SPDLOG_FMT_EXTERNAL)
+if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
     include(CMakeFindDependencyMacro)
     find_dependency(fmt CONFIG)
 endif()

cmake/utils.cmake

@@ -49,7 +49,7 @@ function(spdlog_enable_warnings target_name)
 endfunction()
 
 # Enable address sanitizer (gcc/clang only)
-function(spdlog_enable_sanitizer target_name)
+function(spdlog_enable_addr_sanitizer target_name)
     if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
         message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
     endif()
@@ -58,5 +58,16 @@ function(spdlog_enable_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 -fuse-ld=gold)
+    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined)
+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.10)
+cmake_minimum_required(VERSION 3.11)
 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)
+target_link_libraries(example PRIVATE spdlog::spdlog $<$<BOOL:${MINGW}>:ws2_32>)
 
 # ---------------------------------------------------------------------------------------
 # Example of using header-only library

example/example.cpp

@@ -5,32 +5,39 @@
 // spdlog usage example
 
 #include <cstdio>
+#include <chrono>
 
 void load_levels_example();
 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();
 void stopwatch_example();
 void trace_example();
 void multi_sink_example();
 void user_defined_example();
 void err_handler_example();
 void syslog_example();
+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/cfg/env.h"   // support for loading levels from the environment variable
-#include "spdlog/fmt/ostr.h" // support for user defined types
+#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_VER_PATCH);
+    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR,
+                 SPDLOG_VER_PATCH);
 
     spdlog::warn("Easy padding in numbers like {:08d}", 12);
     spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -39,42 +46,46 @@ int main(int, char *[])
     spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
 
     // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
+    spdlog::set_level(spdlog::level::info);  // Set global log level to info
     spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
+    spdlog::set_level(spdlog::level::trace);  // Set specific logger's log level
     spdlog::debug("This message should be displayed..");
 
     // Customize msg format for all loggers
     spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
     spdlog::info("This an info message with custom format");
-    spdlog::set_pattern("%+"); // back to default format
+    spdlog::set_pattern("%+");  // back to default format
     spdlog::set_level(spdlog::level::info);
 
     // Backtrace support
     // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
     // When needed, call dump_backtrace() to see what happened:
-    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
+    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..
-        spdlog::debug("Backtrace message {}", i); // not logged..
     }
     // e.g. if some error happened:
-    spdlog::dump_backtrace(); // log them now!
+    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();
         multi_sink_example();
         user_defined_example();
         err_handler_example();
         trace_example();
         stopwatch_example();
+        udp_example();
         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!
@@ -89,8 +100,7 @@ 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;
     }
@@ -98,8 +108,7 @@ 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:
@@ -107,32 +116,41 @@ 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");
+    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 = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+    auto rotating_logger =
+        spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
 }
 
 #include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
+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
@@ -140,16 +158,17 @@ 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 = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
+    auto async_file =
+        spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
     // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
+    // auto async_file =
+    // 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);
     }
 }
@@ -163,16 +182,16 @@ void async_example()
 // {:p} - don't print the position on each line start.
 // {:n} - don't split the output to lines.
 
-#include "spdlog/fmt/bin_to_hex.h"
+#if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)
-void binary_example()
+    #include "spdlog/fmt/bin_to_hex.h"
-{
+void binary_example() {
-    std::vector<char> buf(80);
+    std::vector<char> buf;
-    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::to_hex(std::begin(buf), std::begin(buf) + 10));
+    spdlog::info("Another binary example:{:n}",
+                 spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
     // more examples:
     // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
     // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
@@ -180,11 +199,29 @@ 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"
+void vector_example() {
+    std::vector<int> vec = {1, 2, 3};
+    spdlog::info("Vector example: {}", vec);
+}
+
+#else
+void vector_example() {}
+#endif
+
+// ! DSPDLOG_USE_STD_FORMAT
 
 // 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
@@ -198,21 +235,28 @@ 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() {
+    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);
+    my_logger->info("hello world");
+}
+
 // 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 = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
+    auto file_sink =
+        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});
@@ -221,34 +265,44 @@ void multi_sink_example()
     logger.info("this message should not appear in the console, only in the file");
 }
 
-// User defined types logging by implementing operator<<
+// User defined types logging
-struct my_type
+struct my_type {
-{
+    int i = 0;
-    int i;
+    explicit my_type(int i)
-    template<typename OStream>
+        : i(i){}
-    friend OStream &operator<<(OStream &os, const my_type &c)
+};
-    {
+
-        return os << "[my_type i=" << c.i << "]";
+#ifndef SPDLOG_USE_STD_FORMAT  // when using fmtlib
+template <>
+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);
     }
 };
 
-void user_defined_example()
+#else  // when using std::format
-{
+template <>
-    spdlog::info("user defined type: {}", my_type{14});
+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);
+    }
+};
+#endif
+
+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) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
+    spdlog::set_error_handler([](const std::string &msg) {
+        printf("*** Custom log error handler: %s ***\n", msg.c_str());
+    });
 }
 
 // syslog example (linux/osx/freebsd)
 #ifndef _WIN32
-#    include "spdlog/sinks/syslog_sink.h"
+    #include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
+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.");
@@ -257,9 +311,8 @@ 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.");
@@ -269,26 +322,82 @@ 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 &, const std::tm &, spdlog::memory_buf_t &dest) override
+    void format(const spdlog::details::log_msg &,
-    {
+                const std::tm &,
+                spdlog::memory_buf_t &dest) override {
         std::string some_txt = "custom-flag";
         dest.append(some_txt.data(), some_txt.data() + some_txt.size());
     }
 
-    std::unique_ptr<custom_flag_formatter> clone() const override
+    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
-
-    using spdlog::details::make_unique; // for pre c++14
     auto formatter = make_unique<spdlog::pattern_formatter>();
     formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    spdlog::set_formatter(std::move(formatter));
+    // set the new formatter using spdlog::set_formatter(formatter) or
+    // logger->set_formatter(formatter) spdlog::set_formatter(std::move(formatter));
 }
+
+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) {
+        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);
+    };
+    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) {
+        spdlog::info("Before closing {}", filename);
+        fputs("Before closing\n", fstream);
+    };
+    handlers.after_close = [](spdlog::filename_t filename) {
+        spdlog::info("After closing {}", filename);
+    };
+    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() {
+    // store the old logger so we don't break other examples.
+    auto old_logger = spdlog::default_logger();
+
+    auto new_logger =
+        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!");
+    spdlog::set_level(spdlog::level::trace);
+    spdlog::debug("This message should be displayed..");
+
+    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,12 +31,10 @@ 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>
-    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
-    {
         auto &registry_inst = details::registry::instance();
 
         // create global thread pool if not already exists..
@@ -44,14 +42,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), std::move(tp), OverflowPolicy);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
+                                                         std::move(tp), OverflowPolicy);
         registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
@@ -60,34 +58,43 @@ 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, SinkArgs &&...sink_args)
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
-{
+                                                    SinkArgs &&...sink_args) {
-    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+    return async_factory::create<Sink>(std::move(logger_name),
+                                       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, SinkArgs &&...sink_args)
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
-{
+                                                       SinkArgs &&...sink_args) {
-    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+    return async_factory_nonblock::create<Sink>(std::move(logger_name),
+                                                std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
-inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
+inline void init_thread_pool(size_t q_size,
-{
+                             size_t thread_count,
-    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);
+                             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);
     details::registry::instance().set_tp(std::move(tp));
 }
 
-// set global thread pool.
+inline void init_thread_pool(size_t q_size,
-inline void init_thread_pool(size_t q_size, size_t thread_count)
+                             size_t thread_count,
-{
+                             std::function<void()> on_thread_start) {
-    init_thread_pool(q_size, thread_count, [] {});
+    init_thread_pool(q_size, thread_count, on_thread_start, [] {});
+}
+
+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
+}  // namespace spdlog

include/spdlog/async_logger-inl.h

@@ -4,88 +4,80 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/async_logger.h>
+    #include <spdlog/async_logger.h>
 #endif
 
-#include <spdlog/sinks/sink.h>
 #include <spdlog/details/thread_pool.h>
+#include <spdlog/sinks/sink.h>
 
 #include <memory>
 #include <string>
 
-SPDLOG_INLINE spdlog::async_logger::async_logger(
+SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
-    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+                                                 sinks_init_list sinks_list,
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+                                                 std::weak_ptr<details::thread_pool> tp,
-{}
+                                                 async_overflow_policy overflow_policy)
+    : async_logger(std::move(logger_name),
+                   sinks_list.begin(),
+                   sinks_list.end(),
+                   std::move(tp),
+                   overflow_policy) {}
 
-SPDLOG_INLINE spdlog::async_logger::async_logger(
+SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,
-    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+                                                 sink_ptr single_sink,
-    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+                                                 std::weak_ptr<details::thread_pool> tp,
-{}
+                                                 async_overflow_policy overflow_policy)
+    : async_logger(
+          std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {}
 
 // send the log message to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+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");
-        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");
-        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_) {
-    for (auto &sink : sinks_)
+        if (sink->should_log(msg.level)) {
-    {
+            SPDLOG_TRY { sink->log(msg); }
-        if (sink->should_log(msg.level))
+            SPDLOG_LOGGER_CATCH(msg.source)
-        {
-            SPDLOG_TRY
-            {
-                sink->log(msg);
-            }
-            SPDLOG_LOGGER_CATCH()
         }
     }
 
-    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_) {
-    for (auto &sink : sinks_)
+        SPDLOG_TRY { sink->flush(); }
-    {
+        SPDLOG_LOGGER_CATCH(source_loc())
-        SPDLOG_TRY
-        {
-            sink->flush();
-        }
-        SPDLOG_LOGGER_CATCH()
     }
 }
 
-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,35 +19,41 @@
 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
-    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.
-                   // 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>, public logger
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>,
-{
+                                      public logger {
     friend class details::thread_pool;
 
 public:
-    template<typename It>
+    template <typename It>
-    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
+    async_logger(std::string logger_name,
-        async_overflow_policy overflow_policy = async_overflow_policy::block)
+                 It begin,
-        : logger(std::move(logger_name), begin, end)
+                 It end,
-        , thread_pool_(std::move(tp))
+                 std::weak_ptr<details::thread_pool> tp,
-        , overflow_policy_(overflow_policy)
+                 async_overflow_policy overflow_policy = async_overflow_policy::block)
-    {}
+        : logger(std::move(logger_name), begin, end),
+          thread_pool_(std::move(tp)),
+          overflow_policy_(overflow_policy) {}
 
-    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
+    async_logger(std::string logger_name,
-        async_overflow_policy overflow_policy = async_overflow_policy::block);
+                 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, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
+    async_logger(std::string logger_name,
-        async_overflow_policy overflow_policy = async_overflow_policy::block);
+                 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;
 
@@ -61,8 +67,8 @@ private:
     std::weak_ptr<details::thread_pool> thread_pool_;
     async_overflow_policy overflow_policy_;
 };
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "async_logger-inl.h"
+    #include "async_logger-inl.h"
 #endif

include/spdlog/cfg/argv.h

@@ -21,24 +21,20 @@ 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));
 }
 
-} // namespace cfg
+}  // namespace cfg
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/cfg/env.h

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

include/spdlog/cfg/helpers-inl.h

@@ -4,33 +4,32 @@
 #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) {
-    std::transform(
+        return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);
-        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));
@@ -44,16 +43,12 @@ 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);
     }
@@ -62,15 +57,12 @@ 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);
@@ -79,10 +71,8 @@ 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;
     }
 
@@ -91,30 +81,27 @@ 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
+        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), global_level_found ? &global_level : nullptr);
+    details::registry::instance().set_levels(std::move(levels),
+                                             global_level_found ? &global_level : nullptr);
 }
 
-} // namespace helpers
+}  // namespace helpers
-} // namespace cfg
+}  // namespace cfg
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/cfg/helpers.h

@@ -19,11 +19,11 @@ namespace helpers {
 // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
 //
 SPDLOG_API void load_levels(const std::string &txt);
-} // namespace helpers
+}  // namespace helpers
 
-} // namespace cfg
+}  // namespace cfg
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "helpers-inl.h"
+    #include "helpers-inl.h"
-#endif // SPDLOG_HEADER_ONLY
+#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,59 +20,49 @@ 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>(it - std::begin(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;
 }
-} // namespace level
+}  // 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
     memory_buf_t outbuf;
     fmt::format_system_error(outbuf, last_errno, msg.c_str());
     msg_ = fmt::to_string(outbuf);
+#endif
 }
 
-SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT
+SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); }
-{
-    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_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }
-{
-    SPDLOG_THROW(spdlog_ex(std::move(msg)));
-}
 
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/common.h

@@ -3,90 +3,121 @@
 
 #pragma once
 
-#include <spdlog/tweakme.h>
 #include <spdlog/details/null_mutex.h>
+#include <spdlog/tweakme.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>
+
+#ifdef SPDLOG_USE_STD_FORMAT
+    #include <version>
+    #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(_WIN32) && defined(SPDLOG_SHARED_LIB)
+    #if defined(SPDLOG_SHARED_LIB)
-#        ifdef spdlog_EXPORTS
+        #if defined(_WIN32)
-#            define SPDLOG_API __declspec(dllexport)
+            #ifdef spdlog_EXPORTS
-#        else
+                #define SPDLOG_API __declspec(dllexport)
-#            define SPDLOG_API __declspec(dllimport)
+            #else  // !spdlog_EXPORTS
-#        endif
+                #define SPDLOG_API __declspec(dllimport)
-#    else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB)
+            #endif
-#        define SPDLOG_API
+        #else  // !defined(_WIN32)
-#    endif
+            #define SPDLOG_API __attribute__((visibility("default")))
-#    define SPDLOG_INLINE
+        #endif
-#else // !defined(SPDLOG_COMPILED_LIB)
+    #else  // !defined(SPDLOG_SHARED_LIB)
-#    define SPDLOG_API
+        #define SPDLOG_API
-#    define SPDLOG_HEADER_ONLY
+    #endif
-#    define SPDLOG_INLINE inline
+    #define SPDLOG_INLINE
-#endif // #ifdef SPDLOG_COMPILED_LIB
+#else  // !defined(SPDLOG_COMPILED_LIB)
+    #define SPDLOG_API
+    #define SPDLOG_HEADER_ONLY
+    #define SPDLOG_INLINE inline
+#endif  // #ifdef SPDLOG_COMPILED_LIB
 
 #include <spdlog/fmt/fmt.h>
 
-// backward compatibility with fmt versions older than 8
+#if !defined(SPDLOG_USE_STD_FORMAT) && \
-#if FMT_VERSION >= 80000
+    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)
-#    if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
-#        include <spdlog/fmt/xchar.h>
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#    endif
+        #include <spdlog/fmt/xchar.h>
+    #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
 #endif
 
-// visual studio upto 2013 does not support noexcept nor constexpr
+// 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
 #else
-#    define SPDLOG_NOEXCEPT noexcept
+    #define SPDLOG_NOEXCEPT noexcept
-#    define SPDLOG_CONSTEXPR constexpr
+    #define SPDLOG_CONSTEXPR constexpr
+#endif
+
+// If building with std::format, can just use constexpr, otherwise if building with fmt
+// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where
+// a constexpr function in spdlog could end up calling a non-constexpr function in fmt
+// 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()); \
-            printf("spdlog fatal error: %s\n", ex.what());                                                                                 \
+            std::abort();                                  \
-            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 {
@@ -99,44 +130,97 @@ 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;
 using sink_ptr = std::shared_ptr<sinks::sink>;
 using sinks_init_list = std::initializer_list<sink_ptr>;
 using err_handler = std::function<void(const std::string &err_msg)>;
-using string_view_t = fmt::basic_string_view<char>;
+#ifdef SPDLOG_USE_STD_FORMAT
-using wstring_view_t = fmt::basic_string_view<wchar_t>;
+namespace fmt_lib = std;
-using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
-using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
 
-template<class T>
+using string_view_t = std::string_view;
+using memory_buf_t = std::string;
+
+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>
+struct is_convertible_to_basic_format_string
+    : 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)
+using wstring_view_t = std::wstring_view;
+using wmemory_buf_t = std::wstring;
+
+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
+    #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>
+using format_string_t = fmt::format_string<Args...>;
+
+template <class T>
 using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here,
+template <typename Char>
-// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char>
+    #if FMT_VERSION >= 90101
-template<class T, class Char = char>
+using fmt_runtime_string = fmt::runtime_format_string<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_same<remove_cvref_t<T>, fmt::basic_runtime<Char>>::value>
+                             std::is_convertible<T, fmt::basic_string_view<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)
+using wstring_view_t = fmt::basic_string_view<wchar_t>;
+using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
+
+template <typename... Args>
+using wformat_string_t = fmt::wformat_string<Args...>;
+    #endif
+    #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
+#endif      // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
-template<class T>
+template <class T>
-struct is_convertible_to_any_format_string : std::integral_constant<bool, is_convertible_to_basic_format_string<T, char>::value ||
+struct is_convertible_to_any_format_string
-                                                                              is_convertible_to_basic_format_string<T, wchar_t>::value>
+    : std::integral_constant<bool,
-{};
+                             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;
@@ -153,13 +237,12 @@ 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
+enum level_enum : int {
-{
     trace = SPDLOG_LEVEL_TRACE,
     debug = SPDLOG_LEVEL_DEBUG,
     info = SPDLOG_LEVEL_INFO,
@@ -179,52 +262,44 @@ enum level_enum
 #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_WARNING, SPDLOG_LEVEL_NAME_ERROR,  \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO,           \
-                SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF                                                                          \
+                SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
+                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;
 SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
 SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
 
-} // namespace level
+}  // namespace level
 
 //
 // Color mode used by sinks with color support.
 //
-enum class color_mode
+enum class color_mode { always, automatic, never };
-{
-    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
-    local, // log localtime
+    utc     // log utc
-    utc    // log utc
 };
 
 //
 // 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);
@@ -237,40 +312,95 @@ 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
+    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }
-    {
-        return line == 0;
-    }
     const char *filename{nullptr};
     int line{0};
     const char *funcname{nullptr};
 };
 
-namespace details {
+struct file_event_handlers {
-// make_unique support for pre c++14
+    file_event_handlers()
+        : before_open(nullptr),
+          after_open(nullptr),
+          before_close(nullptr),
+          after_close(nullptr) {}
 
-#if __cplusplus >= 201402L // C++14 and beyond
+    std::function<void(const filename_t &filename)> before_open;
+    std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
+    std::function<void(const filename_t &filename, std::FILE *file_stream)> before_close;
+    std::function<void(const filename_t &filename)> after_close;
+};
+
+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<typename T, typename... Args>
+template <bool B, class T = void>
-std::unique_ptr<T> make_unique(Args &&...args)
+using enable_if_t = typename std::enable_if<B, T>::type;
-{
+
+template <typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args &&...args) {
     static_assert(!std::is_array<T>::value, "arrays not supported");
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 #endif
-} // namespace details
+
-} // namespace spdlog
+// 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>
+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>
+constexpr T conditional_static_cast(U value) {
+    return value;
+}
+
+}  // namespace details
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "common-inl.h"
+    #include "common-inl.h"
 #endif

include/spdlog/details/backtracer-inl.h

@@ -4,66 +4,60 @@
 #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
+SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }
-{
-    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});
 }
 
-// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE bool backtracer::empty() const {
-SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
-{
     std::lock_guard<std::mutex> lock{mutex_};
-    while (!messages_.empty())
+    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) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty()) {
         auto &front_msg = messages_.front();
         fun(front_msg);
         messages_.pop_front();
     }
 }
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/backtracer.h

@@ -3,20 +3,19 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg_buffer.h>
 #include <spdlog/details/circular_q.h>
+#include <spdlog/details/log_msg_buffer.h>
 
 #include <atomic>
-#include <mutex>
 #include <functional>
+#include <mutex>
 
 // 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_;
@@ -32,14 +31,15 @@ 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);
 };
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "backtracer-inl.h"
+    #include "backtracer-inl.h"
 #endif

include/spdlog/details/circular_q.h

@@ -4,14 +4,15 @@
 // circular q view of std::vector.
 #pragma once
 
-#include <vector>
 #include <cassert>
+#include <vector>
+
+#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;
@@ -25,35 +26,29 @@ public:
     circular_q() = default;
 
     explicit circular_q(size_t max_items)
-        : max_items_(max_items + 1) // one item is reserved as marker for full q
+        : 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
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); }
-    {
-        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_;
 
-            if (tail_ == head_) // overrun last item if full
+            if (tail_ == head_)  // overrun last item if full
             {
                 head_ = (head_ + 1) % max_items_;
                 ++overrun_counter_;
@@ -63,68 +58,47 @@ public:
 
     // Return reference to the front item.
     // If there are no elements in the container, the behavior is undefined.
-    const T &front() const
+    const T &front() const { return v_[head_]; }
-    {
-        return v_[head_];
-    }
 
-    T &front()
+    T &front() { return v_[head_]; }
-    {
-        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()
+    void pop_front() { head_ = (head_ + 1) % max_items_; }
-    {
-        head_ = (head_ + 1) % max_items_;
-    }
 
-    bool empty() const
+    bool empty() const { return tail_ == head_; }
-    {
-        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
+    size_t overrun_counter() const { return overrun_counter_; }
-    {
+
-        return overrun_counter_;
+    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_;
@@ -137,5 +111,5 @@ private:
         other.overrun_counter_ = 0;
     }
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/console_globals.h

@@ -3,30 +3,26 @@
 
 #pragma once
 
-#include <spdlog/details/null_mutex.h>
 #include <mutex>
+#include <spdlog/details/null_mutex.h>
 
 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;
     }
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

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/details/os.h>
 #include <spdlog/common.h>
+#include <spdlog/details/os.h>
 
 #include <cerrno>
 #include <chrono>
@@ -20,93 +20,101 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE file_helper::~file_helper()
+SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
-{
+    : event_handlers_(event_handlers) {}
-    close();
-}
 
-SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
+SPDLOG_INLINE file_helper::~file_helper() { close(); }
-{
+
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {
     close();
     filename_ = fname;
 
     auto *mode = SPDLOG_FILENAME_T("ab");
     auto *trunc_mode = SPDLOG_FILENAME_T("wb");
 
-    for (int tries = 0; tries < open_tries_; ++tries)
+    if (event_handlers_.before_open) {
-    {
+        event_handlers_.before_open(filename_);
+    }
+    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) {
+                event_handlers_.after_open(filename_, fd_);
+            }
             return;
         }
 
         details::os::sleep_for_millis(open_interval_);
     }
 
-    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing",
+                    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) {
-    std::fflush(fd_);
+        throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
-}
-
-SPDLOG_INLINE void file_helper::close()
-{
-    if (fd_ != nullptr)
-    {
-        std::fclose(fd_);
-        fd_ = nullptr;
     }
 }
 
-SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
+SPDLOG_INLINE void file_helper::sync() {
-{
+    if (!os::fsync(fd_)) {
+        throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+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) {
+            event_handlers_.after_close(filename_);
+        }
+    }
+}
+
+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
+SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; }
-{
-    return filename_;
-}
 
 //
 // return file path and its extension:
@@ -121,21 +129,19 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const
 // ".mylog" => (".mylog". "")
 // "my_folder/.mylog" => ("my_folder/.mylog", "")
 // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
-SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(
-{
+    const filename_t &fname) {
     auto ext_index = fname.rfind('.');
 
     // no valid extension found - return whole path and empty string as
     // extension
-    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    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());
     }
 
@@ -143,5 +149,5 @@ SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension
     return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
 }
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/file_helper.h

@@ -13,10 +13,10 @@ 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:
-    explicit file_helper() = default;
+    file_helper() = default;
+    explicit file_helper(const file_event_handlers &event_handlers);
 
     file_helper(const file_helper &) = delete;
     file_helper &operator=(const file_helper &) = delete;
@@ -25,6 +25,7 @@ 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;
@@ -50,10 +51,11 @@ private:
     const unsigned int open_interval_ = 10;
     std::FILE *fd_{nullptr};
     filename_t filename_;
+    file_event_handlers event_handlers_;
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "file_helper-inl.h"
+    #include "file_helper-inl.h"
 #endif

include/spdlog/details/fmt_helper.h

@@ -3,108 +3,132 @@
 #pragma once
 
 #include <chrono>
-#include <type_traits>
 #include <iterator>
-#include <spdlog/fmt/fmt.h>
 #include <spdlog/common.h>
+#include <spdlog/fmt/fmt.h>
+#include <type_traits>
+
+#ifdef SPDLOG_USE_STD_FORMAT
+    #include <charconv>
+    #include <limits>
+#endif
 
 // Some fmt helpers to efficiently format and pad ints and strings
 namespace spdlog {
 namespace details {
 namespace fmt_helper {
 
-inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {
-{
-    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());
 }
 
-template<typename T>
+#ifdef SPDLOG_USE_STD_FORMAT
-inline void append_int(T n, memory_buf_t &dest)
+template <typename T>
-{
+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()) {
+        dest.append(buf, ptr);
+    } else {
+        throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
+    }
+}
+#else
+template <typename T>
+inline void append_int(T n, memory_buf_t &dest) {
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
-
-template<typename T>
-inline unsigned int count_digits(T n)
-{
-    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
-    return static_cast<unsigned int>(fmt::
-// fmt 7.0.0 renamed the internal namespace to detail.
-// See: https://github.com/fmtlib/fmt/issues/1538
-#if FMT_VERSION < 70000
-            internal
-#else
-            detail
 #endif
-        ::count_digits(static_cast<count_type>(n)));
+
+template <typename T>
+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 (;;) {
+        // 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 < 100) return count + 1;
+        if (n < 1000) return count + 2;
+        if (n < 10000) return count + 3;
+        n /= 10000u;
+        count += 4;
+    }
 }
 
-inline void pad2(int n, memory_buf_t &dest)
+template <typename T>
-{
+inline unsigned int count_digits(T n) {
-    if (n >= 0 && n < 100) // 0-99
+    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.
+    // See: https://github.com/fmtlib/fmt/issues/1538
+    #if FMT_VERSION < 70000
+                                         internal
+    #else
+                                         detail
+    #endif
+                                     ::count_digits(static_cast<count_type>(n)));
+#endif
+}
+
+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::format_to(std::back_inserter(dest), SPDLOG_FMT_RUNTIME("{:02}"), n);
+        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();
@@ -112,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp)
     return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
 }
 
-} // namespace fmt_helper
+}  // namespace fmt_helper
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

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

include/spdlog/details/log_msg.h

@@ -8,10 +8,13 @@
 
 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, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(log_clock::time_point log_time,
+            source_loc loc,
+            string_view_t logger_name,
+            level::level_enum lvl,
+            string_view_t msg);
     log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
     log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
     log_msg(const log_msg &other) = default;
@@ -29,9 +32,9 @@ struct SPDLOG_API log_msg
     source_loc source;
     string_view_t payload;
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // 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,35 +4,33 @@
 #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 : log_msg{other}, buffer{std::move(other.buffer)}
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT
-{
+    : log_msg{other},
+      buffer{std::move(other.buffer)} {
     update_string_views();
 }
 
-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+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());
@@ -40,19 +38,17 @@ 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()};
 }
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/log_msg_buffer.h

@@ -11,8 +11,7 @@ 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();
 
@@ -25,9 +24,9 @@ public:
     log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
 };
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // 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,25 +12,23 @@
 
 #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(); });
@@ -40,8 +38,7 @@ 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));
@@ -49,14 +46,29 @@ public:
         push_cv_.notify_one();
     }
 
-    // try to dequeue item. if no item found. wait upto timeout and try again
+    void enqueue_if_have_room(T &&item) {
-    // Return true, if succeeded dequeue item, false otherwise
+        bool pushed = false;
-    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 (!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) {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
                 return false;
             }
             popped_item = std::move(q_.front());
@@ -66,13 +78,23 @@ 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));
@@ -80,20 +102,32 @@ 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();
     }
 
-    // try to dequeue item. if no item found. wait upto timeout and try again
+    void enqueue_if_have_room(T &&item) {
-    // Return true, if succeeded dequeue item, false otherwise
+        bool pushed = false;
-    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 (!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) {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
             return false;
         }
         popped_item = std::move(q_.front());
@@ -102,25 +136,42 @@ 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 size()
+    size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }
-    {
+
-        std::unique_lock<std::mutex> lock(queue_mutex_);
+    size_t size() {
+        std::lock_guard<std::mutex> lock(queue_mutex_);
         return q_.size();
     }
 
+    void reset_overrun_counter() {
+        std::lock_guard<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 details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/null_mutex.h

@@ -9,41 +9,27 @@
 
 namespace spdlog {
 namespace details {
-struct null_mutex
+struct null_mutex {
-{
     void lock() const {}
     void unlock() const {}
-    bool try_lock() const
-    {
-        return true;
-    }
 };
 
-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
+    int load(std::memory_order = std::memory_order_relaxed) const { return value; }
-    {
-        return value;
-    }
 
-    void store(int new_value, std::memory_order = std::memory_order_relaxed)
+    void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; }
-    {
-        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
+        return new_value;  // return value before the call
     }
 };
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/os-inl.h

@@ -4,86 +4,88 @@
 #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
 
-#    include <io.h>      // _get_osfhandle and _isatty support
+    #ifdef __MINGW32__
-#    include <process.h> //  _get_pid support
+        #include <share.h>
-#    include <spdlog/details/windows_include.h>
+    #endif
 
-#    ifdef __MINGW32__
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
-#        include <share.h>
+        #include <cassert>
-#    endif
+        #include <limits>
+    #endif
 
-#    if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+    #include <direct.h>  // for _mkdir/_wmkdir
-#        include <limits>
-#    endif
 
-#    include <direct.h> // for _mkdir/_wmkdir
+#else  // unix
 
-#else // unix
+    #include <fcntl.h>
+    #include <unistd.h>
 
-#    include <fcntl.h>
+    #ifdef __linux__
-#    include <unistd.h>
+        #include <sys/syscall.h>  //Use gettid() syscall under linux to get thread id
 
-#    ifdef __linux__
+    #elif defined(_AIX)
-#        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+        #include <pthread.h>  // for pthread_getthrds_np
 
-#    elif defined(_AIX)
+    #elif defined(__DragonFly__) || defined(__FreeBSD__)
-#        include <pthread.h> // for pthread_getthreadid_np
+        #include <pthread_np.h>  // for pthread_getthreadid_np
 
-#    elif defined(__DragonFly__) || defined(__FreeBSD__)
+    #elif defined(__NetBSD__)
-#        include <pthread_np.h> // for pthread_getthreadid_np
+        #include <lwp.h>  // for _lwp_self
 
-#    elif defined(__NetBSD__)
+    #elif defined(__sun)
-#        include <lwp.h> // for _lwp_self
+        #include <thread.h>  // for thr_self
+    #endif
 
-#    elif defined(__sun)
+#endif  // unix
-#        include <thread.h> // for thr_self
-#    endif
 
-#endif // unix
+#if defined __APPLE__
+    #include <AvailabilityMacros.h>
+#endif
 
-#ifndef __has_feature          // Clang - feature checking macros.
+#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::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+        std::chrono::duration_cast<typename log_clock::duration>(
+            std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
 
 #else
     return log_clock::now();
 #endif
 }
-SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
-{
-
 #ifdef _WIN32
     std::tm tm;
     ::localtime_s(&tm, &time_tt);
@@ -94,15 +96,12 @@ 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);
@@ -113,55 +112,49 @@ 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
+#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 = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    const int fd =
-    if (fd == -1)
+        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
-    {
+    if (fd == -1) {
-        return false;
+        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
@@ -169,13 +162,11 @@ 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
@@ -184,114 +175,104 @@ 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
-#    ifdef SPDLOG_WCHAR_FILENAMES
+    struct _stat buffer;
-    auto attribs = ::GetFileAttributesW(filename.c_str());
+    #ifdef SPDLOG_WCHAR_FILENAMES
-#    else
+    return (::_wstat(filename.c_str(), &buffer) == 0);
-    auto attribs = ::GetFileAttributesA(filename.c_str());
+    #else
-#    endif
+    return (::_stat(filename.c_str(), &buffer) == 0);
-    return attribs != INVALID_FILE_ATTRIBUTES;
+    #endif
-#else // common linux/unix all have the stat system call
+#else  // common linux/unix all have the stat system call
     struct stat buffer;
     return (::stat(filename.c_str(), &buffer) == 0);
 #endif
 }
 
 #ifdef _MSC_VER
-// avoid warning about unreachable statement at the end of filesize()
+    // 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
+#else  // unix
-// OpenBSD doesn't compile with :: before the fileno(..)
+    // OpenBSD and AIX doesn't compile with :: before the fileno(..)
-#    if defined(__OpenBSD__)
+    #if defined(__OpenBSD__) || defined(_AIX)
     int fd = fileno(f);
-#    else
+    #else
     int fd = ::fileno(f);
-#    endif
+    #endif
-// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
+    // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
-#    if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
+        (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.
+    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)
+    if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);
-        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) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    #if defined(sun) || defined(__sun) || defined(_AIX) || \
+        (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(),
-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+                                             const std::tm &gmtm = details::os::gmtime()) {
-        {
             int local_year = localtm.tm_year + (1900 - 1);
             int gmt_year = gmtm.tm_year + (1900 - 1);
 
@@ -305,7 +286,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
                 ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
 
                 // + difference in years * 365 */
-                + (long int)(local_year - gmt_year) * 365);
+                + static_cast<long int>(local_year - gmt_year) * 365);
 
             long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
             long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
@@ -316,9 +297,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
@@ -327,16 +308,22 @@ 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) || defined(__DragonFly__) || defined(__FreeBSD__)
+#elif defined(_AIX)
+    struct __pthrdsinfo buf;
+    int reg_size = 0;
+    pthread_t pt = pthread_self();
+    int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, &reg_size);
+    int tid = (!retval) ? buf.__pi_tid : 0;
+    return static_cast<size_t>(tid);
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
     return static_cast<size_t>(::pthread_getthreadid_np());
 #elif defined(__NetBSD__)
     return static_cast<size_t>(::_lwp_self());
@@ -346,19 +333,36 @@ 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)
+#else  // Default to standard C++11 (other Unix)
     return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
 #endif
 }
 
 // Return current thread id as size_t (from thread local storage)
-SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
-{
 #if defined(SPDLOG_NO_TLS)
     return _thread_id();
-#else // cache thread id in tls
+#else  // cache thread id in tls
     static thread_local const size_t tid = _thread_id();
     return tid;
 #endif
@@ -366,8 +370,7 @@ 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
@@ -377,54 +380,48 @@ 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 fmt::to_string(buf);
+    return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; }
-{
-    return filename;
-}
 #endif
 
-SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
-{
-
 #ifdef _WIN32
-    return static_cast<int>(::GetCurrentProcessId());
+    return conditional_static_cast<int>(::GetCurrentProcessId());
 #else
-    return static_cast<int>(::getpid());
+    return conditional_static_cast<int>(::getpid());
 #endif
 }
 
 // Determine if the terminal supports colors
 // Based on: https://github.com/agauniyal/rang/
-SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
+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 = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
+        static constexpr std::array<const char *, 16> terms = {
-            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
+            {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys",
+             "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}};
 
         const char *env_term_p = std::getenv("TERM");
-        if (env_term_p == nullptr)
+        if (env_term_p == nullptr) {
-        {
             return false;
         }
 
-        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) {
+            return std::strstr(env_term_p, term) != nullptr;
+        });
     }();
 
     return result;
@@ -433,9 +430,7 @@ 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
@@ -444,86 +439,77 @@ 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) * 2 > result_size)
+    if ((wstr_size + 1) * 4 > result_size) {
-    {
+        result_size =
-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+            ::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, NULL, NULL);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),
+                                            result_size, NULL, NULL);
 
-        if (result_size > 0)
+        if (result_size > 0) {
-        {
             target.resize(result_size);
             return;
         }
     }
 
-    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(
+        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;
     }
 
-    int result_size = static_cast<int>(target.capacity());
+    // find the size to allocate for the result buffer
-    if (str_size + 1 > result_size)
+    int 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);
+        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
-
+                                            result_size);
-        if (result_size > 0)
+        if (result_size > 0) {
-        {
+            assert(result_size == target.size());
-            target.resize(result_size);
             return;
         }
     }
 
-    throw_spdlog_ex(fmt::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(
+        fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
 }
-#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+#endif  // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&
+        // defined(_WIN32)
 
 // return true on success
-static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+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
@@ -531,33 +517,36 @@ 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(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
-            return false; // return error if failed creating dir
         }
         search_offset = token_pos + 1;
     } while (search_offset < path.size());
@@ -570,30 +559,49 @@ SPDLOG_INLINE bool create_dir(filename_t path)
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_INLINE filename_t dir_name(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
+    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
+#else  // revert to getenv
     char *buf = ::getenv(field);
     return buf ? buf : std::string{};
 #endif
 }
 
-} // namespace os
+// Do fsync by FILE handlerpointer
-} // namespace details
+// Return true on success
-} // namespace spdlog
+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,26 +22,27 @@ 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_FILENAME_T(SPDLOG_FOLDER_SEPS);
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] =
+    SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
 
 // fopen_s on non windows for writing
 SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
@@ -99,20 +100,28 @@ SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_API filename_t dir_name(filename_t path);
+SPDLOG_API filename_t dir_name(const filename_t &path);
 
 // Create a dir from the given path.
 // Return true if succeeded or if this dir already exists.
-SPDLOG_API bool create_dir(filename_t path);
+SPDLOG_API bool create_dir(const filename_t &path);
 
 // non thread safe, cross platform getenv/getenv_s
 // return empty string if field not found
 SPDLOG_API std::string getenv(const char *field);
 
-} // namespace os
+// Do fsync by FILE objectpointer.
-} // namespace details
+// Return true on success.
-} // namespace spdlog
+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,38 +4,15 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/periodic_worker.h>
+    #include <spdlog/details/periodic_worker.h>
 #endif
 
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
-{
-    active_ = (interval > std::chrono::seconds::zero());
-    if (!active_)
-    {
-        return;
-    }
-
-    worker_thread_ = std::thread([this, callback_fun, interval]() {
-        for (;;)
-        {
-            std::unique_lock<std::mutex> lock(this->mutex_);
-            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
-            {
-                return; // active_ == false, so exit this thread
-            }
-            callback_fun();
-        }
-    });
-}
-
 // stop the worker thread and join it
-SPDLOG_INLINE periodic_worker::~periodic_worker()
+SPDLOG_INLINE periodic_worker::~periodic_worker() {
-{
+    if (worker_thread_.joinable()) {
-    if (worker_thread_.joinable())
-    {
         {
             std::lock_guard<std::mutex> lock(mutex_);
             active_ = false;
@@ -45,5 +22,5 @@ SPDLOG_INLINE periodic_worker::~periodic_worker()
     }
 }
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/periodic_worker.h

@@ -7,7 +7,8 @@
 //
 // 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 to finish first).
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it
+//    to finish first).
 
 #include <chrono>
 #include <condition_variable>
@@ -17,10 +18,27 @@
 namespace spdlog {
 namespace details {
 
-class SPDLOG_API periodic_worker
+class SPDLOG_API periodic_worker {
-{
 public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
+    template <typename Rep, typename Period>
+    periodic_worker(const std::function<void()> &callback_fun,
+                    std::chrono::duration<Rep, Period> interval) {
+        active_ = (interval > std::chrono::duration<Rep, Period>::zero());
+        if (!active_) {
+            return;
+        }
+
+        worker_thread_ = std::thread([this, callback_fun, interval]() {
+            for (;;) {
+                std::unique_lock<std::mutex> lock(this->mutex_);
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {
+                    return;  // active_ == false, so exit this thread
+                }
+                callback_fun();
+            }
+        });
+    }
+    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
@@ -32,9 +50,9 @@ private:
     std::mutex mutex_;
     std::condition_variable cv_;
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // 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,13 +13,13 @@
 #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
+#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
 
 #include <chrono>
 #include <functional>
@@ -31,39 +31,34 @@ 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));
     loggers_[default_logger_name] = default_logger_;
 
-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
 }
 
 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_);
     }
 
@@ -74,26 +69,22 @@ 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_;
 }
@@ -102,147 +93,110 @@ 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()
+SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }
-{
-    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_);
-    // remove previous default logger from the map
+    if (new_default_logger != nullptr) {
-    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::flush_every(std::chrono::seconds interval)
+SPDLOG_INLINE void registry::set_error_handler(err_handler handler) {
-{
-    std::lock_guard<std::mutex> lock(flusher_mutex_);
-    auto clbk = [this]() { this->flush_all(); };
-    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
-}
-
-SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
-{
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-    {
         l.second->set_error_handler(handler);
     }
     err_handler_ = std::move(handler);
 }
 
-SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+SPDLOG_INLINE void registry::apply_all(
-{
+    const std::function<void(const std::shared_ptr<logger>)> &fun) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    for (auto &l : loggers_)
+    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 (default_logger_ && default_logger_->name() == logger_name)
+    if (is_default_logger) {
-    {
         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();
@@ -256,58 +210,52 @@ SPDLOG_INLINE void registry::shutdown()
     }
 }
 
-SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() { return 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::throw_if_exists_(const std::string &logger_name)
+SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) {
-{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
-    if (loggers_.find(logger_name) != loggers_.end())
+    auto it = log_levels_.find(new_logger->name());
-    {
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+}
+
+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);
 }
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/registry.h

@@ -9,23 +9,22 @@
 // This class is thread safe
 
 #include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
 
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
-#include <mutex>
 
 namespace spdlog {
 class logger;
 
 namespace details {
 class thread_pool;
-class periodic_worker;
 
-class SPDLOG_API registry
+class SPDLOG_API registry {
-{
 public:
     using log_levels = std::unordered_map<std::string, level::level_enum>;
     registry(const registry &) = delete;
@@ -39,11 +38,14 @@ 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 another.
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
+    // another.
     logger *get_default_raw();
 
-    // set default logger.
+    // set default logger and add it to the registry if not registered already.
     // 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);
@@ -61,7 +63,17 @@ public:
 
     void flush_on(level::level_enum log_level);
 
-    void flush_every(std::chrono::seconds interval);
+    template <typename Rep, typename Period>
+    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);
 
@@ -85,6 +97,8 @@ public:
 
     static registry &instance();
 
+    void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
+
 private:
     registry();
     ~registry();
@@ -107,9 +121,9 @@ private:
     size_t backtrace_n_messages_ = 0;
 };
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "registry-inl.h"
+    #include "registry-inl.h"
 #endif

include/spdlog/details/synchronous_factory.h

@@ -10,15 +10,13 @@ namespace spdlog {
 // Default logger factory-  creates synchronous loggers
 class logger;
 
-struct synchronous_factory
+struct synchronous_factory {
-{
+    template <typename Sink, typename... SinkArgs>
-    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
-    {
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
         auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
         details::registry::instance().initialize_logger(new_logger);
         return new_logger;
     }
 };
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/tcp_client-windows.h

@@ -8,12 +8,12 @@
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
-#include <winsock2.h>
-#include <windows.h>
-#include <ws2tcpip.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string>
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
 
 #pragma comment(lib, "Ws2_32.lib")
 #pragma comment(lib, "Mswsock.lib")
@@ -21,94 +21,61 @@
 
 namespace spdlog {
 namespace details {
-class tcp_client
+class tcp_client {
-{
     SOCKET socket_ = INVALID_SOCKET;
 
-    static bool winsock_initialized_()
+    static void init_winsock_() {
-    {
-        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-        if (s == INVALID_SOCKET)
-        {
-            return false;
-        }
-        else
-        {
-            closesocket(s);
-            return true;
-        }
-    }
-
-    static void init_winsock_()
-    {
         WSADATA wsaData;
         auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
-        if (rv != 0)
+        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];
-        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+                         (sizeof(buf) / sizeof(char)), NULL);
 
-        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));
+        throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
     }
 
 public:
-    bool is_connected() const
+    tcp_client() { init_winsock_(); }
-    {
+
-        return socket_ != INVALID_SOCKET;
+    ~tcp_client() {
+        close();
+        ::WSACleanup();
     }
 
-    void close()
+    bool is_connected() const { return socket_ != INVALID_SOCKET; }
-    {
+
+    void close() {
         ::closesocket(socket_);
         socket_ = INVALID_SOCKET;
-        WSACleanup();
     }
 
-    SOCKET fd() const
+    SOCKET fd() const { return socket_; }
-    {
-        return socket_;
-    }
-
-    ~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) {
-    {
+        if (is_connected()) {
-        // initialize winsock if needed
-        if (!winsock_initialized_())
-        {
-            init_winsock_();
-        }
-
-        if (is_connected())
-        {
             close();
         }
-        struct addrinfo hints
+        struct addrinfo hints {};
-        {};
         ZeroMemory(&hints, sizeof(hints));
 
-        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
-        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_socktype = SOCK_STREAM;  // TCP
-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
         int last_error = 0;
-        if (rv != 0)
+        if (rv != 0) {
-        {
             last_error = ::WSAGetLastError();
             WSACleanup();
             throw_winsock_error_("getaddrinfo failed", last_error);
@@ -116,54 +83,47 @@ 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), sizeof(enable_flag));
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
     }
 
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
-    void send(const char *data, size_t n_bytes)
+    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 = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            auto write_result =
-            if (write_result == SOCKET_ERROR)
+                ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
-            {
+            if (write_result == SOCKET_ERROR) {
                 int last_error = ::WSAGetLastError();
                 close();
                 throw_winsock_error_("send failed", last_error);
             }
 
-            if (write_result == 0) // (probably should not happen but in any case..)
+            if (write_result == 0)  // (probably should not happen but in any case..)
             {
                 break;
             }
@@ -171,5 +131,5 @@ public:
         }
     }
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/tcp_client.h

@@ -4,91 +4,73 @@
 #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 <sys/socket.h>
 #include <arpa/inet.h>
-#include <unistd.h>
 #include <netdb.h>
+#include <netinet/in.h>
 #include <netinet/tcp.h>
+#include <sys/socket.h>
+#include <unistd.h>
 
 #include <string>
 
 namespace spdlog {
 namespace details {
-class tcp_client
+class tcp_client {
-{
     int socket_ = -1;
 
 public:
-    bool is_connected() const
+    bool is_connected() const { return socket_ != -1; }
-    {
-        return socket_ != -1;
-    }
 
-    void close()
+    void close() {
-    {
+        if (is_connected()) {
-        if (is_connected())
-        {
             ::close(socket_);
             socket_ = -1;
         }
     }
 
-    int fd() const
+    int fd() const { return socket_; }
-    {
-        return socket_;
-    }
 
-    ~tcp_client()
+    ~tcp_client() { close(); }
-    {
-        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_INET;       // IPv4
+        hints.ai_family = AF_UNSPEC;      // To work with IPv4, IPv6, and so on
-        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_socktype = SOCK_STREAM;  // TCP
-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
-        if (rv != 0)
+        if (rv != 0) {
-        {
+            throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
-            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));
-            throw_spdlog_ex(msg);
         }
 
         // Try each address until we successfully connect(2).
         int last_errno = 0;
-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        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;
@@ -96,45 +78,44 @@ 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), sizeof(enable_flag));
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
 
         // prevent sigpipe on systems where MSG_NOSIGNAL is not available
 #if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag), sizeof(enable_flag));
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char *>(&enable_flag),
+                     sizeof(enable_flag));
 #endif
 
 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-#    error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+    #error "tcp_sink would raise SIGPIPE since neither 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 = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            auto write_result =
-            if (write_result < 0)
+                ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
-            {
+            if (write_result < 0) {
                 close();
                 throw_spdlog_ex("write(2) failed", errno);
             }
 
-            if (write_result == 0) // (probably should not happen but in any case..)
+            if (write_result == 0)  // (probably should not happen but in any case..)
             {
                 break;
             }
@@ -142,5 +123,5 @@ public:
         }
     }
 };
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/details/thread_pool-inl.h

@@ -4,126 +4,124 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/details/thread_pool.h>
+    #include <spdlog/details/thread_pool.h>
 #endif
 
-#include <spdlog/common.h>
 #include <cassert>
+#include <spdlog/common.h>
 
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
-    : q_(q_max_items)
+                                       size_t threads_n,
-{
+                                       std::function<void()> on_thread_start,
-    if (threads_n == 0 || threads_n > 1000)
+                                       std::function<void()> on_thread_stop)
-    {
+    : q_(q_max_items) {
-        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+    if (threads_n == 0 || threads_n > 1000) {
-                        "range is 1-1000)");
+        throw_spdlog_ex(
+            "spdlog::thread_pool(): invalid threads_n param (valid "
+            "range is 1-1000)");
     }
-    for (size_t i = 0; i < threads_n; i++)
+    for (size_t i = 0; i < threads_n; i++) {
-    {
+        threads_.emplace_back([this, on_thread_start, on_thread_stop] {
-        threads_.emplace_back([this, on_thread_start] {
             on_thread_start();
             this->thread_pool::worker_loop_();
+            on_thread_stop();
         });
     }
 }
 
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
+                                       size_t threads_n,
+                                       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, [] {})
+    : thread_pool(
-{}
+          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 {
-    SPDLOG_TRY
+        for (size_t i = 0; i < threads_.size(); i++) {
-    {
-        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, const details::log_msg &msg, async_overflow_policy overflow_policy)
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,
-{
+                                         const details::log_msg &msg,
+                                         async_overflow_policy overflow_policy) {
     async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
     post_async_msg_(std::move(async_m), overflow_policy);
 }
 
-void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr,
-{
+                                           async_overflow_policy overflow_policy) {
     post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
 }
 
-size_t SPDLOG_INLINE thread_pool::overrun_counter()
+size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); }
-{
-    return q_.overrun_counter();
-}
 
-size_t SPDLOG_INLINE thread_pool::queue_size()
+void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); }
-{
-    return q_.size();
-}
 
-void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); }
-{
+
-    if (overflow_policy == async_overflow_policy::block)
+void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); }
-    {
+
+size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); }
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg,
+                                                async_overflow_policy overflow_policy) {
+    if (overflow_policy == async_overflow_policy::block) {
         q_.enqueue(std::move(new_msg));
-    }
+    } else 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;
-    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+    q_.dequeue(incoming_async_msg);
-    if (!dequeued)
-    {
-        return true;
-    }
 
-    switch (incoming_async_msg.msg_type)
+    switch (incoming_async_msg.msg_type) {
-    {
+        case async_msg_type::log: {
-    case async_msg_type::log: {
+            incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
-        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+            return true;
-        return true;
+        }
-    }
+        case async_msg_type::flush: {
-    case async_msg_type::flush: {
+            incoming_async_msg.worker_ptr->backend_flush_();
-        incoming_async_msg.worker_ptr->backend_flush_();
+            return true;
-        return true;
+        }
-    }
 
-    case async_msg_type::terminate: {
+        case async_msg_type::terminate: {
-        return false;
+            return false;
-    }
+        }
 
-    default: {
+        default: {
-        assert(false);
+            assert(false);
-    }
+        }
     }
 
     return true;
 }
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog

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,17 +20,11 @@ namespace details {
 
 using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
 
-enum class async_msg_type
+enum class async_msg_type { log, flush, terminate };
-{
-    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;
 
@@ -43,59 +37,62 @@ 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);
         return *this;
     }
-#else // (_MSC_VER) && _MSC_VER <= 1800
+#else  // (_MSC_VER) && _MSC_VER <= 1800
     async_msg(async_msg &&) = default;
     async_msg &operator=(async_msg &&) = default;
 #endif
 
     // construct from log_msg with given type
     async_msg(async_logger_ptr &&worker, async_msg_type the_type, 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,
+                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);
 
-    // message all threads to terminate gracefully join them
+    // message all threads to terminate gracefully and join them
     ~thread_pool();
 
     thread_pool(const thread_pool &) = delete;
     thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_log(async_logger_ptr &&worker_ptr,
+                  const details::log_msg &msg,
+                  async_overflow_policy overflow_policy);
     void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
     size_t overrun_counter();
+    void reset_overrun_counter();
+    size_t discard_counter();
+    void reset_discard_counter();
     size_t queue_size();
 
 private:
@@ -112,9 +109,9 @@ private:
     bool process_next_msg_();
 };
 
-} // namespace details
+}  // namespace details
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "thread_pool-inl.h"
+    #include "thread_pool-inl.h"
 #endif

include/spdlog/details/udp_client-windows.h

@@ -0,0 +1,98 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over winsock udp client socket.
+// Will throw on construction if socket creation failed.
+
+#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>
+
+#if defined(_MSC_VER)
+    #pragma comment(lib, "Ws2_32.lib")
+    #pragma comment(lib, "Mswsock.lib")
+    #pragma comment(lib, "AdvApi32.lib")
+#endif
+
+namespace spdlog {
+namespace details {
+class udp_client {
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    SOCKET socket_ = INVALID_SOCKET;
+    sockaddr_in addr_ = {};
+
+    static void init_winsock_() {
+        WSADATA wsaData;
+        auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0) {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error) {
+        char buf[512];
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+                         last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,
+                         (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
+    }
+
+    void cleanup_() {
+        if (socket_ != INVALID_SOCKET) {
+            ::closesocket(socket_);
+        }
+        socket_ = INVALID_SOCKET;
+        ::WSACleanup();
+    }
+
+public:
+    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) {
+            int last_error = ::WSAGetLastError();
+            ::WSACleanup();
+            throw_winsock_error_("error: Invalid address!", last_error);
+        }
+
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        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,
+                         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_(); }
+
+    SOCKET fd() const { return socket_; }
+
+    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_,
+                     tolen) == -1) {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+}  // namespace details
+}  // namespace spdlog

include/spdlog/details/udp_client.h

@@ -0,0 +1,81 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over unix udp client socket.
+// Will throw on construction if the socket creation failed.
+
+#ifdef _WIN32
+    #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 <unistd.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+
+class udp_client {
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    int socket_ = -1;
+    struct sockaddr_in sockAddr_;
+
+    void cleanup_() {
+        if (socket_ != -1) {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+public:
+    udp_client(const std::string &host, uint16_t port) {
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        if (socket_ < 0) {
+            throw_spdlog_ex("error: Create Socket Failed!");
+        }
+
+        int option_value = TX_BUFFER_SIZE;
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+                         reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0) {
+            cleanup_();
+            throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
+        }
+
+        sockAddr_.sin_family = AF_INET;
+        sockAddr_.sin_port = htons(port);
+
+        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) {
+            cleanup_();
+            throw_spdlog_ex("error: Invalid address!");
+        }
+
+        ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
+    }
+
+    ~udp_client() { cleanup_(); }
+
+    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) {
+        ssize_t toslen = 0;
+        socklen_t tolen = sizeof(struct sockaddr);
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
+            -1) {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+}  // namespace details
+}  // namespace spdlog

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

@@ -8,9 +8,19 @@
 #include <cctype>
 #include <spdlog/common.h>
 
+#if defined(__has_include)
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if __cpp_lib_span >= 202002L
+    #include <span>
+#endif
+
 //
 // Support for logging binary data as hex
-// format flags, any combination of the followng:
+// format flags, any combination of the following:
 // {:X} - print in uppercase.
 // {:s} - don't separate each byte with space.
 // {:p} - don't print the position on each line start.
@@ -29,93 +39,100 @@
 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) {}
-    {}
 
-    It begin() const
+    // do not use begin() and end() to avoid collision with fmt/ranges
-    {
+    It get_begin() const { return begin_; }
-        return begin_;
+    It get_end() const { return end_; }
-    }
+    size_t size_per_line() const { return size_per_line_; }
-    It end() const
-    {
-        return end_;
-    }
-    size_t size_per_line() const
-    {
-        return size_per_line_;
-    }
 
 private:
     It begin_, end_;
     size_t size_per_line_;
 };
-} // namespace details
+}  // 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, size_t size_per_line = 32)
+inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container,
-{
+                                                                     size_t size_per_line = 32) {
-    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+    static_assert(sizeof(typename Container::value_type) == 1,
+                  "sizeof(Container::value_type) != 1");
     using Iter = typename Container::const_iterator;
     return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
 }
 
+#if __cpp_lib_span >= 202002L
+
+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) {
+    using Container = std::span<Value, Extent>;
+    static_assert(sizeof(typename 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);
+}
+
+#endif
+
 // create dump_info from ranges
-template<typename It>
+template <typename It>
-inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
+inline details::dump_info<It> to_hex(const It range_begin,
-{
+                                     const It range_end,
+                                     size_t size_per_line = 32) {
     return details::dump_info<It>(range_begin, range_end, size_per_line);
 }
 
-} // namespace spdlog
+}  // namespace spdlog
 
-namespace fmt {
+namespace
-
+#ifdef SPDLOG_USE_STD_FORMAT
-template<typename T>
+    std
-struct formatter<spdlog::details::dump_info<T>>
+#else
+    fmt
+#endif
 {
-    const char delimiter = ' ';
+
+template <typename T>
+struct formatter<spdlog::details::dump_info<T>, char> {
+    char delimiter = ' ';
     bool put_newlines = true;
     bool put_delimiters = true;
     bool use_uppercase = false;
-    bool put_positions = true; // position on start of each line
+    bool put_positions = true;  // position on start of each line
     bool show_ascii = false;
 
     // parse the format string flags
-    template<typename ParseContext>
+    template <typename ParseContext>
-    FMT_CONSTEXPR 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;
-            case 'X':
+                    break;
-                use_uppercase = true;
+                case 's':
-                break;
+                    put_delimiters = false;
-            case 's':
+                    break;
-                put_delimiters = false;
+                case 'p':
-                break;
+                    put_positions = false;
-            case 'p':
+                    break;
-                put_positions = false;
+                case 'n':
-                break;
+                    put_newlines = false;
-            case 'n':
+                    show_ascii = false;
-                put_newlines = false;
+                    break;
-                show_ascii = false;
+                case 'a':
-                break;
+                    if (put_newlines) {
-            case 'a':
+                        show_ascii = true;
-                if (put_newlines)
+                    }
-                {
+                    break;
-                    show_ascii = true;
-                }
-                break;
             }
 
             ++it;
@@ -124,39 +141,36 @@ struct formatter<spdlog::details::dump_info<T>>
     }
 
     // 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) -> decltype(ctx.out())
+    auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const
-    {
+        -> decltype(ctx.out()) {
         SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
         SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
         const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
 
-#if FMT_VERSION < 60000
+#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000
         auto inserter = ctx.begin();
 #else
         auto inserter = ctx.out();
 #endif
 
         int size_per_line = static_cast<int>(the_range.size_per_line());
-        auto start_of_line = the_range.begin();
+        auto start_of_line = the_range.get_begin();
-        for (auto i = the_range.begin(); i != the_range.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 && (i == the_range.begin() || i - start_of_line >= size_per_line))
+            if (put_newlines &&
-            {
+                (i == the_range.get_begin() || i - start_of_line >= size_per_line)) {
-                if (show_ascii && i != the_range.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) : '.';
                     }
                 }
 
-                put_newline(inserter, static_cast<size_t>(i - the_range.begin()));
+                put_newline(inserter, static_cast<size_t>(i - the_range.get_begin()));
 
                 // put first byte without delimiter in front of it
                 *inserter++ = hex_chars[(ch >> 4) & 0x0f];
@@ -165,33 +179,28 @@ struct formatter<spdlog::details::dump_info<T>>
                 continue;
             }
 
-            if (put_delimiters)
+            if (put_delimiters && i != the_range.get_begin()) {
-            {
                 *inserter++ = delimiter;
             }
 
             *inserter++ = hex_chars[(ch >> 4) & 0x0f];
             *inserter++ = hex_chars[ch & 0x0f];
         }
-        if (show_ascii) // add ascii to last line
+        if (show_ascii)  // add ascii to last line
         {
-            if (the_range.end() - the_range.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);
-                auto blank_num = size_per_line - (the_range.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.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) : '.';
             }
@@ -200,18 +209,16 @@ struct formatter<spdlog::details::dump_info<T>>
     }
 
     // put newline(and position header)
-    template<typename It>
+    template <typename It>
-    void put_newline(It inserter, std::size_t pos)
+    void put_newline(It inserter, std::size_t pos) const {
-    {
 #ifdef _WIN32
         *inserter++ = '\r';
 #endif
         *inserter++ = '\n';
 
-        if (put_positions)
+        if (put_positions) {
-        {
+            spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
-            fmt::format_to(inserter, "{:04X}: ", pos);
         }
     }
 };
-} // namespace fmt
+}  // namespace std

include/spdlog/fmt/bundled/args.h

@@ -1,4 +1,4 @@
-// Formatting library for C++ - dynamic format arguments
+// Formatting library for C++ - dynamic argument lists
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@@ -8,34 +8,39 @@
 #ifndef FMT_ARGS_H_
 #define FMT_ARGS_H_
 
-#include <functional>  // std::reference_wrapper
+#ifndef FMT_MODULE
-#include <memory>      // std::unique_ptr
+#  include <functional>  // std::reference_wrapper
-#include <vector>
+#  include <memory>      // std::unique_ptr
+#  include <vector>
+#endif
 
-#include "core.h"
+#include "format.h"  // std_string_view
 
 FMT_BEGIN_NAMESPACE
-
 namespace detail {
 
 template <typename T> struct is_reference_wrapper : std::false_type {};
 template <typename T>
 struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-template <typename T> const T& unwrap(const T& v) { return v; }
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
-template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
   return static_cast<const T&>(v);
 }
 
-class dynamic_arg_list {
+// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
-  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+// 2022 (v17.10.0).
-  // templates it doesn't complain about inability to deduce single translation
+//
-  // unit for placing vtable. So storage_node_base is made a fake template.
+// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-  template <typename = void> struct node {
+// templates it doesn't complain about inability to deduce single translation
-    virtual ~node() = default;
+// unit for placing vtable. So node is made a fake template.
-    std::unique_ptr<node<>> next;
+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;
 
@@ -50,7 +55,7 @@ class dynamic_arg_list {
   std::unique_ptr<node<>> head_;
 
  public:
-  template <typename T, typename Arg> const T& push(const Arg& arg) {
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
     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_);
@@ -61,28 +66,18 @@ class dynamic_arg_list {
 }  // namespace detail
 
 /**
-  \rst
+ * A dynamic list of formatting arguments with storage.
-  A dynamic version of `fmt::format_arg_store`.
+ *
-  It's equipped with a storage to potentially temporary objects which lifetimes
+ * It can be implicitly converted into `fmt::basic_format_args` for passing
-  could be shorter than the format arguments object.
+ * into type-erased formatting functions such as `fmt::vformat`.
-
-  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>
+template <typename Context> class dynamic_format_arg_store {
-class dynamic_format_arg_store
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
  private:
   using char_type = typename Context::char_type;
 
   template <typename T> struct need_copy {
     static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, Context>::value;
+        detail::mapped_type_constant<T, char_type>::value;
 
     enum {
       value = !(detail::is_reference_wrapper<T>::value ||
@@ -95,10 +90,10 @@ class dynamic_format_arg_store
   };
 
   template <typename T>
-  using stored_type = conditional_t<detail::is_string<T>::value &&
+  using stored_t = conditional_t<
-                                        !has_formatter<T, Context>::value &&
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
-                                        !detail::is_reference_wrapper<T>::value,
+          !detail::is_reference_wrapper<T>::value,
-                                    std::basic_string<char_type>, T>;
+      std::basic_string<char_type>, T>;
 
   // Storage of basic_format_arg must be contiguous.
   std::vector<basic_format_arg<Context>> data_;
@@ -110,78 +105,72 @@ class dynamic_format_arg_store
 
   friend class basic_format_args<Context>;
 
-  unsigned long long get_types() const {
+  auto data() const -> const basic_format_arg<Context>* {
-    return detail::is_unpacked_bit | data_.size() |
-           (named_info_.empty()
-                ? 0ULL
-                : static_cast<unsigned long long>(detail::has_named_args_bit));
-  }
-
-  const basic_format_arg<Context>* data() const {
     return named_info_.empty() ? data_.data() : data_.data() + 1;
   }
 
   template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(detail::make_arg<Context>(arg));
+    data_.emplace_back(arg);
   }
 
   template <typename T>
   void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty()) {
+    if (named_info_.empty())
-      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
-      data_.insert(data_.begin(), {zero_ptr, 0});
+    data_.emplace_back(detail::unwrap(arg.value));
-    }
-    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
     auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
       data->pop_back();
     };
     std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
         guard{&data_, pop_one};
     named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    data_[0] = {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());
+  }
+
   /**
-    \rst
+   * Adds an argument into the dynamic store for later passing to a formatting
-    Adds an argument into the dynamic store for later passing to a formatting
+   * function.
-    function.
+   *
-
+   * Note that custom types and string types (but not string views) are copied
-    Note that custom types and string types (but not string views) are copied
+   * into the store dynamically allocating memory if necessary.
-    into the store dynamically allocating memory if necessary.
+   *
-
+   * **Example**:
-    **Example**::
+   *
-
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     store.push_back(42);
-      store.push_back(42);
+   *     store.push_back("abc");
-      store.push_back("abc");
+   *     store.push_back(1.5f);
-      store.push_back(1.5f);
+   *     std::string result = fmt::vformat("{} and {} and {}", store);
-      std::string result = fmt::vformat("{} and {} and {}", store);
+   */
-    \endrst
-  */
   template <typename T> void push_back(const T& arg) {
     if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
     else
       emplace_arg(detail::unwrap(arg));
   }
 
   /**
-    \rst
+   * Adds a reference to the argument into the dynamic store for later passing
-    Adds a reference to the argument into the dynamic store for later passing to
+   * to a formatting function.
-    a formatting function.
+   *
-
+   * **Example**:
-    **Example**::
+   *
-
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     char band[] = "Rolling Stones";
-      char band[] = "Rolling Stones";
+   *     store.push_back(std::cref(band));
-      store.push_back(std::cref(band));
+   *     band[9] = 'c'; // Changing str affects the output.
-      band[9] = 'c'; // Changing str affects the output.
+   *     std::string result = fmt::vformat("{}", store);
-      std::string result = fmt::vformat("{}", store);
+   *     // result == "Rolling Scones"
-      // result == "Rolling Scones"
+   */
-    \endrst
-  */
   template <typename T> void push_back(std::reference_wrapper<T> arg) {
     static_assert(
         need_copy<T>::value,
@@ -190,41 +179,40 @@ class dynamic_format_arg_store
   }
 
   /**
-    Adds named argument into the dynamic store for later passing to a formatting
+   * Adds named argument into the dynamic store for later passing to a
-    function. ``std::reference_wrapper`` is supported to avoid copying of the
+   * formatting function. `std::reference_wrapper` is supported to avoid
-    argument. The name is always copied into the store.
+   * copying of the argument. The name is always copied into the store.
-  */
+   */
   template <typename T>
   void push_back(const detail::named_arg<char_type, T>& arg) {
     const char_type* arg_name =
         dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
     if (detail::const_check(need_copy<T>::value)) {
       emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+          fmt::arg(arg_name, dynamic_args_.push<stored_t<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_ = detail::dynamic_arg_list();
+    dynamic_args_ = {};
   }
 
-  /**
+  /// Reserves space to store at least `new_cap` arguments including
-    \rst
+  /// `new_cap_named` named arguments.
-    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

@@ -10,15 +10,8 @@
 
 #include "format.h"
 
-// __declspec(deprecated) is broken in some MSVC versions.
-#if FMT_MSC_VER
-#  define FMT_DEPRECATED_NONMSVC
-#else
-#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
-#endif
-
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
 enum class color : uint32_t {
   alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@@ -185,9 +178,13 @@ enum class terminal_color : uint8_t {
 
 enum class emphasis : uint8_t {
   bold = 1,
-  italic = 1 << 1,
+  faint = 1 << 1,
-  underline = 1 << 2,
+  italic = 1 << 2,
-  strikethrough = 1 << 3
+  underline = 1 << 3,
+  blink = 1 << 4,
+  reverse = 1 << 5,
+  conceal = 1 << 6,
+  strikethrough = 1 << 7,
 };
 
 // rgb is a struct for red, green and blue colors.
@@ -206,21 +203,20 @@ struct rgb {
   uint8_t b;
 };
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
+  FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
-                                                           value{} {
     value.rgb_color = static_cast<uint32_t>(rgb_color);
   }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+  FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
     value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
                       (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
   }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
-                                                                     value{} {
+      : is_rgb(), value{} {
     value.term_color = static_cast<uint8_t>(term_color);
   }
   bool is_rgb;
@@ -229,24 +225,21 @@ struct color_type {
     uint32_t rgb_color;
   } value;
 };
+}  // namespace detail
 
-FMT_END_DETAIL_NAMESPACE
+/// A text style consisting of foreground and background colors and emphasis.
-
-/** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
  public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
-      : set_foreground_color(),
+      : set_foreground_color(), set_background_color(), ems(em) {}
-        set_background_color(),
-        ems(em) {}
 
-  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
       foreground_color = rhs.foreground_color;
     } else if (rhs.set_foreground_color) {
       if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMT_THROW(format_error("can't OR a terminal color"));
+        report_error("can't OR a terminal color");
       foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
     }
 
@@ -255,7 +248,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)
-        FMT_THROW(format_error("can't OR a terminal color"));
+        report_error("can't OR a terminal color");
       background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
     }
 
@@ -264,49 +257,37 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
-                                            const text_style& rhs) {
+      -> text_style {
     return lhs |= rhs;
   }
 
-  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
-      const text_style& rhs) {
-    return and_assign(rhs);
-  }
-
-  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
-  operator&(text_style lhs, const text_style& rhs) {
-    return lhs.and_assign(rhs);
-  }
-
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
     return set_foreground_color;
   }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
     return set_background_color;
   }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
     return static_cast<uint8_t>(ems) != 0;
   }
-  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
     FMT_ASSERT(has_foreground(), "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
     FMT_ASSERT(has_background(), "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
     FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
     return ems;
   }
 
  private:
   FMT_CONSTEXPR text_style(bool is_foreground,
-                           detail::color_type text_color) FMT_NOEXCEPT
+                           detail::color_type text_color) noexcept
-      : set_foreground_color(),
+      : set_foreground_color(), set_background_color(), ems() {
-        set_background_color(),
-        ems() {
     if (is_foreground) {
       foreground_color = text_color;
       set_foreground_color = true;
@@ -316,36 +297,11 @@ class text_style {
     }
   }
 
-  // DEPRECATED!
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
+      -> text_style;
-    if (!set_foreground_color) {
-      set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
-      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
-    }
 
-    if (!set_background_color) {
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
-      set_background_color = rhs.set_background_color;
+      -> text_style;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
-      FMT_NOEXCEPT;
-
-  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
-      FMT_NOEXCEPT;
 
   detail::color_type foreground_color;
   detail::color_type background_color;
@@ -354,26 +310,28 @@ 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 text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline auto 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 text_style bg(detail::color_type background) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
   return text_style(false, background);
 }
 
-FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
+FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
-                                          emphasis rhs) FMT_NOEXCEPT {
+    -> text_style {
   return text_style(lhs) | rhs;
 }
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
+  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
-                                  const char* esc) FMT_NOEXCEPT {
+                                  const char* esc) noexcept {
     // If we have a terminal color, we need to output another escape code
     // sequence.
     if (!text_color.is_rgb) {
@@ -408,17 +366,19 @@ template <typename Char> struct ansi_color_escape {
     to_esc(color.b, buffer + 15, 'm');
     buffer[19] = static_cast<Char>(0);
   }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
-    uint8_t em_codes[4] = {};
+    uint8_t em_codes[num_emphases] = {};
-    uint8_t em_bits = static_cast<uint8_t>(em);
+    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
-    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
+    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
+    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
+    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
-    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
-      em_codes[3] = 9;
+    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
+    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
+    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
 
     size_t index = 0;
-    for (int i = 0; i < 4; ++i) {
+    for (size_t i = 0; i < num_emphases; ++i) {
       if (!em_codes[i]) continue;
       buffer[index++] = static_cast<Char>('\x1b');
       buffer[index++] = static_cast<Char>('[');
@@ -427,201 +387,224 @@ template <typename Char> struct ansi_color_escape {
     }
     buffer[index++] = static_cast<Char>(0);
   }
-  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
 
-  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
-    return buffer + std::char_traits<Char>::length(buffer);
+    return buffer + basic_string_view<Char>(buffer).size();
   }
 
  private:
-  Char buffer[7u + 3u * 4u + 1u];
+  static constexpr size_t num_emphases = 8;
+  Char buffer[7u + 3u * num_emphases + 1u];
 
   static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) FMT_NOEXCEPT {
+                                   char delimiter) noexcept {
     out[0] = static_cast<Char>('0' + c / 100);
     out[1] = static_cast<Char>('0' + c / 10 % 10);
     out[2] = static_cast<Char>('0' + c % 10);
     out[3] = static_cast<Char>(delimiter);
   }
+  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+      -> bool {
+    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+  }
 };
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
-    detail::color_type foreground) FMT_NOEXCEPT {
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
-    detail::color_type background) FMT_NOEXCEPT {
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(em);
 }
 
-template <typename Char>
+template <typename Char> inline void reset_color(buffer<Char>& buffer) {
-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
-}
-
-template <>
-inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
-}
-
-template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
-  fputs("\x1b[0m", stream);
-}
-
-template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
-  fputs(L"\x1b[0m", stream);
-}
-
-template <typename Char>
-inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
   auto reset_color = string_view("\x1b[0m");
   buffer.append(reset_color.begin(), reset_color.end());
 }
 
+template <typename T> struct styled_arg : view {
+  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> format_str,
+                basic_string_view<Char> fmt,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+                basic_format_args<buffered_context<Char>> args) {
   bool has_style = false;
   if (ts.has_emphasis()) {
     has_style = true;
-    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
     buf.append(emphasis.begin(), emphasis.end());
   }
   if (ts.has_foreground()) {
     has_style = true;
-    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    auto foreground = make_foreground_color<Char>(ts.get_foreground());
     buf.append(foreground.begin(), foreground.end());
   }
   if (ts.has_background()) {
     has_style = true;
-    auto background = detail::make_background_color<Char>(ts.get_background());
+    auto background = make_background_color<Char>(ts.get_background());
     buf.append(background.begin(), background.end());
   }
-  detail::vformat_to(buf, format_str, args, {});
+  vformat_to(buf, fmt, args);
-  if (has_style) detail::reset_color<Char>(buf);
+  if (has_style) reset_color<Char>(buf);
 }
+}  // namespace detail
 
-FMT_END_DETAIL_NAMESPACE
+inline void vprint(FILE* f, const text_style& ts, string_view fmt,
-
+                   format_args args) {
-template <typename S, typename Char = char_t<S>>
+  auto buf = memory_buffer();
-void vprint(std::FILE* f, const text_style& ts, const S& format,
+  detail::vformat_to(buf, ts, fmt, args);
-            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
-  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format), args);
-  buf.push_back(Char(0));
-  detail::fputs(buf.data(), f);
 }
 
 /**
-  \rst
+ * Formats a string and prints it to the specified file stream using ANSI
-  Formats a string and prints it to the specified file stream using ANSI
+ * escape sequences to specify text formatting.
-  escape sequences to specify text formatting.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
  */
-template <typename S, typename... Args,
+template <typename... T>
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(FILE* f, const text_style& ts, format_string<T...> fmt,
-void print(std::FILE* f, const text_style& ts, const S& format_str,
+           T&&... args) {
-           const Args&... args) {
+  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
-  vprint(f, ts, format_str,
-         fmt::make_args_checked<Args...>(format_str, args...));
 }
 
 /**
-  \rst
+ * Formats a string and prints it to stdout using ANSI escape sequences to
-  Formats a string and prints it to stdout using ANSI escape sequences to
+ * specify text formatting.
-  specify text formatting.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
-    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
  */
-template <typename S, typename... Args,
+template <typename... T>
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
-void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, fmt, std::forward<T>(args)...);
-  return print(stdout, ts, format_str, args...);
 }
 
-template <typename S, typename Char = char_t<S>>
+inline auto vformat(const text_style& ts, string_view fmt, format_args args)
-inline std::basic_string<Char> vformat(
+    -> std::string {
-    const text_style& ts, const S& format_str,
+  auto buf = memory_buffer();
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  detail::vformat_to(buf, ts, fmt, args);
-  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format_str), args);
   return fmt::to_string(buf);
 }
 
 /**
-  \rst
+ * Formats arguments and returns the result as a string using ANSI escape
-  Formats arguments and returns the result as a string using ANSI
+ * sequences to specify text formatting.
-  escape sequences to specify text formatting.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ * ```
-    #include <fmt/color.h>
+ * #include <fmt/color.h>
-    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+ * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
-                                      "The answer is {}", 42);
+ *                                   "The answer is {}", 42);
-  \endrst
+ * ```
-*/
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
-                                      const Args&... args) {
-  return fmt::vformat(ts, to_string_view(format_str),
-                      fmt::make_args_checked<Args...>(format_str, args...));
-}
-
-/**
-  Formats a string with the given text_style and writes the output to ``out``.
  */
-template <typename OutputIt, typename Char,
+template <typename... T>
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
-OutputIt vformat_to(
+    -> std::string {
-    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
+  return fmt::vformat(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);
+/// Formats a string with the given text_style and writes the output to `out`.
-  return detail::get_iterator(buf);
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
+                format_args args) -> OutputIt {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, ts, fmt, args);
+  return detail::get_iterator(buf, out);
 }
 
 /**
-  \rst
+ * Formats arguments with the given text style, writes the result to the output
-  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.
-  iterator ``out`` and returns the iterator past the end of the output range.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     std::vector<char> out;
-    std::vector<char> out;
+ *     fmt::format_to(std::back_inserter(out),
-    fmt::format_to(std::back_inserter(out),
+ *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
-                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+ */
-  \endrst
+template <typename OutputIt, typename... T,
-*/
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-template <typename OutputIt, typename S, typename... Args,
+inline auto format_to(OutputIt out, const text_style& ts,
-          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
+                      format_string<T...> fmt, T&&... args) -> OutputIt {
-              detail::is_string<S>::value>
+  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
-inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
-                      Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, ts, to_string_view(format_str),
-                    fmt::make_args_checked<Args...>(format_str, args...));
 }
 
-FMT_MODULE_EXPORT_END
+template <typename T, typename Char>
+struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    const auto& ts = arg.style;
+    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);
+    }
+    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);
+    }
+    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 = formatter<T, Char>::format(arg.value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+ * Returns an argument that will be formatted using ANSI escape sequences,
+ * to be used in a formatting function.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Elapsed time: {0:.2f} seconds",
+ *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
+ *                                  fmt::bg(fmt::color::blue)));
+ */
+template <typename T>
+FMT_CONSTEXPR auto styled(const T& value, text_style ts)
+    -> detail::styled_arg<remove_cvref_t<T>> {
+  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
+}
+
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_COLOR_H_

include/spdlog/fmt/bundled/compile.h

@@ -8,178 +8,45 @@
 #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 {
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  size_t count_;
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
-
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
-  };
-
-  counting_iterator() : count_(0) {}
-
-  size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  friend counting_iterator operator+(counting_iterator it, difference_type n) {
-    it.count_ += static_cast<size_t>(n);
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
-template <typename Char, typename InputIt>
-inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                  counting_iterator it) {
-  return it + (end - begin);
-}
-
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  size_t limit_;
-  size_t count_ = 0;
-
-  truncating_iterator_base() : out_(), limit_(0) {}
-
-  truncating_iterator_base(OutputIt out, size_t limit)
-      : out_(out), limit_(limit) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = typename std::iterator_traits<OutputIt>::value_type;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  size_t count() const { return count_; }
-};
-
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
-
- public:
-  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
-
-  truncating_iterator() = default;
-
-  truncating_iterator(OutputIt out, size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
-
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  truncating_iterator() = default;
-
-  truncating_iterator(OutputIt out, size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  template <typename T> truncating_iterator& operator=(T val) {
-    if (this->count_++ < this->limit_) *this->out_++ = val;
-    return *this;
-  }
-
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
 
 // A compile-time string which is compiled into fast formatting code.
-class compiled_string {};
+FMT_EXPORT class compiled_string {};
 
 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};
 
+namespace detail {
+
 /**
-  \rst
+ * Converts a string literal `s` into a format string that will be parsed at
-  Converts a string literal *s* into a format string that will be parsed at
+ * compile time and converted into efficient formatting code. Requires C++17
-  compile time and converted into efficient formatting code. Requires C++17
+ * `constexpr if` compiler support.
-  ``constexpr if`` compiler support.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     // Converts 42 into std::string using the most efficient method and no
-    // Converts 42 into std::string using the most efficient method and no
+ *     // runtime format string processing.
-    // runtime format string processing.
+ *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
-    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
-  \endrst
  */
-#ifdef __cpp_if_constexpr
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) \
+#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
-    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
 #else
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif
 
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
-template <typename Char, size_t N,
-          fmt::detail_exported::fixed_string<Char, N> Str>
-struct udl_compiled_string : compiled_string {
-  using char_type = Char;
-  constexpr operator basic_string_view<char_type>() const {
-    return {Str.data, N - 1};
-  }
-};
-#endif
-
 template <typename T, typename... Tail>
-const T& first(const T& value, const Tail&...) {
+auto first(const T& value, const Tail&...) -> const T& {
   return value;
 }
 
-#ifdef __cpp_if_constexpr
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 template <typename... Args> struct type_list {};
 
 // Returns a reference to the argument at index N from [first, rest...].
@@ -190,7 +57,30 @@ constexpr const auto& get([[maybe_unused]] const T& first,
   if constexpr (N == 0)
     return first;
   else
-    return get<N - 1>(rest...);
+    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>
@@ -202,7 +92,8 @@ constexpr int get_arg_index_by_name(basic_string_view<Char> name,
 template <int N, typename> struct get_type_impl;
 
 template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
-  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+  using type =
+      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
 };
 
 template <int N, typename T>
@@ -235,14 +126,15 @@ template <typename Char> struct code_unit {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&...) const {
-    return write<Char>(out, value);
+    *out++ = value;
+    return out;
   }
 };
 
 // This ensures that the argument type is convertible to `const T&`.
 template <typename T, int N, typename... Args>
 constexpr const T& get_arg_checked(const Args&... args) {
-  const auto& arg = get<N>(args...);
+  const auto& arg = detail::get<N>(args...);
   if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
     return arg.value;
   } else {
@@ -259,7 +151,13 @@ template <typename Char, typename T, int N> struct field {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    return write<Char>(out, get_arg_checked<T, N>(args...));
+    const T& arg = 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);
+    }
   }
 };
 
@@ -289,7 +187,7 @@ template <typename Char> struct runtime_named_field {
   constexpr OutputIt format(OutputIt out, const Args&... args) const {
     bool found = (try_format_argument(out, name, args) || ...);
     if (!found) {
-      throw format_error("argument with specified name is not found");
+      FMT_THROW(format_error("argument with specified name is not found"));
     }
     return out;
   }
@@ -347,13 +245,12 @@ 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 format_str);
+constexpr auto compile_format_string(S fmt);
 
 template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S format_str) {
+constexpr auto parse_tail(T head, S fmt) {
-  if constexpr (POS !=
+  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
-                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
-    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;
@@ -370,48 +267,51 @@ template <typename T, typename Char> struct parse_specs_result {
   int next_arg_id;
 };
 
-constexpr int manual_indexing_id = -1;
+enum { manual_indexing_id = -1 };
 
 template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                   size_t pos, int next_arg_id) {
   str.remove_prefix(pos);
-  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
+  auto ctx =
+      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
   auto f = formatter<T, Char>();
   auto end = f.parse(ctx);
-  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
           next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
 }
 
 template <typename Char> struct arg_id_handler {
+  arg_id_kind kind;
   arg_ref<Char> arg_id;
 
-  constexpr int operator()() {
+  constexpr int on_auto() {
     FMT_ASSERT(false, "handler cannot be used with automatic indexing");
     return 0;
   }
-  constexpr int operator()(int id) {
+  constexpr int on_index(int id) {
+    kind = arg_id_kind::index;
     arg_id = arg_ref<Char>(id);
     return 0;
   }
-  constexpr int operator()(basic_string_view<Char> id) {
+  constexpr int on_name(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) { 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_ref<Char>{}};
+  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
   auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
 }
 
 template <typename T, typename Enable = void> struct field_type {
@@ -425,43 +325,48 @@ 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 format_str) {
+constexpr auto parse_replacement_field_then_tail(S fmt) {
   using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr auto str = basic_string_view<char_type>(fmt);
   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>(),
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
-        format_str);
+  } else if constexpr (c != ':') {
-  } else if constexpr (c == ':') {
+    FMT_THROW(format_error("expected ':'"));
+  } else {
     constexpr auto result = parse_specs<typename field_type<T>::type>(
         str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
-    return parse_tail<Args, result.end, result.next_arg_id>(
+    if constexpr (result.end >= str.size() || str[result.end] != '}') {
-        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+      FMT_THROW(format_error("expected '}'"));
-            result.fmt},
+      return 0;
-        format_str);
+    } else {
+      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);
+    }
   }
 }
 
 // Compiles a non-empty format string and returns the compiled representation
 // or unknown_format() on unrecognized input.
 template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S format_str) {
+constexpr auto compile_format_string(S fmt) {
   using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr auto str = basic_string_view<char_type>(fmt);
   if constexpr (str[POS] == '{') {
     if constexpr (POS + 1 == str.size())
-      throw format_error("unmatched '{' in format string");
+      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), format_str);
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
     } 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>(
+                                               POS + 1, ID, next_id>(fmt);
-          format_str);
     } else {
       constexpr auto arg_id_result =
           parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
@@ -469,70 +374,64 @@ constexpr auto compile_format_string(S format_str) {
       constexpr char_type c =
           arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
       static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+      if constexpr (arg_id_result.kind == arg_id_kind::index) {
         static_assert(
             ID == manual_indexing_id || ID == 0,
             "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        constexpr auto arg_index = arg_id_result.arg_id.index;
         return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                  Args, arg_id_end_pos,
                                                  arg_index, manual_indexing_id>(
-            format_str);
+            fmt);
-      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
         constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
-        if constexpr (arg_index != invalid_arg_index) {
+        if constexpr (arg_index >= 0) {
           constexpr auto next_id =
               ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
           return parse_replacement_field_then_tail<
               decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(format_str);
+              arg_index, next_id>(fmt);
-        } else {
+        } else if constexpr (c == '}') {
-          if constexpr (c == '}') {
+          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-            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},
+        } else if constexpr (c == ':') {
-                format_str);
+          return unknown_format();  // no type info for specs parsing
-          } else if constexpr (c == ':') {
-            return unknown_format();  // no type info for specs parsing
-          }
         }
       }
     }
   } else if constexpr (str[POS] == '}') {
     if constexpr (POS + 1 == str.size())
-      throw format_error("unmatched '}' in format string");
+      FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
   } 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),
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
-                                       format_str);
     } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
-                                       format_str);
     }
   }
 }
 
 template <typename... Args, typename S,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-constexpr auto compile(S format_str) {
+constexpr auto compile(S fmt) {
-  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
   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>(
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
-            format_str);
     return result;
   }
 }
-#endif  // __cpp_if_constexpr
+#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
 
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
-#ifdef __cpp_if_constexpr
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 
 template <typename CompiledFormat, typename... Args,
           typename Char = typename CompiledFormat::char_type,
@@ -552,7 +451,7 @@ constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(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) {
@@ -570,70 +469,71 @@ FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
   constexpr auto compiled = detail::compile<Args...>(S());
   if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                              detail::unknown_format>()) {
-    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
+    return fmt::format(
-                  std::forward<Args>(args)...);
+        static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
   } else {
-    return format(compiled, std::forward<Args>(args)...);
+    return fmt::format(compiled, std::forward<Args>(args)...);
   }
 }
 
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
 FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
   constexpr auto compiled = detail::compile<Args...>(S());
   if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                              detail::unknown_format>()) {
-    return format_to(out,
+    return fmt::format_to(
-                     static_cast<basic_string_view<typename S::char_type>>(S()),
+        out, static_cast<basic_string_view<typename S::char_type>>(S()),
-                     std::forward<Args>(args)...);
+        std::forward<Args>(args)...);
   } else {
-    return format_to(out, compiled, std::forward<Args>(args)...);
+    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
   }
 }
 #endif
 
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
-                                         const S& format_str, Args&&... args) {
+    -> format_to_n_result<OutputIt> {
-  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
+  using traits = detail::fixed_buffer_traits;
-                      std::forward<Args>(args)...);
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  return {it.base(), it.count()};
+  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
+  return {buf.out(), buf.count()};
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-size_t formatted_size(const S& format_str, const Args&... args) {
+FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
-  return format_to(detail::counting_iterator(), format_str, args...).count();
+    -> size_t {
+  auto buf = detail::counting_buffer<>();
+  fmt::format_to(appender(buf), fmt, args...);
+  return buf.count();
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& format_str, const Args&... args) {
+void print(std::FILE* f, const S& fmt, const Args&... args) {
-  memory_buffer buffer;
+  auto buf = memory_buffer();
-  format_to(std::back_inserter(buffer), format_str, args...);
+  fmt::format_to(appender(buf), fmt, args...);
-  detail::print(f, {buffer.data(), buffer.size()});
+  detail::print(f, {buf.data(), buf.size()});
 }
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-void print(const S& format_str, const Args&... args) {
+void print(const S& fmt, const Args&... args) {
-  print(stdout, format_str, args...);
+  print(stdout, fmt, args...);
 }
 
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail_exported::fixed_string Str>
+template <detail::fixed_string Str> constexpr auto operator""_cf() {
-constexpr detail::udl_compiled_string<
+  return FMT_COMPILE(Str.data);
-    remove_cvref_t<decltype(Str.data[0])>,
-    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
-operator""_cf() {
-  return {};
 }
 }  // namespace literals
 #endif
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_COMPILE_H_

include/spdlog/fmt/bundled/fmt.license.rst

@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.

include/spdlog/fmt/bundled/locale.h

@@ -1,2 +0,0 @@
-#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,30 +8,33 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_
 
-#include <cerrno>
-#include <clocale>  // locale_t
-#include <cstddef>
-#include <cstdio>
-#include <cstdlib>       // strtod_l
-#include <system_error>  // std::system_error
-
-#if defined __APPLE__ || defined(__FreeBSD__)
-#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
-#endif
-
 #include "format.h"
 
+#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")
+#  if FMT_HAS_INCLUDE("winapifamily.h")
-#  include <winapifamily.h>
+#    include <winapifamily.h>
-#endif
+#  endif
-#if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
+#  if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
-     defined(__linux__)) &&                              \
+       defined(__linux__)) &&                              \
-    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+      (!defined(WINAPI_FAMILY) ||                          \
-#  include <fcntl.h>  // for O_RDONLY
+       (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
-#  define FMT_USE_FCNTL 1
+#    include <fcntl.h>  // for O_RDONLY
-#else
+#    define FMT_USE_FCNTL 1
-#  define FMT_USE_FCNTL 0
+#  else
+#    define FMT_USE_FCNTL 0
+#  endif
 #endif
 
 #ifndef FMT_POSIX
@@ -45,6 +48,7 @@
 
 // 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
@@ -70,144 +74,89 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
 /**
-  \rst
+ * A reference to a null-terminated string. It can be constructed from a C
-  A reference to a null-terminated string. It can be constructed from a C
+ * string or `std::string`.
-  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.
-  const Char* c_str() const { return data_; }
+  auto c_str() const -> const Char* { return data_; }
 };
 
 using cstring_view = basic_cstring_view<char>;
 using wcstring_view = basic_cstring_view<wchar_t>;
 
-template <typename Char> struct formatter<std::error_code, Char> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write_bytes(out, ec.category().name(),
-                              basic_format_specs<Char>());
-    out = detail::write<Char>(out, Char(':'));
-    out = detail::write<Char>(out, ec.value());
-    return out;
-  }
-};
-
 #ifdef _WIN32
-FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+FMT_API const std::error_category& system_category() noexcept;
-
-FMT_BEGIN_DETAIL_NAMESPACE
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class utf16_to_utf8 {
- private:
-  memory_buffer buffer_;
-
- public:
-  utf16_to_utf8() {}
-  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
-  operator string_view() const { return string_view(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const char* c_str() const { return &buffer_[0]; }
-  std::string str() const { return std::string(&buffer_[0], size()); }
-
-  // Performs conversion returning a system error code instead of
-  // throwing exception on conversion error. This method may still throw
-  // in case of memory allocation error.
-  FMT_API int convert(basic_string_view<wchar_t> s);
-};
 
+namespace detail {
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
-                                  const char* message) FMT_NOEXCEPT;
+                                  const char* message) noexcept;
-FMT_END_DETAIL_NAMESPACE
+}
 
-FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
                                          format_args args);
 
 /**
- \rst
+ * Constructs a `std::system_error` object with the description of the form
- Constructs a :class:`std::system_error` object with the description
+ *
- of the form
+ *     <message>: <system-message>
-
+ *
- .. parsed-literal::
+ * where `<message>` is the formatted message and `<system-message>` is the
-   *<message>*: *<system-message>*
+ * system message corresponding to the error code.
-
+ * `error_code` is a Windows error code as given by `GetLastError`.
- where *<message>* is the formatted message and *<system-message>* is the
+ * If `error_code` is not a valid error code such as -1, the system message
- system message corresponding to the error code.
+ * will look like "error -1".
- *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
+ * **Example**:
- will look like "error -1".
+ *
-
+ *     // This throws a system_error with the description
- **Example**::
+ *     //   cannot open file 'madeup': The system cannot find the file
-
+ * specified.
-   // This throws a system_error with the description
+ *     // or similar (system message may vary).
-   //   cannot open file 'madeup': The system cannot find the file specified.
+ *     const char *filename = "madeup";
-   // or similar (system message may vary).
+ *     LPOFSTRUCT of = LPOFSTRUCT();
-   const char *filename = "madeup";
+ *     HFILE file = OpenFile(filename, &of, OF_READ);
-   LPOFSTRUCT of = LPOFSTRUCT();
+ *     if (file == HFILE_ERROR) {
-   HFILE file = OpenFile(filename, &of, OF_READ);
+ *       throw fmt::windows_error(GetLastError(),
-   if (file == HFILE_ERROR) {
+ *                                "cannot open file '{}'", filename);
-     throw fmt::windows_error(GetLastError(),
+ *     }
-                              "cannot open file '{}'", filename);
+ */
-   }
+template <typename... T>
- \endrst
+auto windows_error(int error_code, string_view message, const T&... args)
-*/
+    -> std::system_error {
-template <typename... Args>
+  return vwindows_error(error_code, message, vargs<T...>{{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,
+FMT_API void report_windows_error(int error_code, const char* message) noexcept;
-                                  const char* message) FMT_NOEXCEPT;
 #else
-inline const std::error_category& system_category() FMT_NOEXCEPT {
+inline auto system_category() noexcept -> const std::error_category& {
   return std::system_category();
 }
 #endif  // _WIN32
@@ -215,8 +164,8 @@ inline const std::error_category& system_category() FMT_NOEXCEPT {
 // std::system is not available on some platforms such as iOS (#2248).
 #ifdef __OSX__
 template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& format_str, Args&&... args) {
+void say(const S& fmt, Args&&... args) {
-  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
 }
 #endif
 
@@ -227,24 +176,24 @@ class buffered_file {
 
   friend class file;
 
-  explicit buffered_file(FILE* f) : file_(f) {}
+  inline explicit buffered_file(FILE* f) : file_(f) {}
 
  public:
   buffered_file(const buffered_file&) = delete;
   void operator=(const buffered_file&) = delete;
 
   // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+  inline buffered_file() noexcept : file_(nullptr) {}
 
   // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() FMT_NOEXCEPT;
+  FMT_API ~buffered_file() noexcept;
 
  public:
-  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
     other.file_ = nullptr;
   }
 
-  buffered_file& operator=(buffered_file&& other) {
+  inline auto operator=(buffered_file&& other) -> buffered_file& {
     close();
     file_ = other.file_;
     other.file_ = nullptr;
@@ -258,36 +207,35 @@ class buffered_file {
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-  FILE* get() const FMT_NOEXCEPT { return file_; }
+  inline auto get() const noexcept -> FILE* { return file_; }
 
-  // We place parentheses around fileno to workaround a bug in some versions
+  FMT_API auto descriptor() const -> int;
-  // of MinGW that define fileno as a macro.
-  FMT_API int(fileno)() const;
 
-  void vprint(string_view format_str, format_args args) {
+  template <typename... T>
-    fmt::vprint(file_, format_str, args);
+  inline void print(string_view fmt, const T&... args) {
-  }
+    fmt::vargs<T...> vargs = {{args...}};
-
+    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
-  template <typename... Args>
+                               : fmt::vprint(file_, fmt, vargs);
-  inline void print(string_view format_str, const Args&... args) {
-    vprint(format_str, fmt::make_format_args(args...));
   }
 };
 
 #if FMT_USE_FCNTL
+
 // A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
+// Methods that are not declared with noexcept may throw
 // fmt::system_error in case of failure. Note that some errors such as
 // closing the file multiple times will cause a crash on Windows rather
 // than an exception. You can get standard behavior by overriding the
 // invalid parameter handler with _set_invalid_parameter_handler.
-class file {
+class FMT_API file {
  private:
   int fd_;  // File descriptor.
 
   // 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 {
@@ -300,19 +248,19 @@ class file {
   };
 
   // Constructs a file object which doesn't represent any file.
-  file() FMT_NOEXCEPT : fd_(-1) {}
+  inline file() noexcept : fd_(-1) {}
 
   // Opens a file and constructs a file object representing this file.
-  FMT_API file(cstring_view path, int oflag);
+  file(cstring_view path, int oflag);
 
  public:
   file(const file&) = delete;
   void operator=(const file&) = delete;
 
-  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
 
   // Move assignment is not noexcept because close may throw.
-  file& operator=(file&& other) {
+  inline auto operator=(file&& other) -> file& {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -320,54 +268,65 @@ class file {
   }
 
   // Destroys the object closing the file it represents if any.
-  FMT_API ~file() FMT_NOEXCEPT;
+  ~file() noexcept;
 
   // Returns the file descriptor.
-  int descriptor() const FMT_NOEXCEPT { return fd_; }
+  inline auto descriptor() const noexcept -> int { return fd_; }
 
   // Closes the file.
-  FMT_API void close();
+  void close();
 
   // Returns the file size. The size has signed type for consistency with
   // stat::st_size.
-  FMT_API long long size() const;
+  auto size() const -> long long;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API size_t read(void* buffer, size_t count);
+  auto read(void* buffer, size_t count) -> size_t;
 
   // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API size_t write(const void* buffer, size_t count);
+  auto write(const void* buffer, size_t count) -> size_t;
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.
-  FMT_API static file dup(int fd);
+  static auto dup(int fd) -> file;
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd);
+  void dup2(int fd);
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
+  void dup2(int fd, std::error_code& ec) noexcept;
-
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  FMT_API static void pipe(file& read_end, file& write_end);
 
   // Creates a buffered_file object associated with this file and detaches
   // this file object from the file.
-  FMT_API buffered_file fdopen(const char* mode);
+  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();
 };
 
 // Returns the memory page size.
-long getpagesize();
+auto getpagesize() -> long;
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 struct buffer_size {
-  buffer_size() = default;
+  constexpr buffer_size() = default;
   size_t value = 0;
-  buffer_size operator=(size_t val) const {
+  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
     auto bs = buffer_size();
     bs.value = val;
     return bs;
@@ -378,7 +337,7 @@ struct ostream_params {
   int oflag = file::WRONLY | file::CREATE | file::TRUNC;
   size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
 
-  ostream_params() {}
+  constexpr ostream_params() {}
 
   template <typename... T>
   ostream_params(T... params, int new_oflag) : ostream_params(params...) {
@@ -390,126 +349,79 @@ struct ostream_params {
       : ostream_params(params...) {
     this->buffer_size = bs.value;
   }
+
+// Intel has a bug that results in failure to deduce a constructor
+// for empty parameter packs.
+#  if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
+  ostream_params(int new_oflag) : oflag(new_oflag) {}
+  ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
+#  endif
 };
 
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 
-constexpr detail::buffer_size buffer_size;
+FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
 
-/** A fast output stream which is not thread-safe. */
+/// A fast buffered output stream for writing from a single thread. Writing from
-class FMT_API ostream final : private detail::buffer<char> {
+/// multiple threads without external synchronization may result in a data race.
+class FMT_API ostream : private detail::buffer<char> {
  private:
   file file_;
 
-  void flush() {
+  ostream(cstring_view path, const detail::ostream_params& params);
+
+  static void grow(buffer<char>& buf, size_t);
+
+ public:
+  ostream(ostream&& other) noexcept;
+  ~ostream();
+
+  operator writer() {
+    detail::buffer<char>& buf = *this;
+    return buf;
+  }
+
+  inline void flush() {
     if (size() == 0) return;
-    file_.write(data(), size());
+    file_.write(data(), size() * sizeof(data()[0]));
     clear();
   }
 
-  void grow(size_t) override;
-
-  ostream(cstring_view path, const detail::ostream_params& params)
-      : file_(path, params.oflag) {
-    set(new char[params.buffer_size], params.buffer_size);
-  }
-
- public:
-  ostream(ostream&& other)
-      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
-        file_(std::move(other.file_)) {
-    other.clear();
-    other.set(nullptr, 0);
-  }
-  ~ostream() {
-    flush();
-    delete[] data();
-  }
-
   template <typename... T>
-  friend ostream output_file(cstring_view path, T... params);
+  friend auto output_file(cstring_view path, T... params) -> ostream;
 
-  void close() {
+  inline void close() {
     flush();
     file_.close();
   }
 
-  /**
+  /// Formats `args` according to specifications in `fmt` and writes the
-    Formats ``args`` according to specifications in ``fmt`` and writes the
+  /// output to the file.
-    output to the file.
-   */
   template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(detail::buffer_appender<char>(*this), fmt,
+    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
-               fmt::make_format_args(args...));
   }
 };
 
 /**
-  \rst
+ * Opens a file for writing. Supported parameters passed in `params`:
-  Opens a file for writing. Supported parameters passed in *params*:
+ *
-
+ * - `<integer>`: Flags passed to [open](
-  * ``<integer>``: Flags passed to `open
+ *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
-    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+ *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
-    (``file::WRONLY | file::CREATE`` by default)
+ * - `buffer_size=<integer>`: Output buffer size
-  * ``buffer_size=<integer>``: Output buffer size
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     auto out = fmt::output_file("guide.txt");
-    auto out = fmt::output_file("guide.txt");
+ *     out.print("Don't {}", "Panic");
-    out.print("Don't {}", "Panic");
-  \endrst
  */
 template <typename... T>
-inline ostream output_file(cstring_view path, T... params) {
+inline auto output_file(cstring_view path, T... params) -> ostream {
   return {path, detail::ostream_params(params...)};
 }
 #endif  // FMT_USE_FCNTL
 
-#ifdef FMT_LOCALE
+FMT_END_EXPORT
-// A "C" numeric locale.
-class locale {
- private:
-#  ifdef _WIN32
-  using locale_t = _locale_t;
-
-  static void freelocale(locale_t loc) { _free_locale(loc); }
-
-  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
-    return _strtod_l(nptr, endptr, loc);
-  }
-#  endif
-
-  locale_t locale_;
-
- public:
-  using type = locale_t;
-  locale(const locale&) = delete;
-  void operator=(const locale&) = delete;
-
-  locale() {
-#  ifndef _WIN32
-    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
-#  else
-    locale_ = _create_locale(LC_NUMERIC, "C");
-#  endif
-    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
-  }
-  ~locale() { freelocale(locale_); }
-
-  type get() const { return locale_; }
-
-  // Converts string to floating-point number and advances str past the end
-  // of the parsed input.
-  double strtod(const char*& str) const {
-    char* end = nullptr;
-    double result = strtod_l(str, &end, locale_);
-    str = end;
-    return result;
-  }
-};
-using Locale FMT_DEPRECATED_ALIAS = locale;
-#endif  // FMT_LOCALE
-FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_OS_H_

include/spdlog/fmt/bundled/ostream.h

@@ -8,93 +8,53 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include <ostream>
+#ifndef FMT_MODULE
+#  include <fstream>  // std::filebuf
+#endif
 
-#include "format.h"
+#ifdef _WIN32
+#  ifdef __GLIBCXX__
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  include <io.h>
+#endif
+
+#include "chrono.h"  // formatbuf
+
+#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 Char> class basic_printf_parse_context;
-template <typename OutputIt, typename Char> class basic_printf_context;
-
 namespace detail {
 
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
+// Generate a unique explicit instantion in every translation unit using a tag
- private:
+// type in an anonymous namespace.
-  using int_type = typename std::basic_streambuf<Char>::int_type;
+namespace {
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
+struct file_access_tag {};
-
+}  // namespace
-  buffer<Char>& buffer_;
+template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
-
+class file_access {
- public:
+  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
-
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
 };
 
-struct converter {
+#if FMT_MSVC_STL_UPDATE
-  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> converter(T);
+template class file_access<file_access_tag, std::filebuf,
-};
+                           &std::filebuf::_Myfile>;
-
+auto get_file(std::filebuf&) -> FILE*;
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
+#endif
- private:
-  void_t<> operator<<(converter);
-};
-
-// Hide insertion operators for built-in types.
-template <typename Char, typename Traits>
-void_t<> operator<<(std::basic_ostream<Char, Traits>&, Char);
-template <typename Char, typename Traits>
-void_t<> operator<<(std::basic_ostream<Char, Traits>&, char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, signed char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, unsigned char);
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
- private:
-  template <typename U>
-  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
-                                              << std::declval<U>()),
-                                     void_t<>>::value>
-  test(int);
-
-  template <typename> static std::false_type test(...);
-
-  using result = decltype(test<T>(0));
-
- public:
-  is_streamable() = default;
-
-  static const bool value = result::value;
-};
 
 // 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 = std::make_unsigned<std::streamsize>::type;
+  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
   unsigned_streamsize size = buf.size();
   unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
   do {
@@ -105,77 +65,102 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
   } while (size != 0);
 }
 
-template <typename Char, typename T>
+template <typename T> struct streamed_view {
-void format_value(buffer<Char>& buf, const T& value,
+  const T& value;
-                  locale_ref loc = locale_ref()) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-  if (loc) output.imbue(loc.get<std::locale>());
-#endif
-  output << value;
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  buf.try_resize(buf.size());
-}
-
-// 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>>
-    : private formatter<basic_string_view<Char>, Char> {
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    return formatter<basic_string_view<Char>, Char>::parse(ctx);
-  }
-  template <typename ParseCtx,
-            FMT_ENABLE_IF(std::is_same<
-                          ParseCtx, basic_printf_parse_context<Char>>::value)>
-  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename OutputIt>
-  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
-      -> OutputIt {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value, ctx.locale());
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-  }
-  template <typename OutputIt>
-  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
-      -> OutputIt {
-    basic_memory_buffer<Char> buffer;
-    format_value(buffer, value, ctx.locale());
-    return std::copy(buffer.begin(), buffer.end(), ctx.out());
-  }
 };
 }  // namespace detail
 
-FMT_MODULE_EXPORT
+// Formats an object of type T that has an overloaded ostream operator<<.
 template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
-            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  void set_debug_format() = delete;
-  basic_memory_buffer<Char> buffer;
+
-  detail::vformat_to(buffer, format_str, args);
+  template <typename T, typename Context>
+  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
+    auto buffer = basic_memory_buffer<Char>();
+    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
+    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);
+  }
+};
+
+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>
+  auto format(detail::streamed_view<T> view, Context& ctx) const
+      -> decltype(ctx.out()) {
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
+  }
+};
+
+/**
+ * Returns a view that formats `value` via an ostream `operator<<`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Current thread id: {}\n",
+ *                fmt::streamed(std::this_thread::get_id()));
+ */
+template <typename T>
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+inline void vprint(std::ostream& os, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  FILE* f = nullptr;
+#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    f = detail::get_file(*buf);
+#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
+  auto* rdbuf = os.rdbuf();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    f = fbuf->file();
+#endif
+#ifdef _WIN32
+  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);
 }
 
 /**
-  \rst
+ * Prints formatted data to the stream `os`.
-  Prints formatted data to the stream *os*.
+ *
-
+ * **Example**:
-  **Example**::
+ *
-
+ *     fmt::print(cerr, "Don't {}!", "panic");
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
  */
-FMT_MODULE_EXPORT
+FMT_EXPORT template <typename... T>
-template <typename S, typename... Args,
+void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+  fmt::vargs<T...> vargs = {{args...}};
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+  if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
-  vprint(os, to_string_view(format_str),
+  auto buffer = memory_buffer();
-         fmt::make_args_checked<Args...>(format_str, args...));
+  detail::vformat_to(buffer, fmt.str, vargs);
+  detail::write_buffer(os, buffer);
 }
+
+FMT_EXPORT template <typename... T>
+void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
 FMT_END_NAMESPACE
 
 #endif  // FMT_OSTREAM_H_

include/spdlog/fmt/bundled/printf.h

@@ -8,108 +8,121 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm>  // std::max
+#ifndef FMT_MODULE
-#include <limits>     // std::numeric_limits
+#  include <algorithm>  // std::max
-#include <ostream>
+#  include <limits>     // std::numeric_limits
+#endif
 
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
-template <typename T> struct printf_formatter { printf_formatter() = delete; };
+template <typename T> struct printf_formatter {
-
+  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 OutputIt, typename Char> class basic_printf_context {
+template <typename Char> class basic_printf_context {
  private:
-  OutputIt out_;
+  basic_appender<Char> 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 format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = parse_context<Char>;
-  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
-    \rst
+  /// stored in the context object so make sure they have appropriate lifetimes.
-    Constructs a ``printf_context`` object. References to the arguments are
+  basic_printf_context(basic_appender<Char> out,
-    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) {}
 
-  OutputIt out() { return out_; }
+  auto out() -> basic_appender<Char> { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
+  void advance_to(basic_appender<Char>) {}
 
-  detail::locale_ref locale() { return {}; }
+  auto locale() -> detail::locale_ref { return {}; }
 
-  format_arg arg(int id) const { return args_.get(id); }
+  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
-
+    return args_.get(id);
-  FMT_CONSTEXPR void on_error(const char* message) {
-    detail::error_handler().on_error(message);
   }
 };
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
+
+// 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 bool fits_in_int(T value) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = max_value<int>();
+    unsigned max = to_unsigned(max_value<int>());
     return value <= max;
   }
-  static bool fits_in_int(bool) { return true; }
+  inline static auto fits_in_int(bool) -> bool { return true; }
 };
 
 template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
     return value >= (std::numeric_limits<int>::min)() &&
            value <= max_value<int>();
   }
-  static bool fits_in_int(int) { return true; }
+  inline static auto fits_in_int(int) -> bool { return true; }
 };
 
-class printf_precision_handler {
+struct printf_precision_handler {
- public:
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
+  auto operator()(T value) -> int {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
+      report_error("number is too big");
     return (std::max)(static_cast<int>(value), 0);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
+  auto operator()(T) -> int {
-    FMT_THROW(format_error("precision is not integer"));
+    report_error("precision is not integer");
     return 0;
   }
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
+struct is_zero_int {
- public:
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
+  auto operator()(T value) -> bool {
     return value == 0;
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
+  auto operator()(T) -> bool {
     return false;
   }
 };
 
 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
 
-template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+template <> struct make_unsigned_or_bool<bool> {
+  using type = bool;
+};
 
 template <typename T, typename Context> class arg_converter {
  private:
@@ -132,24 +145,19 @@ 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.
-      if (is_signed) {
+      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = detail::make_arg<Context>(
+      if (is_signed)
-            static_cast<int>(static_cast<target_type>(value)));
+        arg_ = static_cast<int>(static_cast<target_type>(value));
-      } else {
+      else
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
-        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:
-        // glibc's printf doesn't sign extend arguments of smaller types:
+      //   std::printf("%lld", -42);  // prints "4294967254"
-        //   std::printf("%lld", -42);  // prints "4294967254"
+      // but we don't have to do the same because it's a UB.
-        // 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));
-      }
     }
   }
 
@@ -163,7 +171,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) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+  arg.visit(arg_converter<T, Context>(arg, type));
 }
 
 // Converts an integer argument to char for printf.
@@ -176,8 +184,7 @@ template <typename Context> class char_converter {
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
   void operator()(T value) {
-    arg_ = detail::make_arg<Context>(
+    arg_ = static_cast<typename Context::char_type>(value);
-        static_cast<typename Context::char_type>(value));
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@@ -187,148 +194,148 @@ 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> const Char* operator()(T) { return nullptr; }
+  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
-  const Char* operator()(const Char* s) { return s; }
+  auto operator()(const Char* s) -> const Char* { return s; }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-template <typename Char> class printf_width_handler {
+class printf_width_handler {
  private:
-  using format_specs = basic_format_specs<Char>;
-
   format_specs& specs_;
 
  public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
+  auto operator()(T value) -> unsigned {
     auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
     if (detail::is_negative(value)) {
-      specs_.align = align::left;
+      specs_.set_align(align::left);
       width = 0 - width;
     }
-    unsigned int_max = max_value<int>();
+    unsigned int_max = to_unsigned(max_value<int>());
-    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    if (width > int_max) report_error("number is too big");
     return static_cast<unsigned>(width);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
+  auto operator()(T) -> unsigned {
-    FMT_THROW(format_error("width is not integer"));
+    report_error("width is not integer");
     return 0;
   }
 };
 
-// The ``printf`` argument formatter.
+// Workaround for a bug with the XL compiler when initializing
-template <typename OutputIt, typename Char>
+// printf_arg_formatter's base class.
+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<OutputIt, Char>;
+  using context_type = basic_printf_context<Char>;
-  using format_specs = basic_format_specs<Char>;
 
   context_type& context_;
 
-  OutputIt write_null_pointer(bool is_string = false) {
+  void write_null_pointer(bool is_string = false) {
     auto s = this->specs;
-    s.type = 0;
+    s.set_type(presentation_type::none);
-    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+    write_bytes<Char>(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(OutputIt iter, format_specs& s, context_type& ctx)
+  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
-      : base{iter, s, locale_ref()}, context_(ctx) {}
+                       context_type& ctx)
+      : base(make_arg_formatter(iter, s)), context_(ctx) {}
 
-  OutputIt operator()(monostate value) { return base::operator()(value); }
+  void operator()(monostate value) { write(value); }
 
   template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  OutputIt operator()(T value) {
+  void 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) {
-      format_specs fmt_specs = this->specs;
+      write(value);
-      if (fmt_specs.type && fmt_specs.type != 'c')
+      return;
-        return (*this)(static_cast<int>(value));
-      fmt_specs.sign = sign::none;
-      fmt_specs.alt = false;
-      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 (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
-        fmt_specs.align = align::right;
-      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
     }
-    return base::operator()(value);
+    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);
+    s.clear_alt();
+    s.set_fill(' ');  // 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)
+      s.set_align(align::right);
+    detail::write<Char>(this->out, static_cast<Char>(value), s);
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  OutputIt operator()(T value) {
+  void operator()(T value) {
-    return base::operator()(value);
+    write(value);
   }
 
-  /** Formats a null-terminated C string. */
+  void operator()(const char* value) {
-  OutputIt operator()(const char* value) {
+    if (value)
-    if (value) return base::operator()(value);
+      write(value);
-    return write_null_pointer(this->specs.type != 'p');
+    else
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
-  /** Formats a null-terminated wide C string. */
+  void operator()(const wchar_t* value) {
-  OutputIt operator()(const wchar_t* value) {
+    if (value)
-    if (value) return base::operator()(value);
+      write(value);
-    return write_null_pointer(this->specs.type != 'p');
+    else
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
-  OutputIt operator()(basic_string_view<Char> value) {
+  void operator()(basic_string_view<Char> value) { write(value); }
-    return base::operator()(value);
+
+  void operator()(const void* value) {
+    if (value)
+      write(value);
+    else
+      write_null_pointer();
   }
 
-  /** Formats a pointer. */
+  void operator()(typename basic_format_arg<context_type>::handle handle) {
-  OutputIt operator()(const void* value) {
+    auto parse_ctx = parse_context<Char>({});
-    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(basic_format_specs<Char>& specs, const Char*& it,
+void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
-                 const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
-    case '-':
+    case '-': specs.set_align(align::left); break;
-      specs.align = align::left;
+    case '+': specs.set_sign(sign::plus); break;
-      break;
+    case '0': specs.set_fill('0'); break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
     case ' ':
-      if (specs.sign != sign::plus) {
+      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
-        specs.sign = sign::space;
-      }
       break;
-    case '#':
+    case '#': specs.set_alt(); break;
-      specs.alt = true;
+    default:  return;
-      break;
-    default:
-      return;
     }
   }
 }
 
 template <typename Char, typename GetArg>
-int parse_header(const Char*& it, const Char* end,
+auto parse_header(const Char*& it, const Char* end, format_specs& specs,
-                 basic_format_specs<Char>& specs, GetArg get_arg) {
+                  GetArg get_arg) -> int {
   int arg_index = -1;
   Char c = *it;
   if (c >= '0' && c <= '9') {
@@ -339,11 +346,11 @@ int parse_header(const Char*& it, const Char* end,
       ++it;
       arg_index = value != -1 ? value : max_value<int>();
     } else {
-      if (c == '0') specs.fill[0] = '0';
+      if (c == '0') specs.set_fill('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) FMT_THROW(format_error("number is too big"));
+        if (value == -1) report_error("number is too big");
         specs.width = value;
         return arg_index;
       }
@@ -354,23 +361,47 @@ int parse_header(const Char*& it, const Char* end,
   if (it != end) {
     if (*it >= '0' && *it <= '9') {
       specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
+      if (specs.width == -1) report_error("number is too big");
     } else if (*it == '*') {
       ++it;
-      specs.width = static_cast<int>(visit_format_arg(
+      specs.width = static_cast<int>(
-          detail::printf_width_handler<Char>(specs), get_arg(-1)));
+          get_arg(-1).visit(detail::printf_width_handler(specs)));
     }
   }
   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 OutputIt = buffer_appender<Char>;
+  using iterator = basic_appender<Char>;
-  auto out = OutputIt(buf);
+  auto out = iterator(buf);
-  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = basic_printf_parse_context<Char>(format);
+  auto parse_ctx = parse_context<Char>(format);
 
   // Returns the argument with specified index or, if arg_index is -1, the next
   // argument.
@@ -386,26 +417,24 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
   const Char* end = parse_ctx.end();
   auto it = start;
   while (it != end) {
-    if (!detail::find<false, Char>(it, end, '%', it)) {
+    if (!find<false, Char>(it, end, '%', it)) {
-      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
+      it = end;  // find leaves it == nullptr if it doesn't find '%'.
       break;
     }
     Char c = *it++;
     if (it != end && *it == c) {
-      out = detail::write(
+      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
-          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
       start = ++it;
       continue;
     }
-    out = detail::write(out, basic_string_view<Char>(
+    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
-                                 start, detail::to_unsigned(it - 1 - start)));
 
-    basic_format_specs<Char> specs;
+    auto specs = format_specs();
-    specs.align = align::right;
+    specs.set_align(align::right);
 
     // Parse argument index, flags and width.
     int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) parse_ctx.on_error("argument not found");
+    if (arg_index == 0) report_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -415,8 +444,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 = static_cast<int>(
+        specs.precision =
-            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
       } else {
         specs.precision = 0;
       }
@@ -425,32 +454,31 @@ 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 && arg.is_integral())
+    if (specs.precision >= 0 && is_integral_type(arg.type())) {
-      specs.fill[0] =
+      // Ignore '0' for non-numeric types or if '-' present.
-          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
+      specs.set_fill(' ');
-    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
+    }
-      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
+    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
+      auto str = arg.visit(get_cstring<Char>());
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
-      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+      auto sv = basic_string_view<Char>(
-          basic_string_view<Char>(
+          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-              str, detail::to_unsigned(nul != str_end ? nul - str
+      arg = sv;
-                                                      : specs.precision)));
     }
-    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
-      specs.alt = false;
+    if (specs.fill_unit<Char>() == '0') {
-    if (specs.fill[0] == '0') {
+      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
-      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.set_align(align::numeric);
-        specs.align = align::numeric;
+      } else {
-      else
+        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+        specs.set_fill(' ');
-                              // 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') {
@@ -470,183 +498,136 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         convert_arg<long>(arg, t);
       }
       break;
-    case 'j':
+    case 'j': convert_arg<intmax_t>(arg, t); break;
-      convert_arg<intmax_t>(arg, t);
+    case 'z': convert_arg<size_t>(arg, t); break;
-      break;
+    case 't': convert_arg<std::ptrdiff_t>(arg, t); 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:
+    default: --it; convert_arg<void>(arg, c);
-      --it;
-      convert_arg<void>(arg, c);
     }
 
     // Parse type.
-    if (it == end) FMT_THROW(format_error("invalid format string"));
+    if (it == end) report_error("invalid format string");
-    specs.type = static_cast<char>(*it++);
+    char type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
+    if (is_integral_type(arg.type())) {
       // Normalize type.
-      switch (specs.type) {
+      switch (type) {
       case 'i':
-      case 'u':
+      case 'u': type = 'd'; break;
-        specs.type = 'd';
-        break;
       case 'c':
-        visit_format_arg(
+        arg.visit(char_converter<basic_printf_context<Char>>(arg));
-            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
-            arg);
         break;
       }
     }
+    bool upper = false;
+    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
+    if (specs.type() == presentation_type::none)
+      report_error("invalid format specifier");
+    if (upper) specs.set_upper();
 
     start = it;
 
     // Format argument.
-    out = visit_format_arg(
+    arg.visit(printf_arg_formatter<Char>(out, specs, context));
-        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
   }
-  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 
-template <typename Char>
+using printf_context = basic_printf_context<char>;
-using basic_printf_context_t =
+using wprintf_context = basic_printf_context<wchar_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
-  \rst
+/// arguments and can be implicitly converted to `printf_args`.
-  Constructs an `~fmt::format_arg_store` object that contains references to
+template <typename Char = char, typename... T>
-  arguments and can be implicitly converted to `~fmt::printf_args`.
+inline auto make_printf_args(T&... args)
-  \endrst
+    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
- */
+  return fmt::make_format_args<basic_printf_context<Char>>(args...);
-template <typename... T>
-inline auto make_printf_args(const T&... args)
-    -> format_arg_store<printf_context, T...> {
-  return {args...};
 }
 
-/**
+template <typename Char> struct vprintf_args {
-  \rst
+  using type = basic_format_args<basic_printf_context<Char>>;
-  Constructs an `~fmt::format_arg_store` object that contains references to
+};
-  arguments and can be implicitly converted to `~fmt::wprintf_args`.
-  \endrst
- */
-template <typename... T>
-inline auto make_wprintf_args(const T&... args)
-    -> format_arg_store<wprintf_context, T...> {
-  return {args...};
-}
 
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
-inline auto vsprintf(
+inline auto vsprintf(basic_string_view<Char> fmt,
-    const S& fmt,
+                     typename vprintf_args<Char>::type args)
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buffer;
+  auto buf = basic_memory_buffer<Char>();
-  vprintf(buffer, to_string_view(fmt), args);
+  detail::vprintf(buf, fmt, args);
-  return to_string(buffer);
+  return {buf.data(), buf.size()};
 }
 
 /**
-  \rst
+ * Formats `args` according to specifications in `fmt` and returns the result
-  Formats arguments and returns the result as a string.
+ * as as string.
-
+ *
-  **Example**::
+ * **Example**:
-
+ *
-    std::string message = fmt::sprintf("The answer is %d", 42);
+ *     std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
+ */
-*/
+template <typename S, typename... T, typename Char = detail::char_t<S>>
-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),
-  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }
 
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
-inline auto vfprintf(
+inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
-    std::FILE* f, const S& fmt,
+                     typename vprintf_args<Char>::type args) -> int {
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+  auto buf = basic_memory_buffer<Char>();
-    -> int {
+  detail::vprintf(buf, fmt, args);
-  basic_memory_buffer<Char> buffer;
+  size_t size = buf.size();
-  vprintf(buffer, to_string_view(fmt), args);
+  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
-  size_t size = buffer.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
              : static_cast<int>(size);
 }
 
 /**
-  \rst
+ * Formats `args` according to specifications in `fmt` and writes the output
-  Prints formatted data to the file *f*.
+ * to `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 = char_t<S>>
+template <typename S, typename... T, typename Char = detail::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),
-  return vfprintf(f, to_string_view(fmt),
+                  make_printf_args<Char>(args...));
-                  fmt::make_format_args<context>(args...));
 }
 
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
-inline auto vprintf(
+FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
-    const S& fmt,
+                                   typename vprintf_args<Char>::type args)
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> int {
-  return vfprintf(stdout, to_string_view(fmt), args);
+  return vfprintf(stdout, fmt, args);
 }
 
 /**
-  \rst
+ * Formats `args` according to specifications in `fmt` and writes the output
-  Prints formatted data to ``stdout``.
+ * to `stdout`.
-
+ *
-  **Example**::
+ * **Example**:
-
+ *
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+ *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
  */
-template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+template <typename... T>
-inline auto printf(const S& fmt, const T&... args) -> int {
+inline auto printf(string_view fmt, const T&... args) -> int {
-  return vprintf(
+  return vfprintf(stdout, fmt, make_printf_args(args...));
-      to_string_view(fmt),
+}
-      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
+template <typename... T>
+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...));
 }
 
-template <typename S, typename Char = char_t<S>>
+FMT_END_EXPORT
-FMT_DEPRECATED auto vfprintf(
-    std::basic_ostream<Char>& os, const S& fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-    -> int {
-  basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
-  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
-  return static_cast<int>(buffer.size());
-}
-template <typename S, typename... T, typename Char = char_t<S>>
-FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
-                            const T&... args) -> int {
-  return vfprintf(os, to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
-}
-
-FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_PRINTF_H_

include/spdlog/fmt/bundled/std.h

@@ -0,0 +1,726 @@
+// 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

@@ -5,59 +5,134 @@
 //
 // For the license information refer to format.h.
 
-#ifndef FMT_WCHAR_H_
+#ifndef FMT_XCHAR_H_
-#define FMT_WCHAR_H_
+#define FMT_XCHAR_H_
-
-#include <cwchar>
-#include <tuple>
 
+#include "color.h"
 #include "format.h"
+#include "ostream.h"
+#include "ranges.h"
+
+#ifndef FMT_MODULE
+#  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>;
-}
 
-FMT_MODULE_EXPORT_BEGIN
+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
 
 using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_parse_context = parse_context<wchar_t>;
-using wformat_context = buffer_context<wchar_t>;
+using wformat_context = buffered_context<wchar_t>;
 using wformat_args = basic_format_args<wformat_context>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;
 
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+template <typename Char, typename... T> struct basic_fstring {
-// Workaround broken conversion on older gcc.
+ private:
-template <typename... Args> using wformat_string = wstring_view;
+  basic_string_view<Char> str_;
-#else
+
-template <typename... Args>
+  static constexpr int num_static_named_args =
-using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+      detail::count_static_named_args<T...>();
-#endif
+
+  using checker = detail::format_string_checker<
+      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
+      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 {};
 
-template <typename... Args>
+#ifdef __cpp_char8_t
-constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
-    const Args&... args) {
+#endif
-  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 {
-constexpr auto operator"" _format(const wchar_t* s, size_t n)
+inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
-    -> detail::udl_formatter<wchar_t> {
-  return {{s, n}};
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
-constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
   return {s};
 }
-#endif
 }  // namespace literals
+#endif
 
 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@@ -65,9 +140,9 @@ auto join(It begin, Sentinel end, wstring_view sep)
   return {begin, end, sep};
 }
 
-template <typename Range>
+template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
                  wchar_t> {
   return join(std::begin(range), std::end(range), sep);
 }
@@ -78,136 +153,150 @@ 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> format_str,
+auto vformat(basic_string_view<Char> fmt,
-             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+             typename detail::vformat_args<Char>::type args)
     -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buffer;
+  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buffer, format_str, args);
+  detail::vformat_to(buf, fmt, args);
-  return to_string(buffer);
+  return {buf.data(), buf.size()};
+}
+
+template <typename... T>
+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... Args, typename Char = char_t<S>,
+template <typename S, typename... T,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+          typename Char = detail::format_string_char_t<S>,
-auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+                        !std::is_same<Char, wchar_t>::value)>
-  return vformat(to_string_view(format_str), vargs);
+auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(fmt),
+                 fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename Locale, typename S, typename Char = char_t<S>,
+template <typename Locale, typename 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(
+inline auto vformat(const Locale& loc, const S& fmt,
-    const Locale& loc, const S& format_str,
+                    typename detail::vformat_args<Char>::type args)
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
-  return detail::vformat(loc, to_string_view(format_str), args);
+  auto buf = basic_memory_buffer<Char>();
+  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... Args,
+template <typename Locale, typename S, typename... T,
-          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 format(const Locale& loc, const S& format_str, Args&&... args)
+inline auto format(const Locale& loc, const S& fmt, T&&... args)
     -> std::basic_string<Char> {
-  return detail::vformat(loc, to_string_view(format_str),
+  return vformat(loc, detail::to_string_view(fmt),
-                         fmt::make_args_checked<Args...>(format_str, args...));
+                 fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename OutputIt, typename S, typename Char = char_t<S>,
+template <typename OutputIt, typename 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& format_str,
+auto vformat_to(OutputIt out, const S& fmt,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+                typename detail::vformat_args<Char>::type args) -> OutputIt {
-    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, to_string_view(format_str), args);
+  detail::vformat_to(buf, detail::to_string_view(fmt), args);
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
-                            detail::is_exotic_char<Char>::value)>
+                        !std::is_same<Char, char>::value &&
-inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+                        !std::is_same<Char, wchar_t>::value)>
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, to_string_view(fmt), vargs);
+  return vformat_to(out, detail::to_string_view(fmt),
-}
+                    fmt::make_format_args<buffered_context<Char>>(args...));
-
-template <typename S, typename... Args, typename Char, size_t SIZE,
-          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
-FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
-                              const S& format_str, Args&&... args) ->
-    typename buffer_context<Char>::iterator {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
-  return detail::buffer_appender<Char>(buf);
 }
 
 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_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(
+inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt,
-    OutputIt out, const Locale& loc, const S& format_str,
+                       typename detail::vformat_args<Char>::type args)
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc));
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 
-template <
+template <typename Locale, typename OutputIt, typename S, typename... T,
-    typename OutputIt, typename Locale, typename S, typename... Args,
+          typename Char = detail::format_string_char_t<S>,
-    typename Char = char_t<S>,
+          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
-    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+                        detail::is_locale<Locale>::value &&
-        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
-                      Args&&... args) ->
+                      T&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat_to(out, loc, detail::to_string_view(fmt),
-  return vformat_to(out, loc, to_string_view(format_str), vargs);
+                    fmt::make_format_args<buffered_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(
+inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt,
-    OutputIt out, size_t n, basic_string_view<Char> format_str,
+                         typename detail::vformat_args<Char>::type args)
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
     -> format_to_n_result<OutputIt> {
-  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+  using traits = detail::fixed_buffer_traits;
-                                                                           n);
+  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, format_str, args);
+  detail::vformat_to(buf, fmt, args);
   return {buf.out(), buf.count()};
 }
 
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
-          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)>
-inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-                        const Args&... args) -> format_to_n_result<OutputIt> {
+    -> format_to_n_result<OutputIt> {
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
-  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+                      fmt::make_format_args<buffered_context<Char>>(args...));
 }
 
-template <typename S, typename... Args, typename Char = char_t<S>,
+template <typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
-inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
-  detail::counting_buffer<Char> buf;
+  auto buf = detail::counting_buffer<Char>();
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  detail::vformat_to(buf, detail::to_string_view(fmt),
-  detail::vformat_to(buf, to_string_view(fmt), vargs);
+                     fmt::make_format_args<buffered_context<Char>>(args...));
   return buf.count();
 }
 
 inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  wmemory_buffer buffer;
+  auto buf = wmemory_buffer();
-  detail::vformat_to(buffer, fmt, args);
+  detail::vformat_to(buf, fmt, args);
-  buffer.push_back(L'\0');
+  buf.push_back(L'\0');
-  if (std::fputws(buffer.data(), f) == -1)
+  if (std::fputws(buf.data(), f) == -1)
     FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
@@ -217,20 +306,68 @@ inline void vprint(wstring_view fmt, wformat_args args) {
 
 template <typename... T>
 void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return vprint(f, wstring_view(fmt), make_wformat_args(args...));
+  return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
 template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
-  return vprint(wstring_view(fmt), make_wformat_args(args...));
+  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
-/**
+template <typename... T>
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
+void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
- */
+  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_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
-#endif  // FMT_WCHAR_H_
+#endif  // FMT_XCHAR_H_

include/spdlog/fmt/chrono.h

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

include/spdlog/fmt/compile.h

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

include/spdlog/fmt/fmt.h

@@ -9,19 +9,22 @@
 // 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_FMT_EXTERNAL)
+#if defined(SPDLOG_USE_STD_FORMAT)  // SPDLOG_USE_STD_FORMAT is defined - use std::format
-#    if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
+    #include <format>
-#        define FMT_HEADER_ONLY
+#elif !defined(SPDLOG_FMT_EXTERNAL)
-#    endif
+    #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
-#    ifndef FMT_USE_WINDOWS_H
+        #define FMT_HEADER_ONLY
-#        define FMT_USE_WINDOWS_H 0
+    #endif
-#    endif
+    #ifndef FMT_USE_WINDOWS_H
-// enable the 'n' flag in for backward compatibility with fmt 6.x
+        #define FMT_USE_WINDOWS_H 0
-#    define FMT_DEPRECATED_N_SPECIFIER
+    #endif
-#    include <spdlog/fmt/bundled/core.h>
+
-#    include <spdlog/fmt/bundled/format.h>
+    #include <spdlog/fmt/bundled/core.h>
-#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
+    #include <spdlog/fmt/bundled/format.h>
-#    include <fmt/core.h>
+
-#    include <fmt/format.h>
+#else  // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
+    #include <fmt/core.h>
+    #include <fmt/format.h>
 #endif

include/spdlog/fmt/ostr.h

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

include/spdlog/fmt/ranges.h

@@ -0,0 +1,23 @@
+//
+// 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 ranges support
+//
+#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/ranges.h>
+    #else
+        #include <fmt/ranges.h>
+    #endif
+#endif

include/spdlog/fmt/std.h

@@ -0,0 +1,24 @@
+//
+// 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

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

include/spdlog/formatter.h

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

include/spdlog/fwd.h

@@ -11,4 +11,8 @@ namespace sinks {
 class sink;
 }
 
-} // namespace spdlog
+namespace level {
+enum level_enum : int;
+}
+
+}  // namespace spdlog

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,31 +17,29 @@ 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 : name_(std::move(other.name_)),
+SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT
-                                                               sinks_(std::move(other.sinks_)),
+    : name_(std::move(other.name_)),
-                                                               level_(other.level_.load(std::memory_order_relaxed)),
+      sinks_(std::move(other.sinks_)),
-                                                               flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
+      level_(other.level_.load(std::memory_order_relaxed)),
-                                                               custom_err_handler_(std::move(other.custom_err_handler_)),
+      flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
-                                                               tracer_(std::move(other.tracer_))
+      custom_err_handler_(std::move(other.custom_err_handler_)),
+      tracer_(std::move(other.tracer_))
 
 {}
 
-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_);
 
@@ -59,179 +57,121 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT
     std::swap(tracer_, other.tracer_);
 }
 
-SPDLOG_INLINE void swap(logger &a, logger &b)
+SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); }
-{
-    a.swap(b);
-}
 
-SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
+SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(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
+SPDLOG_INLINE const std::string &logger::name() const { return name_; }
-{
-    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) {
-    for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
+        if (std::next(it) == sinks_.end()) {
-    {
-        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
+            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)
+SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); }
-{
-    tracer_.enable(n_messages);
-}
 
 // restore orig sinks and level and delete the backtrace sink
-SPDLOG_INLINE void logger::disable_backtrace()
+SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); }
-{
-    tracer_.disable();
-}
 
-SPDLOG_INLINE void logger::dump_backtrace()
+SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); }
-{
-    dump_backtrace_();
-}
 
 // flush functions
-SPDLOG_INLINE void logger::flush()
+SPDLOG_INLINE void logger::flush() { flush_(); }
-{
-    flush_();
-}
 
-SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
+SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(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
+SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const { return sinks_; }
-{
-    return sinks_;
-}
 
-SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
+SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() { return 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, bool log_enabled, bool traceback_enabled)
+SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg,
-{
+                                   bool log_enabled,
-    if (log_enabled)
+                                   bool traceback_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_) {
-    for (auto &sink : sinks_)
+        if (sink->should_log(msg.level)) {
-    {
+            SPDLOG_TRY { sink->log(msg); }
-        if (sink->should_log(msg.level))
+            SPDLOG_LOGGER_CATCH(msg.source)
-        {
-            SPDLOG_TRY
-            {
-                sink->log(msg);
-            }
-            SPDLOG_LOGGER_CATCH()
         }
     }
 
-    if (should_flush_(msg))
+    if (should_flush_(msg)) {
-    {
         flush_();
     }
 }
 
-SPDLOG_INLINE void logger::flush_()
+SPDLOG_INLINE void logger::flush_() {
-{
+    for (auto &sink : sinks_) {
-    for (auto &sink : sinks_)
+        SPDLOG_TRY { sink->flush(); }
-    {
+        SPDLOG_LOGGER_CATCH(source_loc())
-        SPDLOG_TRY
-        {
-            sink->flush();
-        }
-        SPDLOG_LOGGER_CATCH()
     }
 }
 
-SPDLOG_INLINE void logger::dump_backtrace_()
+SPDLOG_INLINE void logger::dump_backtrace_() {
-{
     using details::log_msg;
-    if (tracer_.enabled())
+    if (tracer_.enabled() && !tracer_.empty()) {
-    {
+        sink_it_(
-        sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
+            log_msg{name(), level::info, "****************** Backtrace Start ******************"});
         tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
-        sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
+        sink_it_(
+            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;
@@ -239,19 +179,20 @@ 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;
         auto tm_time = details::os::localtime(system_clock::to_time_t(now));
         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
+#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(), msg.c_str());
+        REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(),
+                 msg.c_str());
 #else
-        std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
+        std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf,
+                     name().c_str(), msg.c_str());
 #endif
     }
 }
-} // namespace spdlog
+}  // namespace spdlog

include/spdlog/logger.h

@@ -15,60 +15,58 @@
 // formatted data, and support for different format per sink.
 
 #include <spdlog/common.h>
-#include <spdlog/details/log_msg.h>
 #include <spdlog/details/backtracer.h>
+#include <spdlog/details/log_msg.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()                                                                                                          \
+    #define SPDLOG_LOGGER_CATCH(location)                                                 \
-        catch (const std::exception &ex)                                                                                                   \
+        catch (const std::exception &ex) {                                                \
-        {                                                                                                                                  \
+            if (location.filename) {                                                      \
-            err_handler_(ex.what());                                                                                                       \
+                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
-        }                                                                                                                                  \
+                                             location.filename, location.line));          \
-        catch (...)                                                                                                                        \
+            } else {                                                                      \
-        {                                                                                                                                  \
+                err_handler_(ex.what());                                                  \
-            err_handler_("Rethrowing unknown exception in logger");                                                                        \
+            }                                                                             \
-            throw;                                                                                                                         \
+        }                                                                                 \
+        catch (...) {                                                                     \
+            err_handler_("Rethrowing unknown exception in logger");                       \
+            throw;                                                                        \
         }
 #else
-#    define SPDLOG_LOGGER_CATCH()
+    #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;
 
@@ -77,44 +75,36 @@ 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, fmt::format_string<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, fmt::format_string<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 can be statically converted to string_view
+    // T cannot be statically converted to format string (including string_view/wstring_view)
-    template<class T, typename std::enable_if<std::is_convertible<const T &, spdlog::string_view_t>::value, int>::type = 0>
+    template <class T,
-    void log(source_loc loc, level::level_enum lvl, const T &msg)
+              typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value,
-    {
+                                      int>::type = 0>
-        log(loc, lvl, string_view_t{msg});
+    void log(source_loc loc, level::level_enum lvl, const T &msg) {
-    }
-
-    // T cannot be statically converted to format string (including string_view)
-    template<class T, typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value, 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, source_loc loc, level::level_enum lvl, string_view_t msg)
+    void log(log_clock::time_point log_time,
-    {
+             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;
         }
 
@@ -122,12 +112,10 @@ 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;
         }
 
@@ -135,144 +123,148 @@ public:
         log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(level::level_enum lvl, string_view_t msg)
+    void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); }
-    {
-        log(source_loc{}, lvl, msg);
-    }
 
-    template<typename... Args>
+    template <typename... Args>
-    void trace(fmt::format_string<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(fmt::format_string<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(fmt::format_string<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(fmt::format_string<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(fmt::format_string<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(fmt::format_string<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(level::level_enum lvl, fmt::wformat_string<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)...);
+    }
+
+    template <typename... Args>
+    void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
         log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
     }
 
-    template<typename... Args>
+    void log(log_clock::time_point log_time,
-    void log(source_loc loc, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args)
+             source_loc loc,
-    {
+             level::level_enum lvl,
-        log_(loc, lvl, fmt, std::forward<Args>(args)...);
+             wstring_view_t msg) {
+        bool log_enabled = should_log(lvl);
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled) {
+            return;
+        }
+
+        memory_buf_t buf;
+        details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);
+        details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+        log_it_(log_msg, log_enabled, traceback_enabled);
     }
 
-    template<typename... Args>
+    void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) {
-    void trace(fmt::wformat_string<Args...> fmt, Args &&...args)
+        bool log_enabled = should_log(lvl);
-    {
+        bool traceback_enabled = tracer_.enabled();
+        if (!log_enabled && !traceback_enabled) {
+            return;
+        }
+
+        memory_buf_t buf;
+        details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);
+        details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
+        log_it_(log_msg, log_enabled, traceback_enabled);
+    }
+
+    void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); }
+
+    template <typename... 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(fmt::wformat_string<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(fmt::wformat_string<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(fmt::wformat_string<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(fmt::wformat_string<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(fmt::wformat_string<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
+    bool should_backtrace() const { return tracer_.enabled(); }
-    {
-        return tracer_.enabled();
-    }
 
     void set_level(level::level_enum log_level);
 
@@ -284,6 +276,10 @@ public:
     // each sink will get a separate instance of the formatter object.
     void set_formatter(std::unique_ptr<formatter> f);
 
+    // set formatting for the sinks in this logger.
+    // equivalent to
+    //     set_formatter(make_unique<pattern_formatter>(pattern, time_type))
+    // Note: each sink will get a new instance of a formatter object, replacing the old one.
     void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
 
     // backtrace support.
@@ -317,69 +313,49 @@ 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;
-            fmt::detail::vformat_to(buf, fmt, fmt::make_format_args(args...));
+#ifdef SPDLOG_USE_STD_FORMAT
+            fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...));
+#else
+            fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...));
+#endif
+
             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()
+        SPDLOG_LOGGER_CATCH(loc)
     }
 
 #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
-            fmt::wmemory_buffer wbuf;
+            wmemory_buf_t wbuf;
-            fmt::detail::vformat_to(wbuf, fmt, fmt::make_format_args<fmt::wformat_context>(args...));
+            fmt_lib::vformat_to(std::back_inserter(wbuf), fmt,
+                                fmt_lib::make_format_args<fmt_lib::wformat_context>(args...));
+
             memory_buf_t buf;
             details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), 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()
+        SPDLOG_LOGGER_CATCH(loc)
     }
-
+#endif  // SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    // 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()
-    }
-
-#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
     // log the given message (if the given log level is high enough),
     // and save backtrace (if backtrace is enabled).
@@ -396,8 +372,8 @@ protected:
 
 void swap(logger &a, logger &b);
 
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "logger-inl.h"
+    #include "logger-inl.h"
 #endif

include/spdlog/mdc.h

@@ -0,0 +1,50 @@
+// 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,77 +13,67 @@
 #include <memory>
 
 #include <string>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
 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
+    bool enabled() const { return enabled_; }
-    {
-        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, const std::tm &tm_time, memory_buf_t &dest) = 0;
+    virtual void format(const details::log_msg &msg,
+                        const std::tm &tm_time,
+                        memory_buf_t &dest) = 0;
 
 protected:
     padding_info padinfo_;
 };
 
-} // namespace details
+}  // 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(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, pattern_time_type time_type = pattern_time_type::local,
+    explicit pattern_formatter(std::string pattern,
-        std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags());
+                               pattern_time_type time_type = pattern_time_type::local,
+                               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, std::string eol = spdlog::details::os::default_eol);
+    explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local,
+                               std::string eol = spdlog::details::os::default_eol);
 
     pattern_formatter(const pattern_formatter &other) = delete;
     pattern_formatter &operator=(const pattern_formatter &other) = delete;
@@ -91,36 +81,38 @@ 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;
     }
     void set_pattern(std::string pattern);
+    void need_localtime(bool need = true);
 
 private:
     std::string pattern_;
     std::string eol_;
     pattern_time_type pattern_time_type_;
+    bool need_localtime_;
     std::tm cached_tm_;
     std::chrono::seconds last_log_secs_;
     std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
     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, std::string::const_iterator end);
+    static details::padding_info handle_padspec_(std::string::const_iterator &it,
+                                                 std::string::const_iterator end);
 
     void compile_pattern_(const std::string &pattern);
 };
-} // namespace spdlog
+}  // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "pattern_formatter-inl.h"
+    #include "pattern_formatter-inl.h"
 #endif

include/spdlog/sinks/android_sink.h

@@ -5,90 +5,102 @@
 
 #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/sinks/base_sink.h>
+    #include <spdlog/details/synchronous_factory.h>
-#    include <spdlog/details/synchronous_factory.h>
+    #include <spdlog/sinks/base_sink.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>
 
-#    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)
+ * Android sink
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified
+ * BufferID)
  */
-template<typename Mutex>
+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');
         const char *msg_output = formatted.data();
 
         // See system/core/liblog/logger_write.c for explanation of return value
-        int ret = __android_log_write(priority, tag_.c_str(), msg_output);
+        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_write(priority, tag_.c_str(), msg_output);
+            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);
-            throw_spdlog_ex("__android_log_write() failed", ret);
         }
     }
 
     void flush_() override {}
 
 private:
-    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
+    // There might be liblog versions used, that do not support __android_log_buf_write. So we only
-    {
+    // compile and link against
-        switch (level)
+    // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,
-        {
+    // when using the default log buffer, always log via __android_log_write.
-        case spdlog::level::trace:
+    template <int ID = BufferID>
-            return ANDROID_LOG_VERBOSE;
+    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
-        case spdlog::level::debug:
+        int prio, const char *tag, const char *text) {
-            return ANDROID_LOG_DEBUG;
+        return __android_log_write(prio, tag, text);
-        case spdlog::level::info:
+    }
-            return ANDROID_LOG_INFO;
+
-        case spdlog::level::warn:
+    template <int ID = BufferID>
-            return ANDROID_LOG_WARN;
+    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
-        case spdlog::level::err:
+        int prio, const char *tag, const char *text) {
-            return ANDROID_LOG_ERROR;
+        return __android_log_buf_write(ID, prio, tag, text);
-        case spdlog::level::critical:
+    }
-            return ANDROID_LOG_FATAL;
+
-        default:
+    static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {
-            return ANDROID_LOG_DEFAULT;
+        switch (level) {
+            case spdlog::level::trace:
+                return ANDROID_LOG_VERBOSE;
+            case spdlog::level::debug:
+                return ANDROID_LOG_DEBUG;
+            case spdlog::level::info:
+                return ANDROID_LOG_INFO;
+            case spdlog::level::warn:
+                return ANDROID_LOG_WARN;
+            case spdlog::level::err:
+                return ANDROID_LOG_ERROR;
+            case spdlog::level::critical:
+                return ANDROID_LOG_FATAL;
+            default:
+                return ANDROID_LOG_DEFAULT;
         }
     }
 
@@ -98,22 +110,28 @@ private:
 
 using android_sink_mt = android_sink<std::mutex>;
 using android_sink_st = android_sink<details::null_mutex>;
-} // namespace sinks
+
+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>
+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, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name,
-{
+                                                 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, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name,
-{
+                                                 const std::string &tag = "spdlog") {
     return Factory::template create<sinks::android_sink_st>(logger_name, tag);
 }
 
-} // namespace spdlog
+}  // namespace spdlog
 
-#endif // __ANDROID__
+#endif  // __ANDROID__

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -4,42 +4,41 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/sinks/ansicolor_sink.h>
+    #include <spdlog/sinks/ansicolor_sink.h>
 #endif
 
-#include <spdlog/pattern_formatter.h>
 #include <spdlog/details/os.h>
+#include <spdlog/pattern_formatter.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_[level::trace] = to_string_(white);
+    colors_.at(level::trace) = to_string_(white);
-    colors_[level::debug] = to_string_(cyan);
+    colors_.at(level::debug) = to_string_(cyan);
-    colors_[level::info] = to_string_(green);
+    colors_.at(level::info) = to_string_(green);
-    colors_[level::warn] = to_string_(yellow_bold);
+    colors_.at(level::warn) = to_string_(yellow_bold);
-    colors_[level::err] = to_string_(red_bold);
+    colors_.at(level::err) = to_string_(red_bold);
-    colors_[level::critical] = to_string_(bold_on_red);
+    colors_.at(level::critical) = to_string_(bold_on_red);
-    colors_[level::off] = to_string_(reset);
+    colors_.at(level::off) = to_string_(reset);
 }
 
-template<typename ConsoleMutex>
+template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level,
-{
+                                                           string_view_t color) {
     std::lock_guard<mutex_t> lock(mutex_);
-    colors_[color_level] = to_string_(color);
+    colors_.at(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_);
@@ -47,99 +46,96 @@ 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_[msg.level]);
+        print_ccode_(colors_.at(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(std::unique_ptr<spdlog::formatter> sink_formatter)
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_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()
+SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() const {
-{
     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_);
-    switch (mode)
+    set_color_mode_(mode);
-    {
+}
-    case color_mode::always:
+
-        should_do_colors_ = true;
+template <typename ConsoleMutex>
-        return;
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode) {
-    case color_mode::automatic:
+    switch (mode) {
-        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
+        case color_mode::always:
-        return;
+            should_do_colors_ = true;
-    case color_mode::never:
+            return;
-        should_do_colors_ = false;
+        case color_mode::automatic:
-        return;
+            should_do_colors_ =
-    default:
+                details::os::in_terminal(target_file_) && details::os::is_color_terminal();
-        should_do_colors_ = false;
+            return;
+        case color_mode::never:
+            should_do_colors_ = false;
+            return;
+        default:
+            should_do_colors_ = false;
     }
 }
 
-template<typename ConsoleMutex>
+template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) const {
-{
+    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, size_t start, size_t end)
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
-{
+                                                              size_t start,
-    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
+                                                              size_t end) const {
+    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 sinks
-} // namespace spdlog
+}  // 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,9 +21,8 @@ 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);
@@ -37,11 +36,11 @@ public:
 
     void set_color(level::level_enum color_level, string_view_t color);
     void set_color_mode(color_mode mode);
-    bool should_color();
+    bool should_color() const;
 
     void log(const details::log_msg &msg) override;
     void flush() override;
-    void set_pattern(const std::string &pattern) final;
+    void set_pattern(const std::string &pattern) final override;
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
 
     // Formatting codes
@@ -85,21 +84,20 @@ private:
     bool should_do_colors_;
     std::unique_ptr<spdlog::formatter> formatter_;
     std::array<std::string, level::n_levels> colors_;
-    void print_ccode_(const string_view_t &color_code);
+    void set_color_mode_(color_mode mode);
-    void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
+    void print_ccode_(const string_view_t &color_code) const;
+    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);
 };
@@ -110,9 +108,9 @@ using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmute
 using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
 using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
 
-} // namespace sinks
+}  // namespace sinks
-} // namespace spdlog
+}  // 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,60 +4,56 @@
 #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(std::unique_ptr<spdlog::formatter> formatter)
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(
-    : formatter_{std::move(formatter)}
+    std::unique_ptr<spdlog::formatter> 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 spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+void SPDLOG_INLINE
-{
+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 spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
+void SPDLOG_INLINE
-{
+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,9 +15,8 @@
 
 namespace spdlog {
 namespace sinks {
-template<typename Mutex>
+template <typename Mutex>
-class base_sink : public sink
+class SPDLOG_API base_sink : public sink {
-{
 public:
     base_sink();
     explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
@@ -29,24 +28,24 @@ public:
     base_sink &operator=(const base_sink &) = delete;
     base_sink &operator=(base_sink &&) = delete;
 
-    void log(const details::log_msg &msg) final;
+    void log(const details::log_msg &msg) final override;
-    void flush() final;
+    void flush() final override;
-    void set_pattern(const std::string &pattern) final;
+    void set_pattern(const std::string &pattern) final override;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override;
 
 protected:
     // sink formatter
     std::unique_ptr<spdlog::formatter> formatter_;
-    mutable Mutex mutex_;
+    Mutex mutex_;
 
     virtual void sink_it_(const details::log_msg &msg) = 0;
     virtual void flush_() = 0;
     virtual void set_pattern_(const std::string &pattern);
     virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
 };
-} // namespace sinks
+}  // namespace sinks
-} // namespace spdlog
+}  // 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,31 +13,36 @@
 namespace spdlog {
 namespace sinks {
 
-template<typename Mutex>
+template <typename Mutex>
-SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate)
+SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename,
-{
+                                                      bool truncate,
+                                                      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>::sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void basic_file_sink<Mutex>::truncate() {
-{
+    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();
 }
 
-} // namespace sinks
+}  // namespace sinks
-} // namespace spdlog
+}  // namespace spdlog

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/sinks/base_sink.h>
 #include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
 
 #include <mutex>
 #include <string>
@@ -16,12 +16,14 @@ 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, bool truncate = false);
+    explicit basic_file_sink(const filename_t &filename,
+                             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;
@@ -34,25 +36,31 @@ private:
 using basic_file_sink_mt = basic_file_sink<std::mutex>;
 using basic_file_sink_st = basic_file_sink<details::null_mutex>;
 
-} // namespace sinks
+}  // namespace sinks
 
 //
 // 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, const filename_t &filename, bool truncate = false)
+inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
-{
+                                               const filename_t &filename,
-    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate);
+                                               bool truncate = false,
+                                               const file_event_handlers &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, const filename_t &filename, bool truncate = false)
+inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
-{
+                                               const filename_t &filename,
-    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate);
+                                               bool truncate = false,
+                                               const file_event_handlers &event_handlers = {}) {
+    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate,
+                                                               event_handlers);
 }
 
-} // namespace spdlog
+}  // 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

@@ -0,0 +1,56 @@
+// 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,19 +4,20 @@
 #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/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 <spdlog/fmt/chrono.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/sinks/base_sink.h>
 
 #include <chrono>
 #include <cstdio>
-#include <ctime>
+#include <iomanip>
 #include <mutex>
+#include <sstream>
 #include <string>
 
 namespace spdlog {
@@ -25,36 +26,35 @@ 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::format(
+        return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")),
-            SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
+                               basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+                               ext);
     }
 };
 
 /*
  * Generator of daily log file names with strftime format.
  * Usages:
- *    auto sink =  std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour, minute);"
+ *    auto sink =
- *    auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour,  minute)"
+ * std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour,
+ * 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) {
-    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    {
+        std::wstringstream stream;
-        // generate fmt datetime format string, e.g. {:%Y-%m-%d}.
-        filename_t fmt_filename = fmt::format(SPDLOG_FILENAME_T("{{:{}}}"), filename);
-#if defined(_MSC_VER) && defined(SPDLOG_WCHAR_FILENAMES) // for some reason msvc doesnt allow fmt::runtime(..) with wchar here
-        return fmt::format(fmt_filename, now_tm);
 #else
-        return fmt::format(SPDLOG_FMT_RUNTIME(fmt_filename), now_tm);
+        std::stringstream stream;
 #endif
+        stream << std::put_time(&now_tm, file_path.c_str());
+        return stream.str();
     }
 };
 
@@ -62,22 +62,28 @@ struct daily_filename_format_calculator
  * 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, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0)
+    daily_file_sink(filename_t base_filename,
-        : base_filename_(std::move(base_filename))
+                    int rotation_hour,
-        , rotation_h_(rotation_hour)
+                    int rotation_minute,
-        , rotation_m_(rotation_minute)
+                    bool truncate = false,
-        , truncate_(truncate)
+                    uint16_t max_files = 0,
-        , max_files_(max_files)
+                    const file_event_handlers &event_handlers = {})
-        , filenames_q_()
+        : base_filename_(std::move(base_filename)),
-    {
+          rotation_h_(rotation_hour),
-        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
+          rotation_m_(rotation_minute),
-        {
+          file_helper_{event_handlers},
+          truncate_(truncate),
+          max_files_(max_files),
+          filenames_q_() {
+        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
+            rotation_minute > 59) {
             throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
         }
 
@@ -86,25 +92,21 @@ 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_();
@@ -114,57 +116,46 @@ 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
+    void flush_() override { file_helper_.flush(); }
-    {
-        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)};
@@ -172,21 +163,19 @@ 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), errno);
+                throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename),
+                                errno);
             }
         }
         filenames_q_.push_back(std::move(current_file));
@@ -205,38 +194,61 @@ 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 = daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
+using daily_file_format_sink_st =
+    daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
 
-} // namespace sinks
+}  // namespace sinks
 
 //
 // factory functions
 //
-template<typename Factory = spdlog::synchronous_factory>
+template <typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> daily_logger_mt(
+inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0)
+                                               const filename_t &filename,
-{
+                                               int hour = 0,
-    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files);
+                                               int minute = 0,
+                                               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(
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0)
+    const std::string &logger_name,
-{
+    const filename_t &filename,
-    return Factory::template create<sinks::daily_file_format_sink_mt>(logger_name, filename, hour, minute, truncate, max_files);
+    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(
+inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0)
+                                               const filename_t &filename,
-{
+                                               int hour = 0,
-    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files);
+                                               int minute = 0,
+                                               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(
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0)
+    const std::string &logger_name,
-{
+    const filename_t &filename,
-    return Factory::template create<sinks::daily_file_format_sink_st>(logger_name, filename, hour, minute, truncate, max_files);
+    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);
 }
-} // namespace spdlog
+}  // namespace spdlog