[ { "path": ".clang-format", "content": "---\nLanguage: Cpp\nBasedOnStyle: Google\nAccessModifierOffset: -4\nStandard: c++17\nIndentWidth: 4\nTabWidth: 4\nUseTab: Never\nColumnLimit: 100\nAlignAfterOpenBracket: Align\nBinPackParameters: false\nAlignEscapedNewlines: Left\nAlwaysBreakTemplateDeclarations: Yes\nPackConstructorInitializers: Never\nBreakConstructorInitializersBeforeComma: false\nIndentPPDirectives: None\nSortIncludes: Never\n...\n" }, { "path": ".clang-tidy", "content": "Checks: 'cppcoreguidelines-*,\nperformance-*,\nmodernize-*,\ngoogle-*,\nmisc-*\ncert-*,\nreadability-*,\nclang-analyzer-*,\n-performance-unnecessary-value-param,\n-modernize-use-trailing-return-type,\n-google-runtime-references,\n-misc-non-private-member-variables-in-classes,\n-readability-braces-around-statements,\n-google-readability-braces-around-statements,\n-cppcoreguidelines-avoid-magic-numbers,\n-readability-magic-numbers,\n-readability-magic-numbers,\n-cppcoreguidelines-pro-type-vararg,\n-cppcoreguidelines-pro-bounds-pointer-arithmetic,\n-cppcoreguidelines-avoid-c-arrays,\n-modernize-avoid-c-arrays,\n-cppcoreguidelines-pro-bounds-array-to-pointer-decay,\n-readability-named-parameter,\n-cert-env33-c\n'\n\n\nWarningsAsErrors: ''\nHeaderFilterRegex: '*spdlog/[^f].*'\nFormatStyle: none\n\nCheckOptions: \n - key: google-readability-braces-around-statements.ShortStatementLines\n value: '1'\n - key: google-readability-function-size.StatementThreshold\n value: '800'\n - key: google-readability-namespace-comments.ShortNamespaceLines\n value: '10'\n - key: google-readability-namespace-comments.SpacesBeforeComments\n value: '2'\n - key: modernize-loop-convert.MaxCopySize\n value: '16'\n - key: modernize-loop-convert.MinConfidence\n value: reasonable\n - key: modernize-loop-convert.NamingStyle\n value: CamelCase\n - key: modernize-pass-by-value.IncludeStyle\n value: llvm\n - key: modernize-replace-auto-ptr.IncludeStyle\n value: llvm\n - key: modernize-use-nullptr.NullMacros\n value: 'NULL'\n\n" }, { "path": ".git-blame-ignore-revs", "content": "# clang-format\n1a0bfc7a89f2d58e22605a4dc7e18a9a555b65aa\n95c226e9c92928e20ccdac0d060e7241859e282b\n9d52261185b5f2c454c381d626ec5c84d7b195f4\n4b2a8219d5d1b40062d030441adde7d1fb0d4f84\n0a53eafe18d983c7c8ba4cadd02d0cc7f7308f28\n" }, { "path": ".gitattributes", "content": "* text=false\n" }, { "path": ".github/workflows/coverity_scan.yml", "content": "name: coverity-linux\n\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n coverity_scan:\n runs-on: ubuntu-latest\n name: Coverity Scan\n steps:\n - uses: actions/checkout@v4\n\n - name: Install dependencies\n run: |\n sudo apt-get update\n sudo apt-get install -y curl build-essential cmake pkg-config libsystemd-dev\n\n - name: Download Coverity Tool\n run: |\n curl -s -L --output coverity_tool.tgz \"https://scan.coverity.com/download/linux64?token=${{ secrets.COVERITY_TOKEN }}&project=gabime%2Fspdlog\"\n mkdir coverity_tool\n tar -C coverity_tool --strip-components=1 -xf coverity_tool.tgz\n echo \"$PWD/coverity_tool/bin\" >> $GITHUB_PATH\n\n - name: Build with Coverity\n run: |\n mkdir build && cd build\n cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17\n cd ..\n cov-build --dir cov-int make -C build -j4\n\n - name: Submit results to Coverity\n run: |\n tar czf cov-int.tgz cov-int\n response=$(curl --silent --show-error --fail \\\n --form email=\"${{ secrets.EMAIL }}\" \\\n --form token=\"${{ secrets.COVERITY_TOKEN }}\" \\\n --form file=@cov-int.tgz \\\n --form version=\"GitHub PR #${{ github.event.pull_request.number }}\" \\\n --form description=\"CI run for PR\" \\\n https://scan.coverity.com/builds?project=gabime%2Fspdlog)\n\n echo \"$response\"\n\n if echo \"$response\" | grep -qi \"Build successfully submitted\"; then\n echo \"Coverity upload succeeded\"\n else\n echo \"Coverity upload failed or was rejected\"\n exit 1\n fi\n" }, { "path": ".github/workflows/linux.yml", "content": "name: linux\n\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n # -----------------------------------------------------------------------\n # Linux build matrix\n # -----------------------------------------------------------------------\n build:\n runs-on: ubuntu-latest\n defaults:\n run:\n shell: bash\n strategy:\n fail-fast: false\n matrix:\n config:\n - { compiler: gcc, version: 9, build_type: Release, cppstd: 11 }\n - { compiler: gcc, version: 11, build_type: Debug, cppstd: 17 }\n - { compiler: gcc, version: 12, build_type: Release, cppstd: 20 }\n - { compiler: gcc, version: 12, build_type: Debug, cppstd: 20, asan: ON }\n - { compiler: clang, version: 12, build_type: Debug, cppstd: 17 }\n - { compiler: clang, version: 15, build_type: Release, cppstd: 20, tsan: ON }\n container:\n image: ${{ matrix.config.compiler == 'clang' && 'teeks99/clang-ubuntu' || matrix.config.compiler }}:${{ matrix.config.version }}\n 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' || '' }})\"\n steps:\n - uses: actions/checkout@v4\n - name: Setup\n run: |\n apt-get update\n apt-get install -y curl git pkg-config libsystemd-dev\n CMAKE_VERSION=\"3.24.2\"\n curl -sSL https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-x86_64.sh -o install-cmake.sh\n chmod +x install-cmake.sh\n ./install-cmake.sh --prefix=/usr/local --skip-license\n - name: Setup Compiler\n if: matrix.config.compiler == 'clang'\n run: |\n scripts/ci_setup_clang.sh \"${{ matrix.config.version }}\"\n echo \"CXXFLAGS=-stdlib=libc++\" >> $GITHUB_ENV \n echo \"CC=clang-${{ matrix.config.version }}\" >> $GITHUB_ENV\n echo \"CXX=clang++-${{ matrix.config.version }}\" >> $GITHUB_ENV\n - name: Build\n run: |\n mkdir -p build && cd build\n cmake .. \\\n -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \\\n -DCMAKE_CXX_STANDARD=${{ matrix.config.cppstd }} \\\n -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.examples || 'ON' }} \\\n -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.examples || 'ON' }} \\\n -DSPDLOG_BUILD_WARNINGS=ON \\\n -DSPDLOG_BUILD_BENCH=OFF \\\n -DSPDLOG_BUILD_TESTS=ON \\\n -DSPDLOG_BUILD_TESTS_HO=OFF \\\n -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'OFF' }} \\\n -DSPDLOG_SANITIZE_THREAD=${{ matrix.config.tsan || 'OFF' }}\n make -j 4\n ctest -j 4 --output-on-failure\n\n # -----------------------------------------------------------------------\n # OS X build matrix\n # -----------------------------------------------------------------------\n build_osx:\n runs-on: macOS-latest\n name: \"OS X Clang (C++11, Release)\"\n steps:\n - uses: actions/checkout@v4\n - name: Build\n run: |\n mkdir -p build && cd build\n cmake .. \\\n -DCMAKE_BUILD_TYPE=Release \\\n -DCMAKE_CXX_STANDARD=11 \\\n -DSPDLOG_BUILD_EXAMPLE=ON \\\n -DSPDLOG_BUILD_EXAMPLE_HO=ON \\\n -DSPDLOG_BUILD_WARNINGS=ON \\\n -DSPDLOG_BUILD_BENCH=OFF \\\n -DSPDLOG_BUILD_TESTS=ON \\\n -DSPDLOG_BUILD_TESTS_HO=OFF \\\n -DSPDLOG_SANITIZE_ADDRESS=OFF\n make -j 4\n ctest -j 4 --output-on-failure\n" }, { "path": ".github/workflows/macos.yml", "content": "name: macos\n\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n build:\n runs-on: macOS-latest\n name: \"macOS Clang (C++11, Release)\"\n strategy:\n fail-fast: true\n matrix:\n config:\n - USE_STD_FORMAT: 'ON'\n BUILD_EXAMPLE: 'OFF'\n - USE_STD_FORMAT: 'OFF'\n BUILD_EXAMPLE: 'ON'\n \n steps:\n - uses: actions/checkout@v4\n - name: Build\n run: |\n mkdir -p build && cd build\n cmake .. \\\n -DCMAKE_BUILD_TYPE=Release \\\n -DCMAKE_CXX_STANDARD=11 \\\n -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} \\\n -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} \\\n -DSPDLOG_BUILD_WARNINGS=ON \\\n -DSPDLOG_BUILD_BENCH=OFF \\\n -DSPDLOG_BUILD_TESTS=ON \\\n -DSPDLOG_BUILD_TESTS_HO=OFF \\\n -DSPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} \\\n -DSPDLOG_SANITIZE_ADDRESS=OFF\n make -j 4\n ctest -j 4 --output-on-failure\n" }, { "path": ".github/workflows/windows.yml", "content": "name: windows\n\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n build:\n runs-on: windows-latest\n strategy:\n fail-fast: true\n matrix:\n config:\n - GENERATOR: \"Visual Studio 17 2022\"\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'ON'\n CXX_STANDARD: 20\n - GENERATOR: \"Visual Studio 17 2022\"\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'ON'\n WCHAR_FILES: 'ON'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'ON'\n CXX_STANDARD: 20\n - GENERATOR: \"Visual Studio 17 2022\"\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'ON'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 17\n\n steps:\n - name: Checkout code\n uses: actions/checkout@v4\n\n - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}\n shell: pwsh\n run: |\n mkdir build\n cd build\n cmake -G \"${{ matrix.config.GENERATOR }}\" -A x64 `\n -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `\n -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `\n -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `\n -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `\n -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `\n -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `\n -D SPDLOG_BUILD_TESTS=ON `\n -D SPDLOG_BUILD_TESTS_HO=OFF `\n -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `\n -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `\n -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..\n\n - name: Build\n shell: pwsh\n run: |\n cd build\n cmake --build . --parallel --config ${{ matrix.config.BUILD_TYPE }}\n\n - name: Run Tests\n shell: pwsh\n env:\n PATH: ${{ env.PATH }};${{ github.workspace }}\\build\\_deps\\catch2-build\\src\\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\\build\\${{ matrix.config.BUILD_TYPE }}\n run: |\n build\\tests\\${{ matrix.config.BUILD_TYPE }}\\spdlog-utests.exe\n\n\n \n" }, { "path": ".gitignore", "content": "# Auto generated files\r\n[Dd]ebug/\r\n[Rr]elease/\r\nbuild/*\r\n*.slo\r\n*.lo\r\n*.o\r\n*.obj\r\n*.suo\r\n*.tlog\r\n*.ilk\r\n*.log\r\n*.pdb\r\n*.idb\r\n*.iobj\r\n*.ipdb\r\n*.opensdf\r\n*.sdf\r\n\r\n# Compiled Dynamic libraries\r\n*.so\r\n*.dylib\r\n*.dll\r\n\r\n# Compiled Static libraries\r\n*.lai\r\n*.la\r\n*.a\r\n*.lib\r\n\r\n# Executables\r\n*.exe\r\n*.out\r\n*.app\r\n\r\n# Codelite\r\n.codelite\r\n\r\n# KDevelop\r\n*.kdev4\r\n\r\n# .orig files\r\n*.orig\r\n\r\n# example files\r\nexample/*\r\n!example/example.cpp\r\n!example/bench.cpp\r\n!example/utils.h\r\n!example/Makefile*\r\n!example/example.sln\r\n!example/example.vcxproj\r\n!example/CMakeLists.txt\r\n!example/meson.build\r\n!example/multisink.cpp\r\n!example/jni\r\n\r\n# generated files\r\ngenerated\r\nversion.rc\r\n\r\n# Cmake\r\nCMakeCache.txt\r\nCMakeFiles\r\nCMakeScripts\r\nMakefile\r\ncmake_install.cmake\r\ninstall_manifest.txt\r\n/tests/tests.VC.VC.opendb\r\n/tests/tests.VC.db\r\n/tests/tests\r\n/tests/logs/*\r\nspdlogConfig.cmake\r\nspdlogConfigVersion.cmake\r\ncompile_commands.json\r\n\r\n# idea\r\n.idea/\r\n.cache/\r\n.vscode/\r\ncmake-build-*/\r\n*.db\r\n*.ipch\r\n*.filters\r\n*.db-wal\r\n*.opendb\r\n*.db-shm\r\n*.vcxproj\r\n*.tcl\r\n*.user\r\n*.sln\r\n\r\n# macos\r\n*.DS_store\r\n*.xcodeproj/\r\n/.vs\r\n/out/build\r\n/CMakeSettings.json\r\n" }, { "path": "CMakeLists.txt", "content": "# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\ncmake_minimum_required(VERSION 3.10...3.21)\n\n# ---------------------------------------------------------------------------------------\n# Start spdlog project\n# ---------------------------------------------------------------------------------------\ninclude(cmake/utils.cmake)\ninclude(cmake/ide.cmake)\n\nspdlog_extract_version()\n\nproject(spdlog VERSION ${SPDLOG_VERSION} LANGUAGES CXX)\nmessage(STATUS \"Build spdlog: ${SPDLOG_VERSION}\")\n\ninclude(GNUInstallDirs)\n\n# ---------------------------------------------------------------------------------------\n# Set default build to release\n# ---------------------------------------------------------------------------------------\nif(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)\n # Set CMAKE_BUILD_TYPE only if this project is top-level\n if((DEFINED PROJECT_IS_TOP_LEVEL AND PROJECT_IS_TOP_LEVEL) OR (NOT DEFINED PROJECT_IS_TOP_LEVEL\n AND CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR))\n set(CMAKE_BUILD_TYPE \"Release\" CACHE STRING \"Choose Release or Debug\" FORCE)\n endif()\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Compiler config\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_USE_STD_FORMAT)\n set(CMAKE_CXX_STANDARD 20)\n set(CMAKE_CXX_STANDARD_REQUIRED ON)\nelseif(NOT CMAKE_CXX_STANDARD)\n set(CMAKE_CXX_STANDARD 11)\n set(CMAKE_CXX_STANDARD_REQUIRED ON)\nendif()\n\nset(CMAKE_CXX_EXTENSIONS OFF)\n\nif(CMAKE_SYSTEM_NAME MATCHES \"CYGWIN\" OR CMAKE_SYSTEM_NAME MATCHES \"MSYS\" OR CMAKE_SYSTEM_NAME MATCHES \"MINGW\")\n set(CMAKE_CXX_EXTENSIONS ON)\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog\n# ---------------------------------------------------------------------------------------\n# Check if spdlog is being used directly or via add_subdirectory, but allow overriding\nif(NOT DEFINED SPDLOG_MASTER_PROJECT)\n if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)\n set(SPDLOG_MASTER_PROJECT ON)\n else()\n set(SPDLOG_MASTER_PROJECT OFF)\n endif()\nendif()\n\noption(SPDLOG_BUILD_ALL \"Build all artifacts\" OFF)\n\n# build shared option\noption(SPDLOG_BUILD_SHARED \"Build shared library\" OFF)\n\n# precompiled headers option\noption(SPDLOG_ENABLE_PCH \"Build static or shared library using precompiled header to speed up compilation time\" OFF)\n\n# build position independent code\noption(SPDLOG_BUILD_PIC \"Build position independent code (-fPIC)\" OFF)\n\n# debug build postfix\nset(SPDLOG_DEBUG_POSTFIX \"d\" CACHE STRING \"Filename postfix for libraries in debug builds\")\n\n# example options\noption(SPDLOG_BUILD_EXAMPLE \"Build example\" ${SPDLOG_MASTER_PROJECT})\noption(SPDLOG_BUILD_EXAMPLE_HO \"Build header only example\" OFF)\n\n# testing options\noption(SPDLOG_BUILD_TESTS \"Build tests\" OFF)\noption(SPDLOG_BUILD_TESTS_HO \"Build tests using the header only version\" OFF)\n\n# bench options\noption(SPDLOG_BUILD_BENCH \"Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)\" OFF)\n\n# sanitizer options\noption(SPDLOG_SANITIZE_ADDRESS \"Enable address sanitizer in tests\" OFF)\noption(SPDLOG_SANITIZE_THREAD \"Enable thread sanitizer in tests\" OFF)\nif(SPDLOG_SANITIZE_ADDRESS AND SPDLOG_SANITIZE_THREAD)\n message(FATAL_ERROR \"SPDLOG_SANITIZE_ADDRESS and SPDLOG_SANITIZE_THREAD are mutually exclusive\")\nendif()\n\n# warning options\noption(SPDLOG_BUILD_WARNINGS \"Enable compiler warnings\" OFF)\n\n# install options\noption(SPDLOG_SYSTEM_INCLUDES \"Include as system headers (skip for clang-tidy).\" OFF)\noption(SPDLOG_INSTALL \"Generate the install target\" ${SPDLOG_MASTER_PROJECT})\noption(SPDLOG_USE_STD_FORMAT \"Use std::format instead of fmt library.\" OFF)\noption(SPDLOG_FMT_EXTERNAL \"Use external fmt library instead of bundled\" OFF)\noption(SPDLOG_FMT_EXTERNAL_HO \"Use external fmt header-only library instead of bundled\" OFF)\noption(SPDLOG_NO_EXCEPTIONS \"Compile with -fno-exceptions. Call abort() on any spdlog exceptions\" OFF)\noption(SPDLOG_NO_TZ_OFFSET \"Omit %z timezone offset (use on platforms without tm_gmtoff)\" OFF)\n\nif(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)\n message(FATAL_ERROR \"SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive\")\nendif()\n\nif(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)\n message(FATAL_ERROR \"SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive\")\nendif()\n\nif(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)\n message(FATAL_ERROR \"SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive\")\nendif()\n\n# misc tweakme options\nif(WIN32)\n option(SPDLOG_WCHAR_SUPPORT \"Support wchar api\" OFF)\n option(SPDLOG_WCHAR_FILENAMES \"Support wchar filenames\" OFF)\n option(SPDLOG_WCHAR_CONSOLE \"Support wchar output to console\" OFF)\nelse()\n set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL \"non supported option\" FORCE)\n set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL \"non supported option\" FORCE)\n set(SPDLOG_WCHAR_CONSOLE OFF CACHE BOOL \"non supported option\" FORCE)\nendif()\n\nif(MSVC)\n option(SPDLOG_MSVC_UTF8 \"Enable/disable msvc /utf-8 flag required by fmt lib\" ON)\nendif()\n\nif(${CMAKE_SYSTEM_NAME} STREQUAL \"Linux\")\n option(SPDLOG_CLOCK_COARSE \"Use CLOCK_REALTIME_COARSE instead of the regular clock,\" OFF)\nelse()\n set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL \"non supported option\" FORCE)\nendif()\n\noption(SPDLOG_PREVENT_CHILD_FD \"Prevent from child processes to inherit log file descriptors\" OFF)\noption(SPDLOG_NO_THREAD_ID \"prevent spdlog from querying the thread id on each log call if thread id is not needed\" OFF)\noption(SPDLOG_NO_TLS \"prevent spdlog from using thread local storage\" OFF)\noption(\n SPDLOG_NO_ATOMIC_LEVELS\n \"prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently\"\n OFF)\noption(SPDLOG_DISABLE_DEFAULT_LOGGER \"Disable default logger creation\" OFF)\noption(SPDLOG_FWRITE_UNLOCKED \"Use the unlocked variant of fwrite. Leave this on unless your libc doesn't have it\" ON)\n\n# clang-tidy\noption(SPDLOG_TIDY \"run clang-tidy\" OFF)\n\nif(SPDLOG_TIDY)\n set(CMAKE_CXX_CLANG_TIDY \"clang-tidy\")\n set(CMAKE_EXPORT_COMPILE_COMMANDS ON)\n message(STATUS \"Enabled clang-tidy\")\nendif()\n\nif(SPDLOG_BUILD_PIC)\n set(CMAKE_POSITION_INDEPENDENT_CODE ON)\nendif()\n\nfind_package(Threads REQUIRED)\nmessage(STATUS \"Build type: \" ${CMAKE_BUILD_TYPE})\n# ---------------------------------------------------------------------------------------\n# Static/Shared library\n# ---------------------------------------------------------------------------------------\nset(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)\n\nif(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)\n list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)\nendif()\n\nif(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)\n if(WIN32)\n configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)\n list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)\n endif()\n add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})\n target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)\n if(CMAKE_CXX_COMPILER_ID STREQUAL \"MSVC\")\n target_compile_options(spdlog PUBLIC $<$,$>>:/wd4251\n /wd4275>)\n endif()\n if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)\n target_compile_definitions(spdlog PRIVATE FMT_LIB_EXPORT PUBLIC FMT_SHARED)\n endif()\nelse()\n add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})\nendif()\n\nadd_library(spdlog::spdlog ALIAS spdlog)\n\nset(SPDLOG_INCLUDES_LEVEL \"\")\nif(SPDLOG_SYSTEM_INCLUDES)\n set(SPDLOG_INCLUDES_LEVEL \"SYSTEM\")\nendif()\n\ntarget_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)\ntarget_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC \"$\"\n \"$\")\ntarget_link_libraries(spdlog PUBLIC Threads::Threads)\nspdlog_enable_warnings(spdlog)\n\nset_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION\n ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})\nset_target_properties(spdlog PROPERTIES DEBUG_POSTFIX \"${SPDLOG_DEBUG_POSTFIX}\")\n\nif(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)\n configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)\n target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)\nendif()\n\n# sanitizer support\nif(SPDLOG_SANITIZE_ADDRESS)\n spdlog_enable_addr_sanitizer(spdlog)\nelseif(SPDLOG_SANITIZE_THREAD)\n spdlog_enable_thread_sanitizer(spdlog)\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Header only version\n# ---------------------------------------------------------------------------------------\nadd_library(spdlog_header_only INTERFACE)\nadd_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)\n\ntarget_include_directories(\n spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE \"$\"\n \"$\")\ntarget_link_libraries(spdlog_header_only INTERFACE Threads::Threads)\n\n# ---------------------------------------------------------------------------------------\n# Use fmt package if using external fmt\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)\n if(NOT TARGET fmt::fmt)\n find_package(fmt CONFIG REQUIRED)\n endif()\n target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)\n target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)\n\n # use external fmt-header-only\n if(SPDLOG_FMT_EXTERNAL_HO)\n target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)\n target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)\n else() # use external compile fmt\n target_link_libraries(spdlog PUBLIC fmt::fmt)\n target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)\n endif()\n\n set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Check if fwrite_unlocked/_fwrite_nolock is available\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_FWRITE_UNLOCKED)\n include(CheckSymbolExists)\n if(WIN32)\n check_symbol_exists(_fwrite_nolock \"stdio.h\" HAVE_FWRITE_UNLOCKED)\n else()\n check_symbol_exists(fwrite_unlocked \"stdio.h\" HAVE_FWRITE_UNLOCKED)\n endif()\n if(HAVE_FWRITE_UNLOCKED)\n target_compile_definitions(spdlog PRIVATE SPDLOG_FWRITE_UNLOCKED)\n target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FWRITE_UNLOCKED)\n endif()\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Add required libraries for Android CMake build\n# ---------------------------------------------------------------------------------------\nif(ANDROID)\n target_link_libraries(spdlog PUBLIC log)\n target_link_libraries(spdlog_header_only INTERFACE log)\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Misc definitions according to tweak options\n# ---------------------------------------------------------------------------------------\nset(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})\nset(SPDLOG_UTF8_TO_WCHAR_CONSOLE ${SPDLOG_WCHAR_CONSOLE})\nforeach(\n SPDLOG_OPTION\n SPDLOG_WCHAR_TO_UTF8_SUPPORT\n SPDLOG_UTF8_TO_WCHAR_CONSOLE\n SPDLOG_WCHAR_FILENAMES\n SPDLOG_NO_EXCEPTIONS\n SPDLOG_CLOCK_COARSE\n SPDLOG_PREVENT_CHILD_FD\n SPDLOG_NO_THREAD_ID\n SPDLOG_NO_TLS\n SPDLOG_NO_ATOMIC_LEVELS\n SPDLOG_DISABLE_DEFAULT_LOGGER\n SPDLOG_USE_STD_FORMAT\n SPDLOG_NO_TZ_OFFSET)\n if(${SPDLOG_OPTION})\n target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})\n target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})\n endif()\nendforeach()\n\nif(MSVC)\n target_compile_options(spdlog PRIVATE \"/Zc:__cplusplus\")\n target_compile_options(spdlog_header_only INTERFACE \"/Zc:__cplusplus\")\n if(SPDLOG_MSVC_UTF8)\n # fmtlib requires the /utf-8 flag when building with msvc. see https://github.com/fmtlib/fmt/pull/4159 on the\n # purpose of the additional\n # \"$<$,$>\"\n target_compile_options(spdlog PUBLIC $<$,$>:/utf-8>)\n target_compile_options(spdlog_header_only\n INTERFACE $<$,$>:/utf-8>)\n endif()\nendif()\n\n# ---------------------------------------------------------------------------------------\n# If exceptions are disabled, disable them in the bundled fmt as well\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_NO_EXCEPTIONS)\n if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)\n target_compile_definitions(spdlog PUBLIC FMT_USE_EXCEPTIONS=0)\n endif()\n if(NOT MSVC)\n target_compile_options(spdlog PRIVATE -fno-exceptions)\n else()\n target_compile_options(spdlog PRIVATE /EHs-c-)\n target_compile_definitions(spdlog PRIVATE _HAS_EXCEPTIONS=0)\n endif()\nendif()\n# ---------------------------------------------------------------------------------------\n# Build binaries\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)\n message(STATUS \"Generating example(s)\")\n add_subdirectory(example)\n spdlog_enable_warnings(example)\n if(SPDLOG_BUILD_EXAMPLE_HO)\n spdlog_enable_warnings(example_header_only)\n endif()\nendif()\n\nif(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)\n message(STATUS \"Generating tests\")\n enable_testing()\n add_subdirectory(tests)\nendif()\n\nif(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)\n message(STATUS \"Generating benchmarks\")\n add_subdirectory(bench)\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Install\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_INSTALL)\n message(STATUS \"Generating install\")\n set(project_config_in \"${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in\")\n set(project_config_out \"${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake\")\n set(config_targets_file \"spdlogConfigTargets.cmake\")\n set(version_config_file \"${CMAKE_CURRENT_BINARY_DIR}/spdlogConfigVersion.cmake\")\n set(export_dest_dir \"${CMAKE_INSTALL_LIBDIR}/cmake/spdlog\")\n set(pkgconfig_install_dir \"${CMAKE_INSTALL_LIBDIR}/pkgconfig\")\n set(pkg_config \"${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc\")\n\n # ---------------------------------------------------------------------------------------\n # Include files\n # ---------------------------------------------------------------------------------------\n install(DIRECTORY include/ DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}\" PATTERN \"fmt/bundled\" EXCLUDE)\n install(\n TARGETS spdlog spdlog_header_only\n EXPORT spdlog\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})\n\n if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)\n install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/\n DESTINATION \"${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/\")\n endif()\n\n # ---------------------------------------------------------------------------------------\n # Install pkg-config file\n # ---------------------------------------------------------------------------------------\n if(IS_ABSOLUTE \"${CMAKE_INSTALL_INCLUDEDIR}\")\n set(PKG_CONFIG_INCLUDEDIR \"${CMAKE_INSTALL_INCLUDEDIR}\")\n else()\n set(PKG_CONFIG_INCLUDEDIR \"\\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}\")\n endif()\n if(IS_ABSOLUTE \"${CMAKE_INSTALL_LIBDIR}\")\n set(PKG_CONFIG_LIBDIR \"${CMAKE_INSTALL_LIBDIR}\")\n else()\n set(PKG_CONFIG_LIBDIR \"\\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}\")\n endif()\n get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)\n string(REPLACE \";\" \" -D\" PKG_CONFIG_DEFINES \"${PKG_CONFIG_DEFINES}\")\n string(CONCAT PKG_CONFIG_DEFINES \"-D\" \"${PKG_CONFIG_DEFINES}\")\n configure_file(\"cmake/${PROJECT_NAME}.pc.in\" \"${pkg_config}\" @ONLY)\n install(FILES \"${pkg_config}\" DESTINATION \"${pkgconfig_install_dir}\")\n\n # ---------------------------------------------------------------------------------------\n # Install CMake config files\n # ---------------------------------------------------------------------------------------\n export(TARGETS spdlog spdlog_header_only NAMESPACE spdlog::\n FILE \"${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}\")\n install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})\n\n include(CMakePackageConfigHelpers)\n configure_package_config_file(\"${project_config_in}\" \"${project_config_out}\" INSTALL_DESTINATION ${export_dest_dir})\n\n write_basic_package_version_file(\"${version_config_file}\" COMPATIBILITY SameMajorVersion)\n install(FILES \"${project_config_out}\" \"${version_config_file}\" DESTINATION \"${export_dest_dir}\")\n\n # ---------------------------------------------------------------------------------------\n # Support creation of installable packages\n # ---------------------------------------------------------------------------------------\n include(cmake/spdlogCPack.cmake)\nendif()\n" }, { "path": "INSTALL", "content": "Header Only Version\r\n==================================================================\r\nJust copy the files to your build tree and use a C++11 compiler. \r\nOr use CMake:\r\n``` \r\n add_executable(example_header_only example.cpp)\r\n target_link_libraries(example_header_only spdlog::spdlog_header_only)\r\n```\r\n\r\nCompiled Library Version\r\n==================================================================\r\nCMake:\r\n``` \r\n add_executable(example example.cpp)\r\n target_link_libraries(example spdlog::spdlog)\r\n```\r\n\r\nOr copy files src/*.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.\r\n\r\nImportant Information for Compilation:\r\n==================================================================\r\n* 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\r\n\r\nTested on: \r\ngcc 4.8.1 and above\r\nclang 3.5\r\nVisual Studio 2013" }, { "path": "LICENSE", "content": "The MIT License (MIT)\n\nCopyright (c) 2016 - present, Gabi Melman and spdlog contributors.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n-- NOTE: Third party dependency used by this software --\nThis software depends on the fmt lib (MIT License),\nand users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE\n" }, { "path": "README.md", "content": "# spdlog\r\n\r\n \r\n[![ci](https://github.com/gabime/spdlog/actions/workflows/linux.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/linux.yml) \r\n[![ci](https://github.com/gabime/spdlog/actions/workflows/windows.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/windows.yml) \r\n[![ci](https://github.com/gabime/spdlog/actions/workflows/macos.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/macos.yml) \r\n[![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)\r\n\r\nFast C++ logging library\r\n\r\n\r\n## Install\r\n#### Header-only version\r\nCopy the include [folder](include/spdlog) to your build tree and use a C++11 compiler.\r\n\r\n#### Compiled version (recommended - much faster compile times)\r\n```console\r\n$ git clone https://github.com/gabime/spdlog.git\r\n$ cd spdlog && mkdir build && cd build\r\n$ cmake .. && cmake --build .\r\n```\r\nsee example [CMakeLists.txt](example/CMakeLists.txt) on how to use.\r\n\r\n## Platforms\r\n* Linux, FreeBSD, OpenBSD, Solaris, AIX\r\n* Windows (msvc 2013+, cygwin)\r\n* macOS (clang 3.5+)\r\n* Android\r\n\r\n## Package managers:\r\n* Debian: `sudo apt install libspdlog-dev`\r\n* Homebrew: `brew install spdlog`\r\n* MacPorts: `sudo port install spdlog`\r\n* FreeBSD: `pkg install spdlog`\r\n* Fedora: `dnf install spdlog`\r\n* Gentoo: `emerge dev-libs/spdlog`\r\n* Arch Linux: `pacman -S spdlog`\r\n* openSUSE: `sudo zypper in spdlog-devel`\r\n* ALT Linux: `apt-get install libspdlog-devel`\r\n* vcpkg: `vcpkg install spdlog`\r\n* conan: `conan install --requires=spdlog/[*]`\r\n* conda: `conda install -c conda-forge spdlog`\r\n* build2: ```depends: spdlog ^1.8.2```\r\n\r\n\r\n## Features\r\n* Very fast (see [benchmarks](#benchmarks) below).\r\n* Headers only or compiled\r\n* Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.\r\n* Asynchronous mode (optional)\r\n* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.\r\n* Multi/Single threaded loggers.\r\n* Various log targets:\r\n * Rotating log files.\r\n * Daily log files.\r\n * Console logging (colors supported).\r\n * syslog.\r\n * Windows event log.\r\n * Windows debugger (```OutputDebugString(..)```).\r\n * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).\r\n * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets.\r\n* Log filtering - log levels can be modified at runtime as well as compile time.\r\n* Support for loading log levels from argv or environment var.\r\n* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.\r\n\r\n## Usage samples\r\n\r\n#### Basic usage\r\n```c++\r\n#include \"spdlog/spdlog.h\"\r\n\r\nint main() \r\n{\r\n spdlog::info(\"Welcome to spdlog!\");\r\n spdlog::error(\"Some error message with arg: {}\", 1);\r\n \r\n spdlog::warn(\"Easy padding in numbers like {:08d}\", 12);\r\n spdlog::critical(\"Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}\", 42);\r\n spdlog::info(\"Support for floats {:03.2f}\", 1.23456);\r\n spdlog::info(\"Positional args are {1} {0}..\", \"too\", \"supported\");\r\n spdlog::info(\"{:<30}\", \"left aligned\");\r\n \r\n spdlog::set_level(spdlog::level::debug); // Set *global* log level to debug\r\n spdlog::debug(\"This message should be displayed..\"); \r\n \r\n // change log pattern\r\n spdlog::set_pattern(\"[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v\");\r\n \r\n // Compile time log levels\r\n // Note that this does not change the current log level, it will only\r\n // remove (depending on SPDLOG_ACTIVE_LEVEL) the call on the release code.\r\n SPDLOG_TRACE(\"Some trace message with param {}\", 42);\r\n SPDLOG_DEBUG(\"Some debug message\");\r\n}\r\n\r\n```\r\n---\r\n#### Create stdout/stderr logger object\r\n```c++\r\n#include \"spdlog/spdlog.h\"\r\n#include \"spdlog/sinks/stdout_color_sinks.h\"\r\nvoid stdout_example()\r\n{\r\n // create a color multi-threaded logger\r\n auto console = spdlog::stdout_color_mt(\"console\"); \r\n auto err_logger = spdlog::stderr_color_mt(\"stderr\"); \r\n spdlog::get(\"console\")->info(\"loggers can be retrieved from a global registry using the spdlog::get(logger_name)\");\r\n}\r\n```\r\n\r\n---\r\n#### Basic file logger\r\n```c++\r\n#include \"spdlog/sinks/basic_file_sink.h\"\r\nvoid basic_logfile_example()\r\n{\r\n try \r\n {\r\n auto logger = spdlog::basic_logger_mt(\"basic_logger\", \"logs/basic-log.txt\");\r\n }\r\n catch (const spdlog::spdlog_ex &ex)\r\n {\r\n std::cout << \"Log init failed: \" << ex.what() << std::endl;\r\n }\r\n}\r\n```\r\n---\r\n#### Rotating files\r\n```c++\r\n#include \"spdlog/sinks/rotating_file_sink.h\"\r\nvoid rotating_example()\r\n{\r\n // Create a file rotating logger with 5 MB size max and 3 rotated files\r\n auto max_size = 1048576 * 5;\r\n auto max_files = 3;\r\n auto logger = spdlog::rotating_logger_mt(\"some_logger_name\", \"logs/rotating.txt\", max_size, max_files);\r\n}\r\n```\r\n\r\n---\r\n#### Daily files\r\n```c++\r\n\r\n#include \"spdlog/sinks/daily_file_sink.h\"\r\nvoid daily_example()\r\n{\r\n // Create a daily logger - a new file is created every day at 2:30 am\r\n auto logger = spdlog::daily_logger_mt(\"daily_logger\", \"logs/daily.txt\", 2, 30);\r\n}\r\n\r\n```\r\n\r\n---\r\n#### Backtrace support\r\n```c++\r\n// Debug messages can be stored in a ring buffer instead of being logged immediately.\r\n// This is useful to display debug logs only when needed (e.g. when an error happens).\r\n// When needed, call dump_backtrace() to dump them to your log.\r\n\r\nspdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. \r\n// or my_logger->enable_backtrace(32)..\r\nfor(int i = 0; i < 100; i++)\r\n{\r\n spdlog::debug(\"Backtrace message {}\", i); // not logged yet..\r\n}\r\n// e.g. if some error happened:\r\nspdlog::dump_backtrace(); // log them now! show the last 32 messages\r\n// or my_logger->dump_backtrace(32)..\r\n```\r\n\r\n---\r\n#### Periodic flush\r\n```c++\r\n// periodically flush all *registered* loggers every 3 seconds:\r\n// warning: only use if all your loggers are thread-safe (\"_mt\" loggers)\r\nspdlog::flush_every(std::chrono::seconds(3));\r\n\r\n```\r\n\r\n---\r\n#### Stopwatch\r\n```c++\r\n// Stopwatch support for spdlog\r\n#include \"spdlog/stopwatch.h\"\r\nvoid stopwatch_example()\r\n{\r\n spdlog::stopwatch sw; \r\n spdlog::debug(\"Elapsed {}\", sw);\r\n spdlog::debug(\"Elapsed {:.3}\", sw); \r\n}\r\n\r\n```\r\n\r\n---\r\n#### Log binary data in hex\r\n```c++\r\n// many types of std::container types can be used.\r\n// ranges are supported too.\r\n// format flags:\r\n// {:X} - print in uppercase.\r\n// {:s} - don't separate each byte with space.\r\n// {:p} - don't print the position on each line start.\r\n// {:n} - don't split the output into lines.\r\n// {:a} - show ASCII if :n is not set.\r\n\r\n#include \"spdlog/fmt/bin_to_hex.h\"\r\n\r\nvoid binary_example()\r\n{\r\n auto console = spdlog::get(\"console\");\r\n std::array buf;\r\n console->info(\"Binary example: {}\", spdlog::to_hex(buf));\r\n console->info(\"Another binary example:{:n}\", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));\r\n // more examples:\r\n // logger->info(\"uppercase: {:X}\", spdlog::to_hex(buf));\r\n // logger->info(\"uppercase, no delimiters: {:Xs}\", spdlog::to_hex(buf));\r\n // logger->info(\"uppercase, no delimiters, no position info: {:Xsp}\", spdlog::to_hex(buf));\r\n}\r\n\r\n```\r\n\r\n---\r\n#### Logger with multi sinks - each with a different format and log level\r\n```c++\r\n\r\n// create a logger with 2 targets, with different log levels and formats.\r\n// The console will show only warnings or errors, while the file will log all. \r\nvoid multi_sink_example()\r\n{\r\n auto console_sink = std::make_shared();\r\n console_sink->set_level(spdlog::level::warn);\r\n console_sink->set_pattern(\"[multi_sink_example] [%^%l%$] %v\");\r\n\r\n auto file_sink = std::make_shared(\"logs/multisink.txt\", true);\r\n file_sink->set_level(spdlog::level::trace);\r\n\r\n spdlog::logger logger(\"multi_sink\", {console_sink, file_sink});\r\n logger.set_level(spdlog::level::debug);\r\n logger.warn(\"this should appear in both console and file\");\r\n logger.info(\"this message should not appear in the console, only in the file\");\r\n}\r\n```\r\n\r\n---\r\n#### Register several loggers - change global level\r\n```c++\r\n\r\n// Creation of loggers. Set levels to all registered loggers. \r\nvoid set_level_example()\r\n{\r\n auto logger1 = spdlog::basic_logger_mt(\"logger1\", \"logs/logger1.txt\");\r\n auto logger2 = spdlog::basic_logger_mt(\"logger2\", \"logs/logger2.txt\");\r\n\r\n spdlog::set_default_logger(logger2);\r\n spdlog::default_logger()->set_level(spdlog::level::trace); // set level for the default logger (logger2) to trace\r\n\r\n spdlog::trace(\"trace message to the logger2 (specified as default)\");\r\n\r\n spdlog::set_level(spdlog::level::off) // (sic!) set level for *all* registered loggers to off (disable)\r\n \r\n logger1.warn(\"warn message will not appear because the level set to off\");\r\n logger2.warn(\"warn message will not appear because the level set to off\");\r\n spdlog::warn(\"warn message will not appear because the level set to off\");\r\n}\r\n```\r\n\r\n---\r\n#### User-defined callbacks about log events\r\n```c++\r\n\r\n// create a logger with a lambda function callback, the callback will be called\r\n// each time something is logged to the logger\r\nvoid callback_example()\r\n{\r\n auto callback_sink = std::make_shared([](const spdlog::details::log_msg &msg) {\r\n // for example you can be notified by sending an email to yourself\r\n });\r\n callback_sink->set_level(spdlog::level::err);\r\n\r\n auto console_sink = std::make_shared();\r\n spdlog::logger logger(\"custom_callback_logger\", {console_sink, callback_sink});\r\n\r\n logger.info(\"some info log\");\r\n logger.error(\"critical issue\"); // will notify you\r\n}\r\n```\r\n\r\n---\r\n#### Asynchronous logging\r\n```c++\r\n#include \"spdlog/async.h\"\r\n#include \"spdlog/sinks/basic_file_sink.h\"\r\nvoid async_example()\r\n{\r\n // default thread pool settings can be modified *before* creating the async logger:\r\n // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.\r\n auto async_file = spdlog::basic_logger_mt(\"async_file_logger\", \"logs/async_log.txt\");\r\n // alternatively:\r\n // auto async_file = spdlog::create_async(\"async_file_logger\", \"logs/async_log.txt\"); \r\n}\r\n\r\n```\r\n\r\n---\r\n#### Asynchronous logger with multi sinks\r\n```c++\r\n#include \"spdlog/async.h\"\r\n#include \"spdlog/sinks/stdout_color_sinks.h\"\r\n#include \"spdlog/sinks/rotating_file_sink.h\"\r\n\r\nvoid multi_sink_example2()\r\n{\r\n spdlog::init_thread_pool(8192, 1);\r\n auto stdout_sink = std::make_shared();\r\n auto rotating_sink = std::make_shared(\"mylog.txt\", 1024*1024*10, 3);\r\n std::vector sinks {stdout_sink, rotating_sink};\r\n auto logger = std::make_shared(\"loggername\", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block);\r\n spdlog::register_logger(logger);\r\n}\r\n```\r\n \r\n---\r\n#### User-defined types\r\n```c++\r\ntemplate<>\r\nstruct fmt::formatter : fmt::formatter\r\n{\r\n auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())\r\n {\r\n return fmt::format_to(ctx.out(), \"[my_type i={}]\", my.i);\r\n }\r\n};\r\n\r\nvoid user_defined_example()\r\n{\r\n spdlog::info(\"user defined type: {}\", my_type(14));\r\n}\r\n\r\n```\r\n\r\n---\r\n#### User-defined flags in the log pattern\r\n```c++ \r\n// Log patterns can contain custom flags.\r\n// the following example will add new flag '%*' - which will be bound to a instance.\r\n#include \"spdlog/pattern_formatter.h\"\r\nclass my_formatter_flag : public spdlog::custom_flag_formatter\r\n{\r\npublic:\r\n void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override\r\n {\r\n std::string some_txt = \"custom-flag\";\r\n dest.append(some_txt.data(), some_txt.data() + some_txt.size());\r\n }\r\n\r\n std::unique_ptr clone() const override\r\n {\r\n return spdlog::details::make_unique();\r\n }\r\n};\r\n\r\nvoid custom_flags_example()\r\n{ \r\n auto formatter = std::make_unique();\r\n formatter->add_flag('*').set_pattern(\"[%n] [%*] [%^%l%$] %v\");\r\n spdlog::set_formatter(std::move(formatter));\r\n}\r\n\r\n```\r\n\r\n---\r\n#### Custom error handler\r\n```c++\r\nvoid err_handler_example()\r\n{\r\n // can be set globally or per logger(logger->set_error_handler(..))\r\n spdlog::set_error_handler([](const std::string &msg) { spdlog::get(\"console\")->error(\"*** LOGGER ERROR ***: {}\", msg); });\r\n spdlog::get(\"console\")->info(\"some invalid message to trigger an error {}{}{}{}\", 3);\r\n}\r\n\r\n```\r\n\r\n---\r\n#### syslog\r\n```c++\r\n#include \"spdlog/sinks/syslog_sink.h\"\r\nvoid syslog_example()\r\n{\r\n std::string ident = \"spdlog-example\";\r\n auto syslog_logger = spdlog::syslog_logger_mt(\"syslog\", ident, LOG_PID);\r\n syslog_logger->warn(\"This is warning that will end up in syslog.\");\r\n}\r\n```\r\n---\r\n#### Android example\r\n```c++\r\n#include \"spdlog/sinks/android_sink.h\"\r\nvoid android_example()\r\n{\r\n std::string tag = \"spdlog-android\";\r\n auto android_logger = spdlog::android_logger_mt(\"android\", tag);\r\n android_logger->critical(\"Use \\\"adb shell logcat\\\" to view this message.\");\r\n}\r\n```\r\n\r\n---\r\n#### Load log levels from the env variable or argv\r\n\r\n```c++\r\n#include \"spdlog/cfg/env.h\"\r\nint main (int argc, char *argv[])\r\n{\r\n spdlog::cfg::load_env_levels();\r\n // or specify the env variable name:\r\n // MYAPP_LEVEL=info,mylogger=trace && ./example\r\n // spdlog::cfg::load_env_levels(\"MYAPP_LEVEL\");\r\n // or from the command line:\r\n // ./example SPDLOG_LEVEL=info,mylogger=trace\r\n // #include \"spdlog/cfg/argv.h\" // for loading levels from argv\r\n // spdlog::cfg::load_argv_levels(argc, argv);\r\n}\r\n```\r\nSo then you can:\r\n\r\n```console\r\n$ export SPDLOG_LEVEL=info,mylogger=trace\r\n$ ./example\r\n```\r\n\r\n\r\n---\r\n#### Log file open/close event handlers\r\n```c++\r\n// You can get callbacks from spdlog before/after a log file has been opened or closed. \r\n// This is useful for cleanup procedures or for adding something to the start/end of the log file.\r\nvoid file_events_example()\r\n{\r\n // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications\r\n spdlog::file_event_handlers handlers;\r\n handlers.before_open = [](spdlog::filename_t filename) { spdlog::info(\"Before opening {}\", filename); };\r\n handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) { fputs(\"After opening\\n\", fstream); };\r\n handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) { fputs(\"Before closing\\n\", fstream); };\r\n handlers.after_close = [](spdlog::filename_t filename) { spdlog::info(\"After closing {}\", filename); };\r\n auto my_logger = spdlog::basic_logger_st(\"some_logger\", \"logs/events-sample.txt\", true, handlers); \r\n}\r\n```\r\n\r\n---\r\n#### Replace the Default Logger\r\n```c++\r\nvoid replace_default_logger_example()\r\n{\r\n auto new_logger = spdlog::basic_logger_mt(\"new_default_logger\", \"logs/new-default-log.txt\", true);\r\n spdlog::set_default_logger(new_logger);\r\n spdlog::info(\"new logger log message\");\r\n}\r\n```\r\n\r\n---\r\n#### Log to Qt with nice colors\r\n```c++\r\n#include \"spdlog/spdlog.h\"\r\n#include \"spdlog/sinks/qt_sinks.h\"\r\nMainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)\r\n{\r\n setMinimumSize(640, 480);\r\n auto log_widget = new QTextEdit(this);\r\n setCentralWidget(log_widget);\r\n int max_lines = 500; // keep the text widget to max 500 lines. remove old lines if needed.\r\n auto logger = spdlog::qt_color_logger_mt(\"qt_logger\", log_widget, max_lines);\r\n logger->info(\"Some info message\");\r\n}\r\n```\r\n---\r\n\r\n#### Mapped Diagnostic Context\r\n```c++\r\n// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage.\r\n// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs.\r\n// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage.\r\n#include \"spdlog/mdc.h\"\r\nvoid mdc_example()\r\n{\r\n spdlog::mdc::put(\"key1\", \"value1\");\r\n spdlog::mdc::put(\"key2\", \"value2\");\r\n // if not using the default format, use the %& formatter to print mdc data\r\n // spdlog::set_pattern(\"[%H:%M:%S %z] [%^%L%$] [%&] %v\");\r\n}\r\n```\r\n---\r\n## Benchmarks\r\n\r\nBelow are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz\r\n\r\n#### Synchronous mode\r\n```\r\n[info] **************************************************************\r\n[info] Single thread, 1,000,000 iterations\r\n[info] **************************************************************\r\n[info] basic_st Elapsed: 0.17 secs 5,777,626/sec\r\n[info] rotating_st Elapsed: 0.18 secs 5,475,894/sec\r\n[info] daily_st Elapsed: 0.20 secs 5,062,659/sec\r\n[info] empty_logger Elapsed: 0.07 secs 14,127,300/sec\r\n[info] **************************************************************\r\n[info] C-string (400 bytes). Single thread, 1,000,000 iterations\r\n[info] **************************************************************\r\n[info] basic_st Elapsed: 0.41 secs 2,412,483/sec\r\n[info] rotating_st Elapsed: 0.72 secs 1,389,196/sec\r\n[info] daily_st Elapsed: 0.42 secs 2,393,298/sec\r\n[info] null_st Elapsed: 0.04 secs 27,446,957/sec\r\n[info] **************************************************************\r\n[info] 10 threads, competing over the same logger object, 1,000,000 iterations\r\n[info] **************************************************************\r\n[info] basic_mt Elapsed: 0.60 secs 1,659,613/sec\r\n[info] rotating_mt Elapsed: 0.62 secs 1,612,493/sec\r\n[info] daily_mt Elapsed: 0.61 secs 1,638,305/sec\r\n[info] null_mt Elapsed: 0.16 secs 6,272,758/sec\r\n```\r\n#### Asynchronous mode\r\n```\r\n[info] -------------------------------------------------\r\n[info] Messages : 1,000,000\r\n[info] Threads : 10\r\n[info] Queue : 8,192 slots\r\n[info] Queue memory : 8,192 x 272 = 2,176 KB \r\n[info] -------------------------------------------------\r\n[info] \r\n[info] *********************************\r\n[info] Queue Overflow Policy: block\r\n[info] *********************************\r\n[info] Elapsed: 1.70784 secs 585,535/sec\r\n[info] Elapsed: 1.69805 secs 588,910/sec\r\n[info] Elapsed: 1.7026 secs 587,337/sec\r\n[info] \r\n[info] *********************************\r\n[info] Queue Overflow Policy: overrun\r\n[info] *********************************\r\n[info] Elapsed: 0.372816 secs 2,682,285/sec\r\n[info] Elapsed: 0.379758 secs 2,633,255/sec\r\n[info] Elapsed: 0.373532 secs 2,677,147/sec\r\n\r\n```\r\n\r\n## Documentation\r\n\r\nDocumentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages.\r\n\r\n---\r\n\r\n### Powered by\r\n\r\n \"JetBrains\r\n\r\n" }, { "path": "appveyor.yml", "content": "version: 1.0.{build}\nimage: Visual Studio 2017\nenvironment:\n matrix:\n - GENERATOR: '\"Visual Studio 15 2017 Win64\"'\n BUILD_TYPE: Debug\n BUILD_SHARED: 'OFF'\n FATAL_ERRORS: 'OFF'\n WCHAR: 'ON'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'ON'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 11\n - GENERATOR: '\"Visual Studio 15 2017 Win64\"'\n BUILD_TYPE: Release\n BUILD_SHARED: 'OFF'\n FATAL_ERRORS: 'OFF'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'ON'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 11\n - GENERATOR: '\"Visual Studio 15 2017 Win64\"'\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'OFF'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'ON'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 11\n - GENERATOR: '\"Visual Studio 15 2017 Win64\"'\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'OFF'\n WCHAR: 'ON'\n WCHAR_FILES: 'ON'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 11\n - GENERATOR: '\"Visual Studio 16 2019\" -A x64'\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'OFF'\n CXX_STANDARD: 17\n APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019\n - GENERATOR: '\"Visual Studio 17 2022\" -A x64'\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'OFF'\n WCHAR_FILES: 'OFF'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'ON'\n CXX_STANDARD: 20\n APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022\n - GENERATOR: '\"Visual Studio 17 2022\" -A x64'\n BUILD_TYPE: Release\n BUILD_SHARED: 'ON'\n FATAL_ERRORS: 'ON'\n WCHAR: 'ON'\n WCHAR_FILES: 'ON'\n BUILD_EXAMPLE: 'OFF'\n USE_STD_FORMAT: 'ON'\n CXX_STANDARD: 20\n APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022\nbuild_script:\n - cmd: >-\n set\n\n mkdir build\n\n cd build\n\n set PATH=%PATH%;C:\\Program Files\\Git\\usr\\bin\n\n 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% ..\n\n cmake --build . --config %BUILD_TYPE%\n\nbefore_test:\n - set PATH=%PATH%;C:\\projects\\spdlog\\build\\_deps\\catch2-build\\src\\%BUILD_TYPE%;C:\\projects\\spdlog\\build\\%BUILD_TYPE%\n \ntest_script:\n - C:\\projects\\spdlog\\build\\tests\\%BUILD_TYPE%\\spdlog-utests.exe\n" }, { "path": "bench/CMakeLists.txt", "content": "# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\ncmake_minimum_required(VERSION 3.11)\nproject(spdlog_bench CXX)\n\nif(NOT TARGET spdlog)\n # Stand-alone build\n find_package(spdlog CONFIG REQUIRED)\nendif()\n\nfind_package(Threads REQUIRED)\nfind_package(benchmark CONFIG)\nif(NOT benchmark_FOUND)\n message(STATUS \"Using CMake Version ${CMAKE_VERSION}\")\n # User can fetch googlebenchmark\n message(STATUS \"Downloading GoogleBenchmark\")\n include(FetchContent)\n\n # disable tests\n set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL \"\")\n # Do not build and run googlebenchmark tests\n FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0)\n FetchContent_MakeAvailable(googlebenchmark)\nendif()\n\nadd_executable(bench bench.cpp)\nspdlog_enable_warnings(bench)\ntarget_link_libraries(bench PRIVATE spdlog::spdlog)\n\nadd_executable(async_bench async_bench.cpp)\ntarget_link_libraries(async_bench PRIVATE spdlog::spdlog)\n\nadd_executable(latency latency.cpp)\ntarget_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)\n\nadd_executable(formatter-bench formatter-bench.cpp)\ntarget_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)\n" }, { "path": "bench/async_bench.cpp", "content": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n//\n// bench.cpp : spdlog benchmarks\n//\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/async.h\"\n#include \"spdlog/sinks/basic_file_sink.h\"\n\n#if defined(SPDLOG_USE_STD_FORMAT)\n#include \n#elif defined(SPDLOG_FMT_EXTERNAL)\n#include \n#else\n#include \"spdlog/fmt/bundled/format.h\"\n#endif\n\n#include \"utils.h\"\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\nusing namespace spdlog;\nusing namespace spdlog::sinks;\nusing namespace utils;\n\nvoid bench_mt(int howmany, std::shared_ptr log, int thread_count);\n\n#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning(disable : 4996) // disable fopen warning under msvc\n#endif // _MSC_VER\n\nint count_lines(const char *filename) {\n int counter = 0;\n auto *infile = fopen(filename, \"r\");\n int ch;\n while (EOF != (ch = getc(infile))) {\n if ('\\n' == ch) counter++;\n }\n fclose(infile);\n\n return counter;\n}\n\nvoid verify_file(const char *filename, int expected_count) {\n spdlog::info(\"Verifying {} to contain {} line..\", filename, expected_count);\n auto count = count_lines(filename);\n if (count != expected_count) {\n spdlog::error(\"Test failed. {} has {} lines instead of {}\", filename, count,\n expected_count);\n exit(1);\n }\n spdlog::info(\"Line count OK ({})\\n\", count);\n}\n\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif\n\nint main(int argc, char *argv[]) {\n int howmany = 1000000;\n int queue_size = std::min(howmany + 2, 8192);\n int threads = 10;\n int iters = 3;\n\n try {\n spdlog::set_pattern(\"[%^%l%$] %v\");\n if (argc == 1) {\n spdlog::info(\"Usage: {} \", argv[0]);\n return 0;\n }\n\n if (argc > 1) howmany = atoi(argv[1]);\n if (argc > 2) threads = atoi(argv[2]);\n if (argc > 3) {\n queue_size = atoi(argv[3]);\n if (queue_size > 500000) {\n spdlog::error(\"Max queue size allowed: 500,000\");\n exit(1);\n }\n }\n\n if (argc > 4) iters = atoi(argv[4]);\n\n auto slot_size = sizeof(spdlog::details::async_msg);\n spdlog::info(\"-------------------------------------------------\");\n spdlog::info(\"Messages : {:L}\", howmany);\n spdlog::info(\"Threads : {:L}\", threads);\n spdlog::info(\"Queue : {:L} slots\", queue_size);\n spdlog::info(\"Queue memory : {:L} x {:L} = {:L} KB \", queue_size, slot_size,\n (queue_size * slot_size) / 1024);\n spdlog::info(\"Total iters : {:L}\", iters);\n spdlog::info(\"-------------------------------------------------\");\n\n const char *filename = \"logs/basic_async.log\";\n spdlog::info(\"\");\n spdlog::info(\"*********************************\");\n spdlog::info(\"Queue Overflow Policy: block\");\n spdlog::info(\"*********************************\");\n for (int i = 0; i < iters; i++) {\n auto tp = std::make_shared(queue_size, 1);\n auto file_sink = std::make_shared(filename, true);\n auto logger = std::make_shared(\n \"async_logger\", std::move(file_sink), std::move(tp), async_overflow_policy::block);\n bench_mt(howmany, std::move(logger), threads);\n // verify_file(filename, howmany);\n }\n\n spdlog::info(\"\");\n spdlog::info(\"*********************************\");\n spdlog::info(\"Queue Overflow Policy: overrun\");\n spdlog::info(\"*********************************\");\n // do same test but discard oldest if queue is full instead of blocking\n filename = \"logs/basic_async-overrun.log\";\n for (int i = 0; i < iters; i++) {\n auto tp = std::make_shared(queue_size, 1);\n auto file_sink = std::make_shared(filename, true);\n auto logger =\n std::make_shared(\"async_logger\", std::move(file_sink), std::move(tp),\n async_overflow_policy::overrun_oldest);\n bench_mt(howmany, std::move(logger), threads);\n }\n spdlog::shutdown();\n } catch (std::exception &ex) {\n std::cerr << \"Error: \" << ex.what() << std::endl;\n perror(\"Last error\");\n return 1;\n }\n return 0;\n}\n\nvoid thread_fun(std::shared_ptr logger, int howmany) {\n for (int i = 0; i < howmany; i++) {\n logger->info(\"Hello logger: msg number {}\", i);\n }\n}\n\nvoid bench_mt(int howmany, std::shared_ptr logger, int thread_count) {\n using std::chrono::high_resolution_clock;\n vector threads;\n auto start = high_resolution_clock::now();\n\n int msgs_per_thread = howmany / thread_count;\n int msgs_per_thread_mod = howmany % thread_count;\n for (int t = 0; t < thread_count; ++t) {\n if (t == 0 && msgs_per_thread_mod)\n threads.push_back(\n std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));\n else\n threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));\n }\n\n for (auto &t : threads) {\n t.join();\n }\n\n auto delta = high_resolution_clock::now() - start;\n auto delta_d = duration_cast>(delta).count();\n spdlog::info(\"Elapsed: {} secs\\t {:L}/sec\", delta_d, int(howmany / delta_d));\n}\n" }, { "path": "bench/bench.cpp", "content": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n//\n// bench.cpp : spdlog benchmarks\n//\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/sinks/basic_file_sink.h\"\n#include \"spdlog/sinks/daily_file_sink.h\"\n#include \"spdlog/sinks/null_sink.h\"\n#include \"spdlog/sinks/rotating_file_sink.h\"\n\n#if defined(SPDLOG_USE_STD_FORMAT)\n#include \n#elif defined(SPDLOG_FMT_EXTERNAL)\n#include \n#else\n#include \"spdlog/fmt/bundled/format.h\"\n#endif\n\n#include \"utils.h\"\n#include \n#include // EXIT_FAILURE\n#include \n#include \n#include \n\nvoid bench(int howmany, std::shared_ptr log);\nvoid bench_mt(int howmany, std::shared_ptr log, size_t thread_count);\n\n// void bench_default_api(int howmany, std::shared_ptr log);\n// void bench_c_string(int howmany, std::shared_ptr log);\n\nstatic const size_t file_size = 30 * 1024 * 1024;\nstatic const size_t rotating_files = 5;\nstatic const int max_threads = 1000;\n\nvoid bench_threaded_logging(size_t threads, int iters) {\n spdlog::info(\"**************************************************************\");\n spdlog::info(spdlog::fmt_lib::format(\n std::locale(\"en_US.UTF-8\"), \"Multi threaded: {:L} threads, {:L} messages\", threads, iters));\n spdlog::info(\"**************************************************************\");\n\n auto basic_mt = spdlog::basic_logger_mt(\"basic_mt\", \"logs/basic_mt.log\", true);\n bench_mt(iters, std::move(basic_mt), threads);\n auto basic_mt_tracing =\n spdlog::basic_logger_mt(\"basic_mt/backtrace-on\", \"logs/basic_mt.log\", true);\n basic_mt_tracing->enable_backtrace(32);\n bench_mt(iters, std::move(basic_mt_tracing), threads);\n\n spdlog::info(\"\");\n auto rotating_mt = spdlog::rotating_logger_mt(\"rotating_mt\", \"logs/rotating_mt.log\", file_size,\n rotating_files);\n bench_mt(iters, std::move(rotating_mt), threads);\n auto rotating_mt_tracing = spdlog::rotating_logger_mt(\n \"rotating_mt/backtrace-on\", \"logs/rotating_mt.log\", file_size, rotating_files);\n rotating_mt_tracing->enable_backtrace(32);\n bench_mt(iters, std::move(rotating_mt_tracing), threads);\n\n spdlog::info(\"\");\n auto daily_mt = spdlog::daily_logger_mt(\"daily_mt\", \"logs/daily_mt.log\");\n bench_mt(iters, std::move(daily_mt), threads);\n auto daily_mt_tracing = spdlog::daily_logger_mt(\"daily_mt/backtrace-on\", \"logs/daily_mt.log\");\n daily_mt_tracing->enable_backtrace(32);\n bench_mt(iters, std::move(daily_mt_tracing), threads);\n\n spdlog::info(\"\");\n auto empty_logger = std::make_shared(\"level-off\");\n empty_logger->set_level(spdlog::level::off);\n bench(iters, empty_logger);\n auto empty_logger_tracing = std::make_shared(\"level-off/backtrace-on\");\n empty_logger_tracing->set_level(spdlog::level::off);\n empty_logger_tracing->enable_backtrace(32);\n bench(iters, empty_logger_tracing);\n}\n\nvoid bench_single_threaded(int iters) {\n spdlog::info(\"**************************************************************\");\n spdlog::info(\n spdlog::fmt_lib::format(std::locale(\"en_US.UTF-8\"), \"Single threaded: {} messages\", iters));\n spdlog::info(\"**************************************************************\");\n\n auto basic_st = spdlog::basic_logger_st(\"basic_st\", \"logs/basic_st.log\", true);\n bench(iters, std::move(basic_st));\n\n auto basic_st_tracing =\n spdlog::basic_logger_st(\"basic_st/backtrace-on\", \"logs/basic_st.log\", true);\n bench(iters, std::move(basic_st_tracing));\n\n spdlog::info(\"\");\n auto rotating_st = spdlog::rotating_logger_st(\"rotating_st\", \"logs/rotating_st.log\", file_size,\n rotating_files);\n bench(iters, std::move(rotating_st));\n auto rotating_st_tracing = spdlog::rotating_logger_st(\n \"rotating_st/backtrace-on\", \"logs/rotating_st.log\", file_size, rotating_files);\n rotating_st_tracing->enable_backtrace(32);\n bench(iters, std::move(rotating_st_tracing));\n\n spdlog::info(\"\");\n auto daily_st = spdlog::daily_logger_st(\"daily_st\", \"logs/daily_st.log\");\n bench(iters, std::move(daily_st));\n auto daily_st_tracing = spdlog::daily_logger_st(\"daily_st/backtrace-on\", \"logs/daily_st.log\");\n daily_st_tracing->enable_backtrace(32);\n bench(iters, std::move(daily_st_tracing));\n\n spdlog::info(\"\");\n auto empty_logger = std::make_shared(\"level-off\");\n empty_logger->set_level(spdlog::level::off);\n bench(iters, empty_logger);\n\n auto empty_logger_tracing = std::make_shared(\"level-off/backtrace-on\");\n empty_logger_tracing->set_level(spdlog::level::off);\n empty_logger_tracing->enable_backtrace(32);\n bench(iters, empty_logger_tracing);\n}\n\nint main(int argc, char *argv[]) {\n spdlog::set_automatic_registration(false);\n spdlog::default_logger()->set_pattern(\"[%^%l%$] %v\");\n int iters = 250000;\n size_t threads = 4;\n try {\n if (argc > 1) {\n iters = std::stoi(argv[1]);\n }\n if (argc > 2) {\n threads = std::stoul(argv[2]);\n }\n\n if (threads > max_threads) {\n throw std::runtime_error(\n spdlog::fmt_lib::format(\"Number of threads exceeds maximum({})\", max_threads));\n }\n\n bench_single_threaded(iters);\n bench_threaded_logging(1, iters);\n bench_threaded_logging(threads, iters);\n } catch (std::exception &ex) {\n spdlog::error(ex.what());\n return EXIT_FAILURE;\n }\n return EXIT_SUCCESS;\n}\n\nvoid bench(int howmany, std::shared_ptr log) {\n using std::chrono::duration;\n using std::chrono::duration_cast;\n using std::chrono::high_resolution_clock;\n\n auto start = high_resolution_clock::now();\n for (auto i = 0; i < howmany; ++i) {\n log->info(\"Hello logger: msg number {}\", i);\n }\n\n auto delta = high_resolution_clock::now() - start;\n auto delta_d = duration_cast>(delta).count();\n\n spdlog::info(spdlog::fmt_lib::format(std::locale(\"en_US.UTF-8\"),\n \"{:<30} Elapsed: {:0.2f} secs {:>16L}/sec\", log->name(),\n delta_d, size_t(howmany / delta_d)));\n spdlog::drop(log->name());\n}\n\nvoid bench_mt(int howmany, std::shared_ptr log, size_t thread_count) {\n using std::chrono::duration;\n using std::chrono::duration_cast;\n using std::chrono::high_resolution_clock;\n\n std::vector threads;\n threads.reserve(thread_count);\n auto start = high_resolution_clock::now();\n for (size_t t = 0; t < thread_count; ++t) {\n threads.emplace_back([&]() {\n for (int j = 0; j < howmany / static_cast(thread_count); j++) {\n log->info(\"Hello logger: msg number {}\", j);\n }\n });\n }\n\n for (auto &t : threads) {\n t.join();\n }\n\n auto delta = high_resolution_clock::now() - start;\n auto delta_d = duration_cast>(delta).count();\n spdlog::info(spdlog::fmt_lib::format(std::locale(\"en_US.UTF-8\"),\n \"{:<30} Elapsed: {:0.2f} secs {:>16L}/sec\", log->name(),\n delta_d, size_t(howmany / delta_d)));\n spdlog::drop(log->name());\n}\n\n/*\nvoid bench_default_api(int howmany, std::shared_ptr log)\n{\n using std::chrono::high_resolution_clock;\n using std::chrono::duration;\n using std::chrono::duration_cast;\n\n auto orig_default = spdlog::default_logger();\n spdlog::set_default_logger(log);\n auto start = high_resolution_clock::now();\n for (auto i = 0; i < howmany; ++i)\n {\n spdlog::info(\"Hello logger: msg number {}\", i);\n }\n\n auto delta = high_resolution_clock::now() - start;\n auto delta_d = duration_cast>(delta).count();\n spdlog::drop(log->name());\n spdlog::set_default_logger(std::move(orig_default));\n spdlog::info(\"{:<30} Elapsed: {:0.2f} secs {:>16}/sec\", log->name(), delta_d, int(howmany /\ndelta_d));\n}\n\nvoid bench_c_string(int howmany, std::shared_ptr log)\n{\n using std::chrono::high_resolution_clock;\n using std::chrono::duration;\n using std::chrono::duration_cast;\n\n const char *msg = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra\nmetus cursus \" \"lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus\nvolutpat mi, eu consequat sem \" \"libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam\nnon dapibus eros. Donec fringilla dui sed \" \"augue pretium, nec scelerisque est maximus. Nullam\nconvallis, sem nec blandit maximus, nisi turpis ornare \" \"nisl, sit amet volutpat neque massa eu\nodio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.\";\n\n auto orig_default = spdlog::default_logger();\n spdlog::set_default_logger(log);\n auto start = high_resolution_clock::now();\n for (auto i = 0; i < howmany; ++i)\n {\n spdlog::log(spdlog::level::info, msg);\n }\n\n auto delta = high_resolution_clock::now() - start;\n auto delta_d = duration_cast>(delta).count();\n spdlog::drop(log->name());\n spdlog::set_default_logger(std::move(orig_default));\n spdlog::info(\"{:<30} Elapsed: {:0.2f} secs {:>16}/sec\", log->name(), delta_d, int(howmany /\ndelta_d));\n}\n\n*/\n" }, { "path": "bench/formatter-bench.cpp", "content": "//\n// Copyright(c) 2018 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#include \"benchmark/benchmark.h\"\n\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/pattern_formatter.h\"\n\nvoid bench_formatter(benchmark::State &state, std::string pattern) {\n auto formatter = spdlog::details::make_unique(pattern);\n spdlog::memory_buf_t dest;\n std::string logger_name = \"logger-name\";\n const char *text =\n \"Hello. This is some message with length of 80 \";\n\n spdlog::source_loc source_loc{\"a/b/c/d/myfile.cpp\", 123, \"some_func()\"};\n spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);\n\n for (auto _ : state) {\n dest.clear();\n formatter->format(msg, dest);\n benchmark::DoNotOptimize(dest);\n }\n}\n\nvoid bench_formatters() {\n // basic patterns(single flag)\n std::string all_flags = \"+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%\";\n std::vector basic_patterns;\n for (auto &flag : all_flags) {\n auto pattern = std::string(\"%\") + flag;\n benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);\n\n // pattern = std::string(\"%16\") + flag;\n // benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);\n //\n // // bench center padding\n // pattern = std::string(\"%=16\") + flag;\n // benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);\n }\n\n // complex patterns\n std::vector patterns = {\n \"[%D %X] [%l] [%n] %v\",\n \"[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v\",\n \"[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v\",\n };\n for (auto &pattern : patterns) {\n benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)\n ->Iterations(2500000);\n }\n}\n\nint main(int argc, char *argv[]) {\n spdlog::set_pattern(\"[%^%l%$] %v\");\n if (argc != 2) {\n spdlog::error(\"Usage: {} (or \\\"all\\\" to bench all)\", argv[0]);\n exit(1);\n }\n\n std::string pattern = argv[1];\n if (pattern == \"all\") {\n bench_formatters();\n } else {\n benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);\n }\n benchmark::Initialize(&argc, argv);\n benchmark::RunSpecifiedBenchmarks();\n}\n" }, { "path": "bench/latency.cpp", "content": "//\n// Copyright(c) 2018 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n//\n// latency.cpp : spdlog latency benchmarks\n//\n\n#include \"benchmark/benchmark.h\"\n\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/async.h\"\n#include \"spdlog/sinks/basic_file_sink.h\"\n#include \"spdlog/sinks/daily_file_sink.h\"\n#include \"spdlog/sinks/null_sink.h\"\n#include \"spdlog/sinks/rotating_file_sink.h\"\n\nvoid bench_c_string(benchmark::State &state, std::shared_ptr logger) {\n const char *msg =\n \"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus \"\n \"lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, \"\n \"eu consequat sem \"\n \"libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec \"\n \"fringilla dui sed \"\n \"augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, \"\n \"nisi turpis ornare \"\n \"nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue \"\n \"nibh turpis duis.\";\n\n for (auto _ : state) {\n logger->info(msg);\n }\n}\n\nvoid bench_logger(benchmark::State &state, std::shared_ptr logger) {\n int i = 0;\n for (auto _ : state) {\n logger->info(\"Hello logger: msg number {}...............\", ++i);\n }\n}\nvoid bench_global_logger(benchmark::State &state, std::shared_ptr logger) {\n spdlog::set_default_logger(std::move(logger));\n int i = 0;\n for (auto _ : state) {\n spdlog::info(\"Hello logger: msg number {}...............\", ++i);\n }\n}\n\nvoid bench_disabled_macro(benchmark::State &state, std::shared_ptr logger) {\n int i = 0;\n benchmark::DoNotOptimize(i); // prevent unused warnings\n benchmark::DoNotOptimize(logger); // prevent unused warnings\n for (auto _ : state) {\n SPDLOG_LOGGER_DEBUG(logger, \"Hello logger: msg number {}...............\", i++);\n }\n}\n\nvoid bench_disabled_macro_global_logger(benchmark::State &state,\n std::shared_ptr logger) {\n spdlog::set_default_logger(std::move(logger));\n int i = 0;\n benchmark::DoNotOptimize(i); // prevent unused warnings\n benchmark::DoNotOptimize(logger); // prevent unused warnings\n for (auto _ : state) {\n SPDLOG_DEBUG(\"Hello logger: msg number {}...............\", i++);\n }\n}\n\n#ifdef __linux__\nvoid bench_dev_null() {\n auto dev_null_st = spdlog::basic_logger_st(\"/dev/null_st\", \"/dev/null\");\n benchmark::RegisterBenchmark(\"/dev/null_st\", bench_logger, std::move(dev_null_st))\n ->UseRealTime();\n spdlog::drop(\"/dev/null_st\");\n\n auto dev_null_mt = spdlog::basic_logger_mt(\"/dev/null_mt\", \"/dev/null\");\n benchmark::RegisterBenchmark(\"/dev/null_mt\", bench_logger, std::move(dev_null_mt))\n ->UseRealTime();\n spdlog::drop(\"/dev/null_mt\");\n}\n#endif // __linux__\n\nint main(int argc, char *argv[]) {\n using spdlog::sinks::null_sink_mt;\n using spdlog::sinks::null_sink_st;\n\n size_t file_size = 30 * 1024 * 1024;\n size_t rotating_files = 5;\n int n_threads = benchmark::CPUInfo::Get().num_cpus;\n\n auto full_bench = argc > 1 && std::string(argv[1]) == \"full\";\n\n // disabled loggers\n auto disabled_logger =\n std::make_shared(\"bench\", std::make_shared());\n disabled_logger->set_level(spdlog::level::off);\n benchmark::RegisterBenchmark(\"disabled-at-compile-time\", bench_disabled_macro, disabled_logger);\n benchmark::RegisterBenchmark(\"disabled-at-compile-time (global logger)\",\n bench_disabled_macro_global_logger, disabled_logger);\n benchmark::RegisterBenchmark(\"disabled-at-runtime\", bench_logger, disabled_logger);\n benchmark::RegisterBenchmark(\"disabled-at-runtime (global logger)\", bench_global_logger,\n disabled_logger);\n // with backtrace of 64\n auto tracing_disabled_logger =\n std::make_shared(\"bench\", std::make_shared());\n tracing_disabled_logger->enable_backtrace(64);\n benchmark::RegisterBenchmark(\"disabled-at-runtime/backtrace\", bench_logger,\n tracing_disabled_logger);\n\n auto null_logger_st =\n std::make_shared(\"bench\", std::make_shared());\n benchmark::RegisterBenchmark(\"null_sink_st (500_bytes c_str)\", bench_c_string,\n std::move(null_logger_st));\n benchmark::RegisterBenchmark(\"null_sink_st\", bench_logger, null_logger_st);\n benchmark::RegisterBenchmark(\"null_sink_st (global logger)\", bench_global_logger,\n null_logger_st);\n // with backtrace of 64\n auto tracing_null_logger_st =\n std::make_shared(\"bench\", std::make_shared());\n tracing_null_logger_st->enable_backtrace(64);\n benchmark::RegisterBenchmark(\"null_sink_st/backtrace\", bench_logger, tracing_null_logger_st);\n\n#ifdef __linux__\n bench_dev_null();\n#endif // __linux__\n\n if (full_bench) {\n // basic_st\n auto basic_st = spdlog::basic_logger_st(\"basic_st\", \"latency_logs/basic_st.log\", true);\n benchmark::RegisterBenchmark(\"basic_st\", bench_logger, std::move(basic_st))->UseRealTime();\n spdlog::drop(\"basic_st\");\n // with backtrace of 64\n auto tracing_basic_st =\n spdlog::basic_logger_st(\"tracing_basic_st\", \"latency_logs/tracing_basic_st.log\", true);\n tracing_basic_st->enable_backtrace(64);\n benchmark::RegisterBenchmark(\"basic_st/backtrace\", bench_logger,\n std::move(tracing_basic_st))\n ->UseRealTime();\n spdlog::drop(\"tracing_basic_st\");\n\n // rotating st\n auto rotating_st = spdlog::rotating_logger_st(\"rotating_st\", \"latency_logs/rotating_st.log\",\n file_size, rotating_files);\n benchmark::RegisterBenchmark(\"rotating_st\", bench_logger, std::move(rotating_st))\n ->UseRealTime();\n spdlog::drop(\"rotating_st\");\n // with backtrace of 64\n auto tracing_rotating_st = spdlog::rotating_logger_st(\n \"tracing_rotating_st\", \"latency_logs/tracing_rotating_st.log\", file_size,\n rotating_files);\n benchmark::RegisterBenchmark(\"rotating_st/backtrace\", bench_logger,\n std::move(tracing_rotating_st))\n ->UseRealTime();\n spdlog::drop(\"tracing_rotating_st\");\n\n // daily st\n auto daily_st = spdlog::daily_logger_mt(\"daily_st\", \"latency_logs/daily_st.log\");\n benchmark::RegisterBenchmark(\"daily_st\", bench_logger, std::move(daily_st))->UseRealTime();\n spdlog::drop(\"daily_st\");\n auto tracing_daily_st =\n spdlog::daily_logger_mt(\"tracing_daily_st\", \"latency_logs/daily_st.log\");\n benchmark::RegisterBenchmark(\"daily_st/backtrace\", bench_logger,\n std::move(tracing_daily_st))\n ->UseRealTime();\n spdlog::drop(\"tracing_daily_st\");\n\n //\n // Multi threaded bench, 10 loggers using same logger concurrently\n //\n auto null_logger_mt =\n std::make_shared(\"bench\", std::make_shared());\n benchmark::RegisterBenchmark(\"null_sink_mt\", bench_logger, null_logger_mt)\n ->Threads(n_threads)\n ->UseRealTime();\n\n // basic_mt\n auto basic_mt = spdlog::basic_logger_mt(\"basic_mt\", \"latency_logs/basic_mt.log\", true);\n benchmark::RegisterBenchmark(\"basic_mt\", bench_logger, std::move(basic_mt))\n ->Threads(n_threads)\n ->UseRealTime();\n spdlog::drop(\"basic_mt\");\n\n // rotating mt\n auto rotating_mt = spdlog::rotating_logger_mt(\"rotating_mt\", \"latency_logs/rotating_mt.log\",\n file_size, rotating_files);\n benchmark::RegisterBenchmark(\"rotating_mt\", bench_logger, std::move(rotating_mt))\n ->Threads(n_threads)\n ->UseRealTime();\n spdlog::drop(\"rotating_mt\");\n\n // daily mt\n auto daily_mt = spdlog::daily_logger_mt(\"daily_mt\", \"latency_logs/daily_mt.log\");\n benchmark::RegisterBenchmark(\"daily_mt\", bench_logger, std::move(daily_mt))\n ->Threads(n_threads)\n ->UseRealTime();\n spdlog::drop(\"daily_mt\");\n }\n\n // async\n auto queue_size = 1024 * 1024 * 3;\n auto tp = std::make_shared(queue_size, 1);\n auto async_logger = std::make_shared(\n \"async_logger\", std::make_shared(), std::move(tp),\n spdlog::async_overflow_policy::overrun_oldest);\n benchmark::RegisterBenchmark(\"async_logger\", bench_logger, async_logger)\n ->Threads(n_threads)\n ->UseRealTime();\n\n auto async_logger_tracing = std::make_shared(\n \"async_logger_tracing\", std::make_shared(), std::move(tp),\n spdlog::async_overflow_policy::overrun_oldest);\n async_logger_tracing->enable_backtrace(32);\n benchmark::RegisterBenchmark(\"async_logger/tracing\", bench_logger, async_logger_tracing)\n ->Threads(n_threads)\n ->UseRealTime();\n\n benchmark::Initialize(&argc, argv);\n benchmark::RunSpecifiedBenchmarks();\n}\n" }, { "path": "bench/utils.h", "content": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n\n#include \n#include \n#include \n\nnamespace utils {\n\ntemplate \ninline std::string format(const T &value) {\n static std::locale loc(\"\");\n std::stringstream ss;\n ss.imbue(loc);\n ss << value;\n return ss.str();\n}\n\ntemplate <>\ninline std::string format(const double &value) {\n static std::locale loc(\"\");\n std::stringstream ss;\n ss.imbue(loc);\n ss << std::fixed << std::setprecision(1) << value;\n return ss.str();\n}\n\n} // namespace utils\n" }, { "path": "cmake/ide.cmake", "content": "# ---------------------------------------------------------------------------------------\n# IDE support for headers\n# ---------------------------------------------------------------------------------------\nset(SPDLOG_HEADERS_DIR \"${CMAKE_CURRENT_LIST_DIR}/../include\")\n\nfile(GLOB SPDLOG_TOP_HEADERS \"${SPDLOG_HEADERS_DIR}/spdlog/*.h\")\nfile(GLOB SPDLOG_DETAILS_HEADERS \"${SPDLOG_HEADERS_DIR}/spdlog/details/*.h\")\nfile(GLOB SPDLOG_SINKS_HEADERS \"${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h\")\nfile(GLOB SPDLOG_FMT_HEADERS \"${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h\")\nfile(GLOB SPDLOG_FMT_BUNDELED_HEADERS \"${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h\")\nset(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS}\n ${SPDLOG_FMT_BUNDELED_HEADERS})\n\nsource_group(\"Header Files\\\\spdlog\" FILES ${SPDLOG_TOP_HEADERS})\nsource_group(\"Header Files\\\\spdlog\\\\details\" FILES ${SPDLOG_DETAILS_HEADERS})\nsource_group(\"Header Files\\\\spdlog\\\\sinks\" FILES ${SPDLOG_SINKS_HEADERS})\nsource_group(\"Header Files\\\\spdlog\\\\fmt\" FILES ${SPDLOG_FMT_HEADERS})\nsource_group(\"Header Files\\\\spdlog\\\\fmt\\\\bundled\\\\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS})\n" }, { "path": "cmake/pch.h.in", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// details/pattern_formatter-inl.h\n// fmt/bin_to_hex.h\n// fmt/bundled/format-inl.h\n#include \n\n// details/file_helper-inl.h\n// details/os-inl.h\n// fmt/bundled/posix.h\n// logger-inl.h\n// sinks/daily_file_sink.h\n// sinks/stdout_sinks.h\n#include \n\n// details/os-inl.h\n// fmt/bundled/posix.h\n#include \n\n// details/os-inl.h\n// details/pattern_formatter-inl.h\n// fmt/bundled/format-inl.h\n#include \n\n// details/os-inl.h\n// details/os.h\n// details/pattern_formatter-inl.h\n// details/pattern_formatter.h\n// fmt/bundled/chrono.h\n// sinks/daily_file_sink.h\n// sinks/rotating_file_sink-inl.h\n#include \n\n// fmt/bundled/format-inl.h\n#include \n\n// fmt/bundled/format-inl.h\n#include \n\n// fmt/bundled/format-inl.h\n// fmt/bundled/format.h\n#include \n\n// fmt/bundled/format-inl.h\n#include \n\n// details/file_helper-inl.h\n// fmt/bundled/format.h\n// fmt/bundled/posix.h\n// sinks/rotating_file_sink-inl.h\n#include \n\n// details/circular_q.h\n// details/thread_pool-inl.h\n// fmt/bundled/format-inl.h\n#include \n\n// async_logger-inl.h\n// cfg/helpers-inl.h\n// log_levels.h\n// common.h\n// details/file_helper-inl.h\n// details/log_msg.h\n// details/os-inl.h\n// details/pattern_formatter-inl.h\n// details/pattern_formatter.h\n// details/registry-inl.h\n// details/registry.h\n// details/tcp_client-windows.h\n// details/tcp_client.h\n// sinks/android_sink.h\n// sinks/ansicolor_sink.h\n// sinks/basic_file_sink.h\n// sinks/daily_file_sink.h\n// sinks/dup_filter_sink.h\n// sinks/msvc_sink.h\n// sinks/ringbuffer_sink.h\n// sinks/rotating_file_sink-inl.h\n// sinks/rotating_file_sink.h\n// sinks/syslog_sink.h\n// sinks/tcp_sink.h\n// sinks/win_eventlog_sink.h\n// sinks/wincolor_sink.h\n// spdlog.h:\n#include \n\n// cfg/helpers-inl.h\n// fmt/bundled/chrono.h\n#include \n\n// fmt/bundled/ostream.h\n// sinks/ostream_sink.h\n#include \n\n// cfg/log_levels.h\n// details/registry-inl.h\n// details/registry.h\n#include \n\n// details/circular_q.h\n// details/pattern_formatter-inl.h\n// details/pattern_formatter.h\n// details/thread_pool.h\n// fmt/bundled/compile.h\n// logger.h\n// sinks/dist_sink.h\n// sinks/ringbuffer_sink.h\n// sinks/win_eventlog_sink.h\n#include \n\n// details/os-inl.h\n// details/pattern_formatter-inl.h\n// sinks/ansicolor_sink.h\n// sinks/syslog_sink.h\n// sinks/systemd_sink.h\n// sinks/wincolor_sink.h\n#include \n\n// details/file_helper-inl.h\n// details/file_helper.h\n// sinks/rotating_file_sink-inl.h\n#include \n\n// details/os-inl.h\n// fmt/bundled/format.h\n// fmt/bundled/printf.h\n#include \n\n// common.h\n// details/backtracer.h\n// details/null_mutex.h\n#include \n\n// common.h\n// details/backtracer.h\n// details/null_mutex.h\n#include \n\n// common.h\n#include \n\n// common.h\n#include \n\n// common.h\n// details/fmt_helper.h\n// fmt/bundled/ranges.h\n#include \n\n// cfg/helpers-inl.h\n// details/null_mutex.h\n// details/pattern_formatter-inl.h\n#include \n\n// async.h\n// async_logger-inl.h\n// common.h\n// details/pattern_formatter-inl.h\n// details/pattern_formatter.h\n// details/registry-inl.h\n// details/registry.h\n// details/thread_pool.h\n// fmt/bundled/format.h\n// sinks/ansicolor_sink.h\n// sinks/base_sink-inl.h\n// sinks/dist_sink.h\n// sinks/stdout_sinks-inl.h\n// sinks/wincolor_sink.h\n// spdlog.h\n#include \n\n// async.h\n// common.h\n// details/backtracer.h\n// details/periodic_worker.h\n// details/registry-inl.h\n// details/registry.h\n// details/thread_pool.h\n// sinks/tcp_sink.h\n// spdlog.h\n#include \n\n// details/mpmc_blocking_q.h\n// details/periodic_worker.h\n#include \n\n// details/os-inl.h\n// fmt/bundled/format.h\n// fmt/bundled/printf.h\n// sinks/dist_sink.h\n#include \n\n// common.h\n// details/file_helper-inl.h\n// details/fmt_helper.h\n// details/os-inl.h\n// details/pattern_formatter-inl.h\n// details/pattern_formatter.h\n// details/periodic_worker.h\n// details/registry-inl.h\n// details/registry.h\n// details/thread_pool.h\n// fmt/bundled/chrono.h\n// sinks/android_sink.h\n// sinks/daily_file_sink.h\n// sinks/dup_filter_sink.h\n// sinks/rotating_file_sink-inl.h\n// sinks/rotating_file_sink.h\n// sinks/tcp_sink.h\n// spdlog.h\n#include \n\n// details/file_helper-inl.h\n// details/os-inl.h\n// details/pattern_formatter-inl.h\n// details/periodic_worker.h\n// details/thread_pool.h\n// sinks/android_sink.h\n#include \n\n// async.h\n// details/backtracer.h\n// details/console_globals.h\n// details/mpmc_blocking_q.h\n// details/pattern_formatter-inl.h\n// details/periodic_worker.h\n// details/registry.h\n// sinks/android_sink.h\n// sinks/ansicolor_sink.h\n// sinks/basic_file_sink.h\n// sinks/daily_file_sink.h\n// sinks/dist_sink.h\n// sinks/dup_filter_sink.h\n// sinks/msvc_sink.h\n// sinks/null_sink.h\n// sinks/ostream_sink.h\n// sinks/ringbuffer_sink.h\n// sinks/rotating_file_sink-inl.h\n// sinks/rotating_file_sink.h\n// sinks/tcp_sink.h\n// sinks/win_eventlog_sink.h\n// sinks/wincolor_sink.h\n//\n// color_sinks.cpp\n// file_sinks.cpp\n// spdlog.cpp\n// stdout_sinks.cpp\n#include \n\n// spdlog\n#include \n" }, { "path": "cmake/spdlog.pc.in", "content": "prefix=@CMAKE_INSTALL_PREFIX@\nexec_prefix=${prefix}\nincludedir=@PKG_CONFIG_INCLUDEDIR@\nlibdir=@PKG_CONFIG_LIBDIR@\n\nName: lib@PROJECT_NAME@\nDescription: Fast C++ logging library.\nURL: https://github.com/gabime/@PROJECT_NAME@\nVersion: @SPDLOG_VERSION@\nCFlags: -I${includedir} @PKG_CONFIG_DEFINES@\nLibs: -L${libdir} -lspdlog -pthread\nRequires: @PKG_CONFIG_REQUIRES@\n\n" }, { "path": "cmake/spdlogCPack.cmake", "content": "set(CPACK_GENERATOR \"TGZ;ZIP\" CACHE STRING \"Semicolon separated list of generators\")\n\nset(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)\nset(CPACK_INSTALL_CMAKE_PROJECTS \"${CMAKE_BINARY_DIR}\" \"${PROJECT_NAME}\" ALL .)\n\nset(CPACK_PROJECT_URL \"https://github.com/gabime/spdlog\")\nset(CPACK_PACKAGE_VENDOR \"Gabi Melman\")\nset(CPACK_PACKAGE_CONTACT \"Gabi Melman \")\nset(CPACK_PACKAGE_DESCRIPTION_SUMMARY \"Fast C++ logging library\")\nset(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})\nset(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})\nset(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})\nset(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})\nif(PROJECT_VERSION_TWEAK)\n set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})\nendif()\nset(CPACK_PACKAGE_RELOCATABLE ON CACHE BOOL \"Build relocatable package\")\n\nset(CPACK_RPM_PACKAGE_LICENSE \"MIT\")\nset(CPACK_RPM_PACKAGE_GROUP \"Development/Libraries\")\nset(CPACK_DEBIAN_PACKAGE_SECTION \"libs\")\nset(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})\nset(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${CPACK_PROJECT_URL})\nset(CPACK_RPM_PACKAGE_DESCRIPTION \"Very fast, header-only/compiled, C++ logging library.\")\nset(CPACK_DEBIAN_PACKAGE_DESCRIPTION \"Very fast, header-only/compiled, C++ logging library.\")\n\nif(CPACK_PACKAGE_NAME)\n set(CPACK_RPM_FILE_NAME \"${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}\")\n set(CPACK_DEBIAN_FILE_NAME \"${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}\")\nelse()\n set(CPACK_RPM_FILE_NAME \"${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}\")\n set(CPACK_DEBIAN_FILE_NAME \"${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}\")\n set(CPACK_RPM_PACKAGE_NAME \"${PROJECT_NAME}\")\n set(CPACK_DEBIAN_PACKAGE_NAME \"${PROJECT_NAME}\")\nendif()\n\nif(CPACK_RPM_PACKAGE_RELEASE)\n set(CPACK_RPM_FILE_NAME \"${CPACK_RPM_FILE_NAME}-${CPACK_RPM_PACKAGE_RELEASE}\")\nendif()\nif(CPACK_DEBIAN_PACKAGE_RELEASE)\n set(CPACK_DEBIAN_FILE_NAME \"${CPACK_DEBIAN_FILE_NAME}-${CPACK_DEBIAN_PACKAGE_RELEASE}\")\nendif()\n\nif(CPACK_RPM_PACKAGE_ARCHITECTURE)\n set(CPACK_RPM_FILE_NAME \"${CPACK_RPM_FILE_NAME}.${CPACK_RPM_PACKAGE_ARCHITECTURE}\")\nendif()\nif(CPACK_DEBIAN_PACKAGE_ARCHITECTURE)\n set(CPACK_DEBIAN_FILE_NAME \"${CPACK_DEBIAN_FILE_NAME}.${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}\")\nendif()\nset(CPACK_RPM_FILE_NAME \"${CPACK_RPM_FILE_NAME}.rpm\")\nset(CPACK_DEBIAN_FILE_NAME \"${CPACK_DEBIAN_FILE_NAME}.deb\")\n\nif(NOT CPACK_PACKAGE_RELOCATABLE)\n # Depend on pkgconfig rpm to create the system pkgconfig folder\n set(CPACK_RPM_PACKAGE_REQUIRES pkgconfig)\n set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION\n \"${CPACK_PACKAGING_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig\")\nendif()\n\ninclude(CPack)\n" }, { "path": "cmake/spdlogConfig.cmake.in", "content": "# Copyright(c) 2019 spdlog authors\r\n# Distributed under the MIT License (http://opensource.org/licenses/MIT)\r\n\r\n@PACKAGE_INIT@\r\n\r\nfind_package(Threads REQUIRED)\r\n\r\nset(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)\r\nset(SPDLOG_FMT_EXTERNAL_HO @SPDLOG_FMT_EXTERNAL_HO@)\r\nset(config_targets_file @config_targets_file@)\r\n\r\nif(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)\r\n include(CMakeFindDependencyMacro)\r\n find_dependency(fmt CONFIG)\r\nendif()\r\n\r\n\r\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}\")\r\n\r\ncheck_required_components(spdlog)\r\n" }, { "path": "cmake/utils.cmake", "content": "# Get spdlog version from include/spdlog/version.h and put it in SPDLOG_VERSION\nfunction(spdlog_extract_version)\n file(READ \"${CMAKE_CURRENT_LIST_DIR}/include/spdlog/version.h\" file_contents)\n string(REGEX MATCH \"SPDLOG_VER_MAJOR ([0-9]+)\" _ \"${file_contents}\")\n if(NOT CMAKE_MATCH_COUNT EQUAL 1)\n message(FATAL_ERROR \"Could not extract major version number from spdlog/version.h\")\n endif()\n set(ver_major ${CMAKE_MATCH_1})\n\n string(REGEX MATCH \"SPDLOG_VER_MINOR ([0-9]+)\" _ \"${file_contents}\")\n if(NOT CMAKE_MATCH_COUNT EQUAL 1)\n message(FATAL_ERROR \"Could not extract minor version number from spdlog/version.h\")\n endif()\n\n set(ver_minor ${CMAKE_MATCH_1})\n string(REGEX MATCH \"SPDLOG_VER_PATCH ([0-9]+)\" _ \"${file_contents}\")\n if(NOT CMAKE_MATCH_COUNT EQUAL 1)\n message(FATAL_ERROR \"Could not extract patch version number from spdlog/version.h\")\n endif()\n set(ver_patch ${CMAKE_MATCH_1})\n\n set(SPDLOG_VERSION_MAJOR ${ver_major} PARENT_SCOPE)\n set(SPDLOG_VERSION_MINOR ${ver_minor} PARENT_SCOPE)\n set(SPDLOG_VERSION_PATCH ${ver_patch} PARENT_SCOPE)\n set(SPDLOG_VERSION \"${ver_major}.${ver_minor}.${ver_patch}\" PARENT_SCOPE)\nendfunction()\n\n# Turn on warnings on the given target\nfunction(spdlog_enable_warnings target_name)\n if(SPDLOG_BUILD_WARNINGS)\n if(CMAKE_CXX_COMPILER_ID STREQUAL \"MSVC\")\n list(APPEND MSVC_OPTIONS \"/W3\")\n if(MSVC_VERSION GREATER 1900) # Allow non fatal security warnings for msvc 2015\n list(APPEND MSVC_OPTIONS \"/WX\")\n endif()\n endif()\n\n target_compile_options(\n ${target_name}\n PRIVATE $<$,$,$>:\n -Wall\n -Wextra\n -Wconversion\n -pedantic\n -Werror\n -Wfatal-errors>\n $<$:${MSVC_OPTIONS}>)\n endif()\nendfunction()\n\n# Enable address sanitizer (gcc/clang only)\nfunction(spdlog_enable_addr_sanitizer target_name)\n if(NOT CMAKE_CXX_COMPILER_ID MATCHES \"GNU|Clang\")\n message(FATAL_ERROR \"Sanitizer supported only for gcc/clang\")\n endif()\n message(STATUS \"Address sanitizer enabled\")\n target_compile_options(${target_name} PRIVATE -fsanitize=address,undefined)\n target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)\n target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)\n target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)\n target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined)\nendfunction()\n\n# Enable thread sanitizer (gcc/clang only)\nfunction(spdlog_enable_thread_sanitizer target_name)\n if(NOT CMAKE_CXX_COMPILER_ID MATCHES \"GNU|Clang\")\n message(FATAL_ERROR \"Sanitizer supported only for gcc/clang\")\n endif()\n message(STATUS \"Thread sanitizer enabled\")\n target_compile_options(${target_name} PRIVATE -fsanitize=thread)\n target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)\n target_link_libraries(${target_name} PRIVATE -fsanitize=thread)\nendfunction()\n" }, { "path": "cmake/version.rc.in", "content": "#define APSTUDIO_READONLY_SYMBOLS\n#include \n#undef APSTUDIO_READONLY_SYMBOLS\n\nLANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US\n\n\nVS_VERSION_INFO VERSIONINFO\n FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0\n PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0\n FILEFLAGSMASK 0x3fL\n#ifdef _DEBUG\n FILEFLAGS 0x1L\n#else\n FILEFLAGS 0x0L\n#endif\n FILEOS 0x40004L\n FILETYPE 0x2L\n FILESUBTYPE 0x0L\nBEGIN\n BLOCK \"StringFileInfo\"\n BEGIN\n BLOCK \"040904b0\"\n BEGIN\n VALUE \"FileDescription\", \"spdlog dll\\0\"\n VALUE \"FileVersion\", \"@SPDLOG_VERSION@.0\\0\"\n VALUE \"InternalName\", \"spdlog.dll\\0\"\n VALUE \"LegalCopyright\", \"Copyright (C) spdlog\\0\"\n VALUE \"ProductName\", \"spdlog\\0\"\n VALUE \"ProductVersion\", \"@SPDLOG_VERSION@.0\\0\"\n END\n END\n BLOCK \"VarFileInfo\"\n BEGIN\n VALUE \"Translation\", 0x409, 1200\n END\nEND\n\n\n\n\n\n" }, { "path": "example/CMakeLists.txt", "content": "# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\ncmake_minimum_required(VERSION 3.11)\nproject(spdlog_examples CXX)\n\nif(NOT TARGET spdlog)\n # Stand-alone build\n find_package(spdlog REQUIRED)\nendif()\n\n# ---------------------------------------------------------------------------------------\n# Example of using pre-compiled library\n# ---------------------------------------------------------------------------------------\nadd_executable(example example.cpp)\ntarget_link_libraries(example PRIVATE spdlog::spdlog $<$:ws2_32>)\n\n# ---------------------------------------------------------------------------------------\n# Example of using header-only library\n# ---------------------------------------------------------------------------------------\nif(SPDLOG_BUILD_EXAMPLE_HO)\n add_executable(example_header_only example.cpp)\n target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)\nendif()\n" }, { "path": "example/example.cpp", "content": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n// spdlog usage example\n\n#include \n#include \n\nvoid load_levels_example();\nvoid stdout_logger_example();\nvoid basic_example();\nvoid rotating_example();\nvoid daily_example();\nvoid callback_example();\nvoid async_example();\nvoid binary_example();\nvoid vector_example();\nvoid stopwatch_example();\nvoid trace_example();\nvoid multi_sink_example();\nvoid user_defined_example();\nvoid err_handler_example();\nvoid syslog_example();\nvoid udp_example();\nvoid custom_flags_example();\nvoid file_events_example();\nvoid replace_default_logger_example();\nvoid mdc_example();\n\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/cfg/env.h\" // support for loading levels from the environment variable\n#include \"spdlog/fmt/ostr.h\" // support for user defined types\n\nint main(int, char *[]) {\n try {\n // Log levels can be loaded from argv/env using \"SPDLOG_LEVEL\"\n load_levels_example();\n\n spdlog::info(\"Welcome to spdlog version {}.{}.{} !\", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR,\n SPDLOG_VER_PATCH);\n\n spdlog::warn(\"Easy padding in numbers like {:08d}\", 12);\n spdlog::critical(\"Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}\", 42);\n spdlog::info(\"Support for floats {:03.2f}\", 1.23456);\n spdlog::info(\"Positional args are {1} {0}..\", \"too\", \"supported\");\n spdlog::info(\"{:>8} aligned, {:<8} aligned\", \"right\", \"left\");\n\n // Runtime log levels\n spdlog::set_level(spdlog::level::info); // Set global log level to info\n spdlog::debug(\"This message should not be displayed!\");\n spdlog::set_level(spdlog::level::trace); // Set specific logger's log level\n spdlog::debug(\"This message should be displayed..\");\n\n // Customize msg format for all loggers\n spdlog::set_pattern(\"[%H:%M:%S %z] [%^%L%$] [thread %t] %v\");\n spdlog::info(\"This an info message with custom format\");\n spdlog::set_pattern(\"%+\"); // back to default format\n spdlog::set_level(spdlog::level::info);\n\n // Backtrace support\n // Loggers can store in a ring buffer all messages (including debug/trace) for later\n // inspection. When needed, call dump_backtrace() to see what happened:\n spdlog::enable_backtrace(10); // create ring buffer with capacity of 10 messages\n for (int i = 0; i < 100; i++) {\n spdlog::debug(\"Backtrace message {}\", i); // not logged..\n }\n // e.g. if some error happened:\n spdlog::dump_backtrace(); // log them now!\n\n stdout_logger_example();\n basic_example();\n rotating_example();\n daily_example();\n callback_example();\n async_example();\n binary_example();\n vector_example();\n multi_sink_example();\n user_defined_example();\n err_handler_example();\n trace_example();\n stopwatch_example();\n udp_example();\n custom_flags_example();\n file_events_example();\n replace_default_logger_example();\n mdc_example();\n\n // Flush all *registered* loggers using a worker thread every 3 seconds.\n // note: registered loggers *must* be thread safe for this to work correctly!\n spdlog::flush_every(std::chrono::seconds(3));\n\n // Apply some function on all registered loggers\n spdlog::apply_all([&](std::shared_ptr l) { l->info(\"End of example.\"); });\n\n // Release all spdlog resources, and drop all loggers in the registry.\n // This is optional (only mandatory if using windows + async log).\n spdlog::shutdown();\n }\n\n // Exceptions will only be thrown upon failed logger or sink construction (not during logging).\n catch (const spdlog::spdlog_ex &ex) {\n std::printf(\"Log initialization failed: %s\\n\", ex.what());\n return 1;\n }\n}\n\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n// or #include \"spdlog/sinks/stdout_sinks.h\" if no colors needed.\nvoid stdout_logger_example() {\n // Create color multi threaded logger.\n auto console = spdlog::stdout_color_mt(\"console\");\n // or for stderr:\n // auto console = spdlog::stderr_color_mt(\"error-logger\");\n}\n\n#include \"spdlog/sinks/basic_file_sink.h\"\nvoid basic_example() {\n // Create basic file logger (not rotated).\n auto my_logger = spdlog::basic_logger_mt(\"file_logger\", \"logs/basic-log.txt\", true);\n}\n\n#include \"spdlog/sinks/rotating_file_sink.h\"\nvoid rotating_example() {\n // Create a file rotating logger with 5mb size max and 3 rotated files.\n auto rotating_logger =\n spdlog::rotating_logger_mt(\"some_logger_name\", \"logs/rotating.txt\", 1048576 * 5, 3);\n}\n\n#include \"spdlog/sinks/daily_file_sink.h\"\nvoid daily_example() {\n // Create a daily logger - a new file is created every day on 2:30am.\n auto daily_logger = spdlog::daily_logger_mt(\"daily_logger\", \"logs/daily.txt\", 2, 30);\n}\n\n#include \"spdlog/sinks/callback_sink.h\"\nvoid callback_example() {\n // Create the logger\n auto logger = spdlog::callback_logger_mt(\"custom_callback_logger\",\n [](const spdlog::details::log_msg & /*msg*/) {\n // do what you need to do with msg\n });\n}\n\n#include \"spdlog/cfg/env.h\"\nvoid load_levels_example() {\n // Set the log level to \"info\" and mylogger to \"trace\":\n // SPDLOG_LEVEL=info,mylogger=trace && ./example\n spdlog::cfg::load_env_levels();\n // or specify the env variable name:\n // MYAPP_LEVEL=info,mylogger=trace && ./example\n // spdlog::cfg::load_env_levels(\"MYAPP_LEVEL\");\n // or from command line:\n // ./example SPDLOG_LEVEL=info,mylogger=trace\n // #include \"spdlog/cfg/argv.h\" // for loading levels from argv\n // spdlog::cfg::load_argv_levels(args, argv);\n}\n\n#include \"spdlog/async.h\"\nvoid async_example() {\n // Default thread pool settings can be modified *before* creating the async logger:\n // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.\n auto async_file =\n spdlog::basic_logger_mt(\"async_file_logger\", \"logs/async_log.txt\");\n // alternatively:\n // auto async_file =\n // spdlog::create_async(\"async_file_logger\",\n // \"logs/async_log.txt\");\n\n for (int i = 1; i < 101; ++i) {\n async_file->info(\"Async message #{}\", i);\n }\n}\n\n// Log binary data as hex.\n// Many types of std::container types can be used.\n// Iterator ranges are supported too.\n// Format flags:\n// {:X} - print in uppercase.\n// {:s} - don't separate each byte with space.\n// {:p} - don't print the position on each line start.\n// {:n} - don't split the output to lines.\n\n#if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)\n#include \"spdlog/fmt/bin_to_hex.h\"\nvoid binary_example() {\n std::vector buf;\n for (int i = 0; i < 80; i++) {\n buf.push_back(static_cast(i & 0xff));\n }\n spdlog::info(\"Binary example: {}\", spdlog::to_hex(buf));\n spdlog::info(\"Another binary example:{:n}\",\n spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));\n // more examples:\n // logger->info(\"uppercase: {:X}\", spdlog::to_hex(buf));\n // logger->info(\"uppercase, no delimiters: {:Xs}\", spdlog::to_hex(buf));\n // logger->info(\"uppercase, no delimiters, no position info: {:Xsp}\", spdlog::to_hex(buf));\n // logger->info(\"hexdump style: {:a}\", spdlog::to_hex(buf));\n // logger->info(\"hexdump style, 20 chars per line {:a}\", spdlog::to_hex(buf, 20));\n}\n#else\nvoid binary_example() {\n // not supported with std::format yet\n}\n#endif\n\n// Log a vector of numbers\n#ifndef SPDLOG_USE_STD_FORMAT\n#include \"spdlog/fmt/ranges.h\"\nvoid vector_example() {\n std::vector vec = {1, 2, 3};\n spdlog::info(\"Vector example: {}\", vec);\n}\n\n#else\nvoid vector_example() {}\n#endif\n\n// ! DSPDLOG_USE_STD_FORMAT\n\n// Compile time log levels.\n// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)\nvoid trace_example() {\n // trace from default logger\n SPDLOG_TRACE(\"Some trace message.. {} ,{}\", 1, 3.23);\n // debug from default logger\n SPDLOG_DEBUG(\"Some debug message.. {} ,{}\", 1, 3.23);\n\n // trace from logger object\n auto logger = spdlog::get(\"file_logger\");\n SPDLOG_LOGGER_TRACE(logger, \"another trace message\");\n}\n\n// stopwatch example\n#include \"spdlog/stopwatch.h\"\n#include \nvoid stopwatch_example() {\n spdlog::stopwatch sw;\n std::this_thread::sleep_for(std::chrono::milliseconds(123));\n spdlog::info(\"Stopwatch: {} seconds\", sw);\n}\n\n#include \"spdlog/sinks/udp_sink.h\"\nvoid udp_example() {\n spdlog::sinks::udp_sink_config cfg(\"127.0.0.1\", 11091);\n auto my_logger = spdlog::udp_logger_mt(\"udplog\", cfg);\n my_logger->set_level(spdlog::level::debug);\n my_logger->info(\"hello world\");\n}\n\n// A logger with multiple sinks (stdout and file) - each with a different format and log level.\nvoid multi_sink_example() {\n auto console_sink = std::make_shared();\n console_sink->set_level(spdlog::level::warn);\n console_sink->set_pattern(\"[multi_sink_example] [%^%l%$] %v\");\n\n auto file_sink =\n std::make_shared(\"logs/multisink.txt\", true);\n file_sink->set_level(spdlog::level::trace);\n\n spdlog::logger logger(\"multi_sink\", {console_sink, file_sink});\n logger.set_level(spdlog::level::debug);\n logger.warn(\"this should appear in both console and file\");\n logger.info(\"this message should not appear in the console, only in the file\");\n}\n\n// User defined types logging\nstruct my_type {\n int value_ = 0;\n explicit my_type(int value)\n : value_(value) {}\n};\n\n#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib\ntemplate <>\nstruct fmt::formatter : fmt::formatter {\n auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {\n return fmt::format_to(ctx.out(), \"[my_type value={}]\", my.value_);\n }\n};\n\n#else // when using std::format\ntemplate <>\nstruct std::formatter : std::formatter {\n auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {\n return std::format_to(ctx.out(), \"[my_type value={}]\", my.value_);\n }\n};\n#endif\n\nvoid user_defined_example() { spdlog::info(\"user defined type: {}\", my_type(14)); }\n\n// Custom error handler. Will be triggered on log failure.\nvoid err_handler_example() {\n // can be set globally or per logger(logger->set_error_handler(..))\n spdlog::set_error_handler([](const std::string &msg) {\n printf(\"*** Custom log error handler: %s ***\\n\", msg.c_str());\n });\n}\n\n// syslog example (linux/osx/freebsd)\n#ifndef _WIN32\n#include \"spdlog/sinks/syslog_sink.h\"\nvoid syslog_example() {\n std::string ident = \"spdlog-example\";\n auto syslog_logger = spdlog::syslog_logger_mt(\"syslog\", ident, LOG_PID);\n syslog_logger->warn(\"This is warning that will end up in syslog.\");\n}\n#endif\n\n// Android example.\n#if defined(__ANDROID__)\n#include \"spdlog/sinks/android_sink.h\"\nvoid android_example() {\n std::string tag = \"spdlog-android\";\n auto android_logger = spdlog::android_logger_mt(\"android\", tag);\n android_logger->critical(\"Use \\\"adb shell logcat\\\" to view this message.\");\n}\n#endif\n\n// Log patterns can contain custom flags.\n// this will add custom flag '%*' which will be bound to a instance\n#include \"spdlog/pattern_formatter.h\"\nclass my_formatter_flag : public spdlog::custom_flag_formatter {\npublic:\n void format(const spdlog::details::log_msg &,\n const std::tm &,\n spdlog::memory_buf_t &dest) override {\n std::string some_txt = \"custom-flag\";\n dest.append(some_txt.data(), some_txt.data() + some_txt.size());\n }\n\n std::unique_ptr clone() const override {\n return spdlog::details::make_unique();\n }\n};\n\nvoid custom_flags_example() {\n using spdlog::details::make_unique; // for pre c++14\n auto formatter = make_unique();\n formatter->add_flag('*').set_pattern(\"[%n] [%*] [%^%l%$] %v\");\n // set the new formatter using spdlog::set_formatter(formatter) or\n // logger->set_formatter(formatter) spdlog::set_formatter(std::move(formatter));\n}\n\nvoid file_events_example() {\n // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications\n spdlog::file_event_handlers handlers;\n handlers.before_open = [](spdlog::filename_t filename) {\n spdlog::info(\"Before opening {}\", filename);\n };\n handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) {\n spdlog::info(\"After opening {}\", filename);\n fputs(\"After opening\\n\", fstream);\n };\n handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) {\n spdlog::info(\"Before closing {}\", filename);\n fputs(\"Before closing\\n\", fstream);\n };\n handlers.after_close = [](spdlog::filename_t filename) {\n spdlog::info(\"After closing {}\", filename);\n };\n auto file_sink = std::make_shared(\"logs/events-sample.txt\",\n true, handlers);\n spdlog::logger my_logger(\"some_logger\", file_sink);\n my_logger.info(\"Some log line\");\n}\n\nvoid replace_default_logger_example() {\n // store the old logger so we don't break other examples.\n auto old_logger = spdlog::default_logger();\n\n auto new_logger = spdlog::basic_logger_mt(\"new_default_logger\", \"logs/somelog.txt\", true);\n spdlog::set_default_logger(std::move(new_logger));\n spdlog::set_level(spdlog::level::info);\n spdlog::debug(\"This message should not be displayed!\");\n spdlog::set_level(spdlog::level::trace);\n spdlog::debug(\"This message should be displayed..\");\n spdlog::set_default_logger(std::move(old_logger));\n}\n\n// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread\n// local storage. Each thread maintains its own MDC, which loggers use to append diagnostic\n// information to log outputs. Note: it is not supported in asynchronous mode due to its reliance on\n// thread-local storage.\n\n#ifndef SPDLOG_NO_TLS\n#include \"spdlog/mdc.h\"\nvoid mdc_example() {\n spdlog::mdc::put(\"key1\", \"value1\");\n spdlog::mdc::put(\"key2\", \"value2\");\n // if not using the default format, you can use the %& formatter to print mdc data as well\n spdlog::set_pattern(\"[%H:%M:%S %z] [%^%L%$] [%&] %v\");\n spdlog::info(\"Some log message with context\");\n}\n#else\nvoid mdc_example() {\n // if TLS feature is disabled\n}\n#endif\n" }, { "path": "include/spdlog/async.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n//\n// Async logging using global thread pool\n// All loggers created here share same global thread pool.\n// Each log message is pushed to a queue along with a shared pointer to the\n// logger.\n// If a logger deleted while having pending messages in the queue, it's actual\n// destruction will defer\n// until all its messages are processed by the thread pool.\n// This is because each message in the queue holds a shared_ptr to the\n// originating logger.\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\n\nnamespace details {\nstatic const size_t default_async_q_size = 8192;\n}\n\n// async logger factory - creates async loggers backed with thread pool.\n// if a global thread pool doesn't already exist, create it with default queue\n// size of 8192 items and single thread.\ntemplate \nstruct async_factory_impl {\n template \n static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) {\n auto ®istry_inst = details::registry::instance();\n\n // create global thread pool if not already exists..\n\n auto &mutex = registry_inst.tp_mutex();\n std::lock_guard tp_lock(mutex);\n auto tp = registry_inst.get_tp();\n if (tp == nullptr) {\n tp = std::make_shared(details::default_async_q_size, 1U);\n registry_inst.set_tp(tp);\n }\n\n auto sink = std::make_shared(std::forward(args)...);\n auto new_logger = std::make_shared(std::move(logger_name), std::move(sink),\n std::move(tp), OverflowPolicy);\n registry_inst.initialize_logger(new_logger);\n return new_logger;\n }\n};\n\nusing async_factory = async_factory_impl;\nusing async_factory_nonblock = async_factory_impl;\n\ntemplate \ninline std::shared_ptr create_async(std::string logger_name,\n SinkArgs &&...sink_args) {\n return async_factory::create(std::move(logger_name),\n std::forward(sink_args)...);\n}\n\ntemplate \ninline std::shared_ptr create_async_nb(std::string logger_name,\n SinkArgs &&...sink_args) {\n return async_factory_nonblock::create(std::move(logger_name),\n std::forward(sink_args)...);\n}\n\n// set global thread pool.\ninline void init_thread_pool(size_t q_size,\n size_t thread_count,\n std::function on_thread_start,\n std::function on_thread_stop) {\n auto tp = std::make_shared(q_size, thread_count, on_thread_start,\n on_thread_stop);\n details::registry::instance().set_tp(std::move(tp));\n}\n\ninline void init_thread_pool(size_t q_size,\n size_t thread_count,\n std::function on_thread_start) {\n init_thread_pool(q_size, thread_count, on_thread_start, [] {});\n}\n\ninline void init_thread_pool(size_t q_size, size_t thread_count) {\n init_thread_pool(q_size, thread_count, [] {}, [] {});\n}\n\n// get the global thread pool.\ninline std::shared_ptr thread_pool() {\n return details::registry::instance().get_tp();\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/async_logger-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n\nSPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,\n sinks_init_list sinks_list,\n std::weak_ptr tp,\n async_overflow_policy overflow_policy)\n : async_logger(std::move(logger_name),\n sinks_list.begin(),\n sinks_list.end(),\n std::move(tp),\n overflow_policy) {}\n\nSPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name,\n sink_ptr single_sink,\n std::weak_ptr tp,\n async_overflow_policy overflow_policy)\n : async_logger(\n std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {}\n\n// send the log message to the thread pool\nSPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){\n SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){\n pool_ptr -> post_log(shared_from_this(), msg, overflow_policy_);\n}\nelse {\n throw_spdlog_ex(\"async log: thread pool doesn't exist anymore\");\n}\n}\nSPDLOG_LOGGER_CATCH(msg.source)\n}\n\n// send flush request to the thread pool\nSPDLOG_INLINE void spdlog::async_logger::flush_(){\n SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){\n pool_ptr -> post_flush(shared_from_this(), overflow_policy_);\n}\nelse {\n throw_spdlog_ex(\"async flush: thread pool doesn't exist anymore\");\n}\n}\nSPDLOG_LOGGER_CATCH(source_loc())\n}\n\n//\n// backend functions - called from the thread pool to do the actual job\n//\nSPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &incoming_log_msg) {\n for (auto &sink : sinks_) {\n if (sink->should_log(incoming_log_msg.level)) {\n SPDLOG_TRY { sink->log(incoming_log_msg); }\n SPDLOG_LOGGER_CATCH(incoming_log_msg.source)\n }\n }\n\n if (should_flush_(incoming_log_msg)) {\n backend_flush_();\n }\n}\n\nSPDLOG_INLINE void spdlog::async_logger::backend_flush_() {\n for (auto &sink : sinks_) {\n SPDLOG_TRY { sink->flush(); }\n SPDLOG_LOGGER_CATCH(source_loc())\n }\n}\n\nSPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) {\n auto cloned = std::make_shared(*this);\n cloned->name_ = std::move(new_name);\n return cloned;\n}\n" }, { "path": "include/spdlog/async_logger.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// Fast asynchronous logger.\n// Uses pre allocated queue.\n// Creates a single back thread to pop messages from the queue and log them.\n//\n// Upon each log write the logger:\n// 1. Checks if its log level is enough to log the message\n// 2. Push a new copy of the message to a queue (or block the caller until\n// space is available in the queue)\n// Upon destruction, logs all remaining messages in the queue before\n// destructing..\n\n#include \n\nnamespace spdlog {\n\n// Async overflow policy - block by default.\nenum class async_overflow_policy {\n block, // Block until message can be enqueued\n overrun_oldest, // Discard oldest message in the queue if full when trying to\n // add new item.\n discard_new // Discard new message if the queue is full when trying to add new item.\n};\n\nnamespace details {\nclass thread_pool;\n}\n\nclass SPDLOG_API async_logger final : public std::enable_shared_from_this,\n public logger {\n friend class details::thread_pool;\n\npublic:\n template \n async_logger(std::string logger_name,\n It begin,\n It end,\n std::weak_ptr tp,\n async_overflow_policy overflow_policy = async_overflow_policy::block)\n : logger(std::move(logger_name), begin, end),\n thread_pool_(std::move(tp)),\n overflow_policy_(overflow_policy) {}\n\n async_logger(std::string logger_name,\n sinks_init_list sinks_list,\n std::weak_ptr tp,\n async_overflow_policy overflow_policy = async_overflow_policy::block);\n\n async_logger(std::string logger_name,\n sink_ptr single_sink,\n std::weak_ptr tp,\n async_overflow_policy overflow_policy = async_overflow_policy::block);\n\n std::shared_ptr clone(std::string new_name) override;\n\nprotected:\n void sink_it_(const details::log_msg &msg) override;\n void flush_() override;\n void backend_sink_it_(const details::log_msg &incoming_log_msg);\n void backend_flush_();\n\nprivate:\n std::weak_ptr thread_pool_;\n async_overflow_policy overflow_policy_;\n};\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"async_logger-inl.h\"\n#endif\n" }, { "path": "include/spdlog/cfg/argv.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n#include \n#include \n\n//\n// Init log levels using each argv entry that starts with \"SPDLOG_LEVEL=\"\n//\n// set all loggers to debug level:\n// example.exe \"SPDLOG_LEVEL=debug\"\n\n// set logger1 to trace level\n// example.exe \"SPDLOG_LEVEL=logger1=trace\"\n\n// turn off all logging except for logger1 and logger2:\n// example.exe \"SPDLOG_LEVEL=off,logger1=debug,logger2=info\"\n\nnamespace spdlog {\nnamespace cfg {\n\n// search for SPDLOG_LEVEL= in the args and use it to init the levels\ninline void load_argv_levels(int argc, const char **argv) {\n const std::string spdlog_level_prefix = \"SPDLOG_LEVEL=\";\n for (int i = 1; i < argc; i++) {\n std::string arg = argv[i];\n if (arg.find(spdlog_level_prefix) == 0) {\n const auto levels_spec = arg.substr(spdlog_level_prefix.size());\n helpers::load_levels(levels_spec);\n }\n }\n}\n\ninline void load_argv_levels(int argc, char **argv) {\n load_argv_levels(argc, const_cast(argv));\n}\n\n} // namespace cfg\n} // namespace spdlog\n" }, { "path": "include/spdlog/cfg/env.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n#include \n#include \n#include \n\n//\n// Init levels and patterns from env variables SPDLOG_LEVEL\n// Inspired from Rust's \"env_logger\" crate (https://crates.io/crates/env_logger).\n// Note - fallback to \"info\" level on unrecognized levels\n//\n// Examples:\n//\n// set global level to debug:\n// export SPDLOG_LEVEL=debug\n//\n// turn off all logging except for logger1:\n// export SPDLOG_LEVEL=\"off,logger1=debug\"\n//\n\n// turn off all logging except for logger1 and logger2:\n// export SPDLOG_LEVEL=\"off,logger1=debug,logger2=info\"\n\nnamespace spdlog {\nnamespace cfg {\ninline void load_env_levels(const char* var = \"SPDLOG_LEVEL\") {\n const auto levels_spec = details::os::getenv(var);\n if (!levels_spec.empty()) {\n helpers::load_levels(levels_spec);\n }\n}\n\n} // namespace cfg\n} // namespace spdlog\n" }, { "path": "include/spdlog/cfg/helpers-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace cfg {\nnamespace helpers {\n\n// inplace convert to lowercase\ninline std::string &to_lower_(std::string &str) {\n std::transform(str.begin(), str.end(), str.begin(), [](char ch) {\n return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);\n });\n return str;\n}\n\n// inplace trim spaces\ninline std::string &trim_(std::string &str) {\n const char *spaces = \" \\n\\r\\t\";\n str.erase(str.find_last_not_of(spaces) + 1);\n str.erase(0, str.find_first_not_of(spaces));\n return str;\n}\n\n// return (name,value) trimmed pair from the given \"name = value\" string.\n// return empty string on missing parts\n// \"key=val\" => (\"key\", \"val\")\n// \" key = val \" => (\"key\", \"val\")\n// \"key=\" => (\"key\", \"\")\n// \"val\" => (\"\", \"val\")\n\ninline std::pair extract_kv_(char sep, const std::string &str) {\n auto n = str.find(sep);\n std::string k, v;\n if (n == std::string::npos) {\n v = str;\n } else {\n k = str.substr(0, n);\n v = str.substr(n + 1);\n }\n return std::make_pair(trim_(k), trim_(v));\n}\n\n// return vector of key/value pairs from a sequence of \"K1=V1,K2=V2,..\"\n// \"a=AAA,b=BBB,c=CCC,..\" => {(\"a\",\"AAA\"),(\"b\",\"BBB\"),(\"c\", \"CCC\"),...}\ninline std::unordered_map extract_key_vals_(const std::string &str) {\n std::string token;\n std::istringstream token_stream(str);\n std::unordered_map rv{};\n while (std::getline(token_stream, token, ',')) {\n if (token.empty()) {\n continue;\n }\n auto kv = extract_kv_('=', token);\n rv[kv.first] = kv.second;\n }\n return rv;\n}\n\nSPDLOG_INLINE void load_levels(const std::string &levels_spec) {\n if (levels_spec.empty() || levels_spec.size() >= 32768) {\n return;\n }\n\n auto key_vals = extract_key_vals_(levels_spec);\n std::unordered_map levels;\n level::level_enum global_level = level::info;\n bool global_level_found = false;\n\n for (auto &name_level : key_vals) {\n const auto &logger_name = name_level.first;\n const auto &level_name = to_lower_(name_level.second);\n const auto level = level::from_str(level_name);\n // ignore unrecognized level names\n if (level == level::off && level_name != \"off\") {\n continue;\n }\n if (logger_name.empty()) // no logger name indicates global level\n {\n global_level_found = true;\n global_level = level;\n } else {\n levels[logger_name] = level;\n }\n }\n\n details::registry::instance().set_levels(std::move(levels),\n global_level_found ? &global_level : nullptr);\n}\n\n} // namespace helpers\n} // namespace cfg\n} // namespace spdlog\n" }, { "path": "include/spdlog/cfg/helpers.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\nnamespace cfg {\nnamespace helpers {\n//\n// Init levels from given string\n//\n// Examples:\n//\n// set global level to debug: \"debug\"\n// turn off all logging except for logger1: \"off,logger1=debug\"\n// turn off all logging except for logger1 and logger2: \"off,logger1=debug,logger2=info\"\n//\nSPDLOG_API void load_levels(const std::string &levels_spec);\n} // namespace helpers\n\n} // namespace cfg\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"helpers-inl.h\"\n#endif // SPDLOG_HEADER_ONLY\n" }, { "path": "include/spdlog/common-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace level {\n\n#if __cplusplus >= 201703L\nconstexpr\n#endif\n static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;\n\nstatic const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;\n\nSPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {\n return level_string_views[l];\n}\n\nSPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {\n return short_level_names[l];\n}\n\nSPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT {\n auto it = std::find_if(std::begin(level_string_views), std::end(level_string_views),\n [&name](const string_view_t &level_name) {\n return level_name.size() == name.size() &&\n std::equal(name.begin(), name.end(), level_name.begin(),\n [](char a, char b) {\n return std::tolower(static_cast(a)) ==\n std::tolower(static_cast(b));\n });\n });\n if (it != std::end(level_string_views))\n return static_cast(std::distance(std::begin(level_string_views), it));\n\n // check also for \"warn\" and \"err\" before giving up..\n auto iequals = [](const std::string &a, const std::string &b) {\n return a.size() == b.size() &&\n std::equal(a.begin(), a.end(), b.begin(), [](char ac, char bc) {\n return std::tolower(static_cast(ac)) ==\n std::tolower(static_cast(bc));\n });\n };\n\n if (iequals(name, \"warn\")) {\n return level::warn;\n }\n if (iequals(name, \"err\")) {\n return level::err;\n }\n return level::off;\n}\n} // namespace level\n\nSPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)\n : msg_(std::move(msg)) {}\n\nSPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {\n#ifdef SPDLOG_USE_STD_FORMAT\n msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();\n#else\n memory_buf_t outbuf;\n fmt::format_system_error(outbuf, last_errno, msg.c_str());\n msg_ = fmt::to_string(outbuf);\n#endif\n}\n\nSPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); }\n\nSPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) {\n SPDLOG_THROW(spdlog_ex(msg, last_errno));\n}\n\nSPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/common.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef SPDLOG_USE_STD_FORMAT\n#include \n#if __cpp_lib_format >= 202207L\n#include \n#else\n#include \n#endif\n#endif\n\n#ifdef SPDLOG_COMPILED_LIB\n#undef SPDLOG_HEADER_ONLY\n#if defined(SPDLOG_SHARED_LIB)\n#if defined(_WIN32)\n#ifdef spdlog_EXPORTS\n#define SPDLOG_API __declspec(dllexport)\n#else // !spdlog_EXPORTS\n#define SPDLOG_API __declspec(dllimport)\n#endif\n#else // !defined(_WIN32)\n#define SPDLOG_API __attribute__((visibility(\"default\")))\n#endif\n#else // !defined(SPDLOG_SHARED_LIB)\n#define SPDLOG_API\n#endif\n#define SPDLOG_INLINE\n#else // !defined(SPDLOG_COMPILED_LIB)\n#define SPDLOG_API\n#define SPDLOG_HEADER_ONLY\n#define SPDLOG_INLINE inline\n#endif // #ifdef SPDLOG_COMPILED_LIB\n\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT) && \\\n FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8\n#define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)\n#define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)\n#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\n#include \n#endif\n#else\n#define SPDLOG_FMT_RUNTIME(format_string) format_string\n#define SPDLOG_FMT_STRING(format_string) format_string\n#endif\n\n// visual studio up to 2013 does not support noexcept nor constexpr\n#if defined(_MSC_VER) && (_MSC_VER < 1900)\n#define SPDLOG_NOEXCEPT _NOEXCEPT\n#define SPDLOG_CONSTEXPR\n#else\n#define SPDLOG_NOEXCEPT noexcept\n#define SPDLOG_CONSTEXPR constexpr\n#endif\n\n// If building with std::format, can just use constexpr, otherwise if building with fmt\n// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where\n// a constexpr function in spdlog could end up calling a non-constexpr function in fmt\n// depending on the compiler\n// If fmt determines it can't use constexpr, we should inline the function instead\n#ifdef SPDLOG_USE_STD_FORMAT\n#define SPDLOG_CONSTEXPR_FUNC constexpr\n#else // Being built with fmt\n#if FMT_USE_CONSTEXPR\n#define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR\n#else\n#define SPDLOG_CONSTEXPR_FUNC inline\n#endif\n#endif\n\n#if defined(__GNUC__) || defined(__clang__)\n#define SPDLOG_DEPRECATED __attribute__((deprecated))\n#elif defined(_MSC_VER)\n#define SPDLOG_DEPRECATED __declspec(deprecated)\n#else\n#define SPDLOG_DEPRECATED\n#endif\n\n// disable thread local on msvc 2013\n#ifndef SPDLOG_NO_TLS\n#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)\n#define SPDLOG_NO_TLS 1\n#endif\n#endif\n\n#ifndef SPDLOG_FUNCTION\n#define SPDLOG_FUNCTION static_cast(__FUNCTION__)\n#endif\n\n#ifdef SPDLOG_NO_EXCEPTIONS\n#define SPDLOG_TRY\n#define SPDLOG_THROW(ex) \\\n do { \\\n printf(\"spdlog fatal error: %s\\n\", ex.what()); \\\n std::abort(); \\\n } while (0)\n#define SPDLOG_CATCH_STD\n#else\n#define SPDLOG_TRY try\n#define SPDLOG_THROW(ex) throw(ex)\n#define SPDLOG_CATCH_STD \\\n catch (const std::exception &) { \\\n }\n#endif\n\nnamespace spdlog {\n\nclass formatter;\n\nnamespace sinks {\nclass sink;\n}\n\n#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)\nusing filename_t = std::wstring;\n// allow macro expansion to occur in SPDLOG_FILENAME_T\n#define SPDLOG_FILENAME_T_INNER(s) L##s\n#define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)\n#else\nusing filename_t = std::string;\n#define SPDLOG_FILENAME_T(s) s\n#endif\n\nusing log_clock = std::chrono::system_clock;\nusing sink_ptr = std::shared_ptr;\nusing sinks_init_list = std::initializer_list;\nusing err_handler = std::function;\n#ifdef SPDLOG_USE_STD_FORMAT\nnamespace fmt_lib = std;\n\nusing string_view_t = std::string_view;\nusing memory_buf_t = std::string;\n\ntemplate \n#if __cpp_lib_format >= 202207L\nusing format_string_t = std::format_string;\n#else\nusing format_string_t = std::string_view;\n#endif\n\ntemplate \nstruct is_convertible_to_basic_format_string\n : std::integral_constant>::value> {};\n\n#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\nusing wstring_view_t = std::wstring_view;\nusing wmemory_buf_t = std::wstring;\n\ntemplate \n#if __cpp_lib_format >= 202207L\nusing wformat_string_t = std::wformat_string;\n#else\nusing wformat_string_t = std::wstring_view;\n#endif\n#endif\n#define SPDLOG_BUF_TO_STRING(x) x\n#else // use fmt lib instead of std::format\nnamespace fmt_lib = fmt;\n\nusing string_view_t = fmt::basic_string_view;\nusing memory_buf_t = fmt::basic_memory_buffer;\n\ntemplate \nusing format_string_t = fmt::format_string;\n\ntemplate \nusing remove_cvref_t = typename std::remove_cv::type>::type;\n\ntemplate \n#if FMT_VERSION >= 90101\nusing fmt_runtime_string = fmt::runtime_format_string;\n#else\nusing fmt_runtime_string = fmt::basic_runtime;\n#endif\n\n// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the\n// condition from basic_format_string here, in addition, fmt::basic_runtime is only\n// convertible to basic_format_string but not basic_string_view\ntemplate \nstruct is_convertible_to_basic_format_string\n : std::integral_constant>::value ||\n std::is_same, fmt_runtime_string>::value> {\n};\n\n#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\nusing wstring_view_t = fmt::basic_string_view;\nusing wmemory_buf_t = fmt::basic_memory_buffer;\n\ntemplate \nusing wformat_string_t = fmt::wformat_string;\n#endif\n#define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)\n#endif\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\n#ifndef _WIN32\n#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows\n#endif // _WIN32\n#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT\n\ntemplate \nstruct is_convertible_to_any_format_string\n : std::integral_constant::value ||\n is_convertible_to_basic_format_string::value> {};\n\n#if defined(SPDLOG_NO_ATOMIC_LEVELS)\nusing level_t = details::null_atomic_int;\n#else\nusing level_t = std::atomic;\n#endif\n\n#define SPDLOG_LEVEL_TRACE 0\n#define SPDLOG_LEVEL_DEBUG 1\n#define SPDLOG_LEVEL_INFO 2\n#define SPDLOG_LEVEL_WARN 3\n#define SPDLOG_LEVEL_ERROR 4\n#define SPDLOG_LEVEL_CRITICAL 5\n#define SPDLOG_LEVEL_OFF 6\n\n#if !defined(SPDLOG_ACTIVE_LEVEL)\n#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO\n#endif\n\n// Log level enum\nnamespace level {\nenum level_enum : int {\n trace = SPDLOG_LEVEL_TRACE,\n debug = SPDLOG_LEVEL_DEBUG,\n info = SPDLOG_LEVEL_INFO,\n warn = SPDLOG_LEVEL_WARN,\n err = SPDLOG_LEVEL_ERROR,\n critical = SPDLOG_LEVEL_CRITICAL,\n off = SPDLOG_LEVEL_OFF,\n n_levels\n};\n\n#define SPDLOG_LEVEL_NAME_TRACE spdlog::string_view_t(\"trace\", 5)\n#define SPDLOG_LEVEL_NAME_DEBUG spdlog::string_view_t(\"debug\", 5)\n#define SPDLOG_LEVEL_NAME_INFO spdlog::string_view_t(\"info\", 4)\n#define SPDLOG_LEVEL_NAME_WARNING spdlog::string_view_t(\"warning\", 7)\n#define SPDLOG_LEVEL_NAME_ERROR spdlog::string_view_t(\"error\", 5)\n#define SPDLOG_LEVEL_NAME_CRITICAL spdlog::string_view_t(\"critical\", 8)\n#define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t(\"off\", 3)\n\n#if !defined(SPDLOG_LEVEL_NAMES)\n#define SPDLOG_LEVEL_NAMES \\\n { \\\n SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, \\\n SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \\\n SPDLOG_LEVEL_NAME_OFF \\\n }\n#endif\n\n#if !defined(SPDLOG_SHORT_LEVEL_NAMES)\n\n#define SPDLOG_SHORT_LEVEL_NAMES \\\n { \"T\", \"D\", \"I\", \"W\", \"E\", \"C\", \"O\" }\n#endif\n\nSPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;\nSPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;\nSPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;\n\n} // namespace level\n\n//\n// Color mode used by sinks with color support.\n//\nenum class color_mode { always, automatic, never };\n\n//\n// Pattern time - specific time getting to use for pattern_formatter.\n// local time by default\n//\nenum class pattern_time_type {\n local, // log localtime\n utc // log utc\n};\n\n//\n// Log exception\n//\nclass SPDLOG_API spdlog_ex : public std::exception {\npublic:\n explicit spdlog_ex(std::string msg);\n spdlog_ex(const std::string &msg, int last_errno);\n const char *what() const SPDLOG_NOEXCEPT override;\n\nprivate:\n std::string msg_;\n};\n\n[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno);\n[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);\n\nstruct source_loc {\n SPDLOG_CONSTEXPR source_loc() = default;\n SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in)\n : filename{filename_in},\n line{line_in},\n funcname{funcname_in} {}\n\n SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; }\n const char *filename{nullptr};\n int line{0};\n const char *funcname{nullptr};\n};\n\nstruct file_event_handlers {\n file_event_handlers()\n : before_open(nullptr),\n after_open(nullptr),\n before_close(nullptr),\n after_close(nullptr) {}\n\n std::function before_open;\n std::function after_open;\n std::function before_close;\n std::function after_close;\n};\n\nnamespace details {\n\n// make_unique support for pre c++14\n#if __cplusplus >= 201402L // C++14 and beyond\nusing std::enable_if_t;\nusing std::make_unique;\n#else\ntemplate \nusing enable_if_t = typename std::enable_if::type;\n\ntemplate \nstd::unique_ptr make_unique(Args &&...args) {\n static_assert(!std::is_array::value, \"arrays not supported\");\n return std::unique_ptr(new T(std::forward(args)...));\n}\n#endif\n\n// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)\ntemplate ::value, int> = 0>\nconstexpr T conditional_static_cast(U value) {\n return static_cast(value);\n}\n\ntemplate ::value, int> = 0>\nconstexpr T conditional_static_cast(U value) {\n return value;\n}\n\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"common-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/backtracer-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\nnamespace spdlog {\nnamespace details {\nSPDLOG_INLINE backtracer::backtracer(const backtracer &other) {\n std::lock_guard lock(other.mutex_);\n enabled_ = other.enabled();\n messages_ = other.messages_;\n}\n\nSPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT {\n std::lock_guard lock(other.mutex_);\n enabled_ = other.enabled();\n messages_ = std::move(other.messages_);\n}\n\nSPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) {\n std::lock_guard lock(mutex_);\n enabled_ = other.enabled();\n messages_ = std::move(other.messages_);\n return *this;\n}\n\nSPDLOG_INLINE void backtracer::enable(size_t size) {\n std::lock_guard lock{mutex_};\n enabled_.store(true, std::memory_order_relaxed);\n messages_ = circular_q{size};\n}\n\nSPDLOG_INLINE void backtracer::disable() {\n std::lock_guard lock{mutex_};\n enabled_.store(false, std::memory_order_relaxed);\n}\n\nSPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); }\n\nSPDLOG_INLINE void backtracer::push_back(const log_msg &msg) {\n std::lock_guard lock{mutex_};\n messages_.push_back(log_msg_buffer{msg});\n}\n\nSPDLOG_INLINE bool backtracer::empty() const {\n std::lock_guard lock{mutex_};\n return messages_.empty();\n}\n\n// pop all items in the q and apply the given fun on each of them.\nSPDLOG_INLINE void backtracer::foreach_pop(std::function fun) {\n std::lock_guard lock{mutex_};\n while (!messages_.empty()) {\n auto &front_msg = messages_.front();\n fun(front_msg);\n messages_.pop_front();\n }\n}\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/backtracer.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\n#include \n#include \n#include \n\n// Store log messages in circular buffer.\n// Useful for storing debug data in case of error/warning happens.\n\nnamespace spdlog {\nnamespace details {\nclass SPDLOG_API backtracer {\n mutable std::mutex mutex_;\n std::atomic enabled_{false};\n circular_q messages_;\n\npublic:\n backtracer() = default;\n backtracer(const backtracer &other);\n\n backtracer(backtracer &&other) SPDLOG_NOEXCEPT;\n backtracer &operator=(backtracer other);\n\n void enable(size_t size);\n void disable();\n bool enabled() const;\n void push_back(const log_msg &msg);\n bool empty() const;\n\n // pop all items in the q and apply the given fun on each of them.\n void foreach_pop(std::function fun);\n};\n\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"backtracer-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/circular_q.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n// circular q view of std::vector.\n#pragma once\n\n#include \n#include \n\n#include \"spdlog/common.h\"\n\nnamespace spdlog {\nnamespace details {\ntemplate \nclass circular_q {\n size_t max_items_ = 0;\n typename std::vector::size_type head_ = 0;\n typename std::vector::size_type tail_ = 0;\n size_t overrun_counter_ = 0;\n std::vector v_;\n\npublic:\n using value_type = T;\n\n // empty ctor - create a disabled queue with no elements allocated at all\n circular_q() = default;\n\n explicit circular_q(size_t max_items)\n : max_items_(max_items + 1) // one item is reserved as marker for full q\n ,\n v_(max_items_) {}\n\n circular_q(const circular_q &) = default;\n circular_q &operator=(const circular_q &) = default;\n\n // move cannot be default,\n // since we need to reset head_, tail_, etc to zero in the moved object\n circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); }\n\n circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT {\n copy_moveable(std::move(other));\n return *this;\n }\n\n // push back, overrun (oldest) item if no room left\n void push_back(T &&item) {\n if (max_items_ > 0) {\n v_[tail_] = std::move(item);\n tail_ = (tail_ + 1) % max_items_;\n\n if (tail_ == head_) // overrun last item if full\n {\n head_ = (head_ + 1) % max_items_;\n ++overrun_counter_;\n }\n }\n }\n\n // Return reference to the front item.\n // If there are no elements in the container, the behavior is undefined.\n const T &front() const { return v_[head_]; }\n\n T &front() { return v_[head_]; }\n\n // Return number of elements actually stored\n size_t size() const {\n if (tail_ >= head_) {\n return tail_ - head_;\n } else {\n return max_items_ - (head_ - tail_);\n }\n }\n\n // Return const reference to item by index.\n // If index is out of range 0…size()-1, the behavior is undefined.\n const T &at(size_t i) const {\n assert(i < size());\n return v_[(head_ + i) % max_items_];\n }\n\n // Pop item from front.\n // If there are no elements in the container, the behavior is undefined.\n void pop_front() { head_ = (head_ + 1) % max_items_; }\n\n bool empty() const { return tail_ == head_; }\n\n bool full() const {\n // head is ahead of the tail by 1\n if (max_items_ > 0) {\n return ((tail_ + 1) % max_items_) == head_;\n }\n return false;\n }\n\n size_t overrun_counter() const { return overrun_counter_; }\n\n void reset_overrun_counter() { overrun_counter_ = 0; }\n\nprivate:\n // copy from other&& and reset it to disabled state\n void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT {\n max_items_ = other.max_items_;\n head_ = other.head_;\n tail_ = other.tail_;\n overrun_counter_ = other.overrun_counter_;\n v_ = std::move(other.v_);\n\n // put &&other in disabled, but valid state\n other.max_items_ = 0;\n other.head_ = other.tail_ = 0;\n other.overrun_counter_ = 0;\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/console_globals.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\nstruct console_mutex {\n using mutex_t = std::mutex;\n static mutex_t &mutex() {\n static mutex_t s_mutex;\n return s_mutex;\n }\n};\n\nstruct console_nullmutex {\n using mutex_t = null_mutex;\n static mutex_t &mutex() {\n static mutex_t s_mutex;\n return s_mutex;\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/file_helper-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\nSPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)\n : event_handlers_(event_handlers) {}\n\nSPDLOG_INLINE file_helper::~file_helper() { close(); }\n\nSPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) {\n close();\n filename_ = fname;\n\n auto *mode = SPDLOG_FILENAME_T(\"ab\");\n auto *trunc_mode = SPDLOG_FILENAME_T(\"wb\");\n\n if (event_handlers_.before_open) {\n event_handlers_.before_open(filename_);\n }\n for (int tries = 0; tries < open_tries_; ++tries) {\n // create containing folder if not exists already.\n os::create_dir(os::dir_name(fname));\n if (truncate) {\n // Truncate by opening-and-closing a tmp file in \"wb\" mode, always\n // opening the actual log-we-write-to in \"ab\" mode, since that\n // interacts more politely with eternal processes that might\n // rotate/truncate the file underneath us.\n std::FILE *tmp;\n if (os::fopen_s(&tmp, fname, trunc_mode)) {\n continue;\n }\n std::fclose(tmp);\n }\n if (!os::fopen_s(&fd_, fname, mode)) {\n if (event_handlers_.after_open) {\n event_handlers_.after_open(filename_, fd_);\n }\n return;\n }\n\n details::os::sleep_for_millis(open_interval_);\n }\n\n throw_spdlog_ex(\"Failed opening file \" + os::filename_to_str(filename_) + \" for writing\",\n errno);\n}\n\nSPDLOG_INLINE void file_helper::reopen(bool truncate) {\n if (filename_.empty()) {\n throw_spdlog_ex(\"Failed re opening file - was not opened before\");\n }\n this->open(filename_, truncate);\n}\n\nSPDLOG_INLINE void file_helper::flush() {\n if (std::fflush(fd_) != 0) {\n throw_spdlog_ex(\"Failed flush to file \" + os::filename_to_str(filename_), errno);\n }\n}\n\nSPDLOG_INLINE void file_helper::sync() {\n if (!os::fsync(fd_)) {\n throw_spdlog_ex(\"Failed to fsync file \" + os::filename_to_str(filename_), errno);\n }\n}\n\nSPDLOG_INLINE void file_helper::close() {\n if (fd_ != nullptr) {\n if (event_handlers_.before_close) {\n event_handlers_.before_close(filename_, fd_);\n }\n\n std::fclose(fd_);\n fd_ = nullptr;\n\n if (event_handlers_.after_close) {\n event_handlers_.after_close(filename_);\n }\n }\n}\n\nSPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {\n if (fd_ == nullptr) return;\n size_t msg_size = buf.size();\n auto data = buf.data();\n\n if (!details::os::fwrite_bytes(data, msg_size, fd_)) {\n throw_spdlog_ex(\"Failed writing to file \" + os::filename_to_str(filename_), errno);\n }\n}\n\nSPDLOG_INLINE size_t file_helper::size() const {\n if (fd_ == nullptr) {\n throw_spdlog_ex(\"Cannot use size() on closed file \" + os::filename_to_str(filename_));\n }\n return os::filesize(fd_);\n}\n\nSPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; }\n\n//\n// return file path and its extension:\n//\n// \"mylog.txt\" => (\"mylog\", \".txt\")\n// \"mylog\" => (\"mylog\", \"\")\n// \"mylog.\" => (\"mylog.\", \"\")\n// \"/dir1/dir2/mylog.txt\" => (\"/dir1/dir2/mylog\", \".txt\")\n//\n// the starting dot in filenames is ignored (hidden files):\n//\n// \".mylog\" => (\".mylog\". \"\")\n// \"my_folder/.mylog\" => (\"my_folder/.mylog\", \"\")\n// \"my_folder/.mylog.txt\" => (\"my_folder/.mylog\", \".txt\")\nSPDLOG_INLINE std::tuple file_helper::split_by_extension(\n const filename_t &fname) {\n auto ext_index = fname.rfind('.');\n\n // no valid extension found - return whole path and empty string as\n // extension\n if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) {\n return std::make_tuple(fname, filename_t());\n }\n\n // treat cases like \"/etc/rc.d/somelogfile or \"/abc/.hiddenfile\"\n auto folder_index = fname.find_last_of(details::os::folder_seps_filename);\n if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {\n return std::make_tuple(fname, filename_t());\n }\n\n // finally - return a valid base and extension tuple\n return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));\n}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/file_helper.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\n// Helper class for file sinks.\n// When failing to open a file, retry several times(5) with a delay interval(10 ms).\n// Throw spdlog_ex exception on errors.\n\nclass SPDLOG_API file_helper {\npublic:\n file_helper() = default;\n explicit file_helper(const file_event_handlers &event_handlers);\n\n file_helper(const file_helper &) = delete;\n file_helper &operator=(const file_helper &) = delete;\n ~file_helper();\n\n void open(const filename_t &fname, bool truncate = false);\n void reopen(bool truncate);\n void flush();\n void sync();\n void close();\n void write(const memory_buf_t &buf);\n size_t size() const;\n const filename_t &filename() const;\n\n //\n // return file path and its extension:\n //\n // \"mylog.txt\" => (\"mylog\", \".txt\")\n // \"mylog\" => (\"mylog\", \"\")\n // \"mylog.\" => (\"mylog.\", \"\")\n // \"/dir1/dir2/mylog.txt\" => (\"/dir1/dir2/mylog\", \".txt\")\n //\n // the starting dot in filenames is ignored (hidden files):\n //\n // \".mylog\" => (\".mylog\". \"\")\n // \"my_folder/.mylog\" => (\"my_folder/.mylog\", \"\")\n // \"my_folder/.mylog.txt\" => (\"my_folder/.mylog\", \".txt\")\n static std::tuple split_by_extension(const filename_t &fname);\n\nprivate:\n const int open_tries_ = 5;\n const unsigned int open_interval_ = 10;\n std::FILE *fd_{nullptr};\n filename_t filename_;\n file_event_handlers event_handlers_;\n};\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"file_helper-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/fmt_helper.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef SPDLOG_USE_STD_FORMAT\n#include \n#include \n#endif\n\n// Some fmt helpers to efficiently format and pad ints and strings\nnamespace spdlog {\nnamespace details {\nnamespace fmt_helper {\n\ninline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) {\n auto *buf_ptr = view.data();\n dest.append(buf_ptr, buf_ptr + view.size());\n}\n\n#ifdef SPDLOG_USE_STD_FORMAT\ntemplate \ninline void append_int(T n, memory_buf_t &dest) {\n // Buffer should be large enough to hold all digits (digits10 + 1) and a sign\n SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits::digits10 + 2;\n char buf[BUF_SIZE];\n\n auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);\n if (ec == std::errc()) {\n dest.append(buf, ptr);\n } else {\n throw_spdlog_ex(\"Failed to format int\", static_cast(ec));\n }\n}\n#else\ntemplate \ninline void append_int(T n, memory_buf_t &dest) {\n fmt::format_int i(n);\n dest.append(i.data(), i.data() + i.size());\n}\n#endif\n\ntemplate \nSPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) {\n // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912\n unsigned int count = 1;\n for (;;) {\n // Integer division is slow so do it for a group of four digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n if (n < 10) return count;\n if (n < 100) return count + 1;\n if (n < 1000) return count + 2;\n if (n < 10000) return count + 3;\n n /= 10000u;\n count += 4;\n }\n}\n\ntemplate \ninline unsigned int count_digits(T n) {\n using count_type =\n typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;\n#ifdef SPDLOG_USE_STD_FORMAT\n return count_digits_fallback(static_cast(n));\n#else\n return static_cast(fmt::\n// fmt 7.0.0 renamed the internal namespace to detail.\n// See: https://github.com/fmtlib/fmt/issues/1538\n#if FMT_VERSION < 70000\n internal\n#else\n detail\n#endif\n ::count_digits(static_cast(n)));\n#endif\n}\n\ninline void pad2(int n, memory_buf_t &dest) {\n if (n >= 0 && n < 100) // 0-99\n {\n dest.push_back(static_cast('0' + n / 10));\n dest.push_back(static_cast('0' + n % 10));\n } else // unlikely, but just in case, let fmt deal with it\n {\n fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING(\"{:02}\"), n);\n }\n}\n\ntemplate \ninline void pad_uint(T n, unsigned int width, memory_buf_t &dest) {\n static_assert(std::is_unsigned::value, \"pad_uint must get unsigned T\");\n for (auto digits = count_digits(n); digits < width; digits++) {\n dest.push_back('0');\n }\n append_int(n, dest);\n}\n\ntemplate \ninline void pad3(T n, memory_buf_t &dest) {\n static_assert(std::is_unsigned::value, \"pad3 must get unsigned T\");\n if (n < 1000) {\n dest.push_back(static_cast(n / 100 + '0'));\n n = n % 100;\n dest.push_back(static_cast((n / 10) + '0'));\n dest.push_back(static_cast((n % 10) + '0'));\n } else {\n append_int(n, dest);\n }\n}\n\ntemplate \ninline void pad6(T n, memory_buf_t &dest) {\n pad_uint(n, 6, dest);\n}\n\ntemplate \ninline void pad9(T n, memory_buf_t &dest) {\n pad_uint(n, 9, dest);\n}\n\n// return fraction of a second of the given time_point.\n// e.g.\n// fraction(tp) -> will return the millis part of the second\ntemplate \ninline ToDuration time_fraction(log_clock::time_point tp) {\n using std::chrono::duration_cast;\n using std::chrono::seconds;\n auto duration = tp.time_since_epoch();\n auto secs = duration_cast(duration);\n return duration_cast(duration) - duration_cast(secs);\n}\n\n} // namespace fmt_helper\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/log_msg-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n\nnamespace spdlog {\nnamespace details {\n\nSPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time,\n spdlog::source_loc loc,\n string_view_t a_logger_name,\n spdlog::level::level_enum lvl,\n spdlog::string_view_t msg)\n : logger_name(a_logger_name),\n level(lvl),\n time(log_time)\n#ifndef SPDLOG_NO_THREAD_ID\n ,\n thread_id(os::thread_id())\n#endif\n ,\n source(loc),\n payload(msg) {\n}\n\nSPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc,\n string_view_t a_logger_name,\n spdlog::level::level_enum lvl,\n spdlog::string_view_t msg)\n : log_msg(os::now(), loc, a_logger_name, lvl, msg) {}\n\nSPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name,\n spdlog::level::level_enum lvl,\n spdlog::string_view_t msg)\n : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/log_msg.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\nnamespace details {\nstruct SPDLOG_API log_msg {\n log_msg() = default;\n log_msg(log_clock::time_point log_time,\n source_loc loc,\n string_view_t logger_name,\n level::level_enum lvl,\n string_view_t msg);\n log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);\n log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);\n log_msg(const log_msg &other) = default;\n log_msg &operator=(const log_msg &other) = default;\n\n string_view_t logger_name;\n level::level_enum level{level::off};\n log_clock::time_point time;\n size_t thread_id{0};\n\n // wrapping the formatted text with color (updated by pattern_formatter).\n mutable size_t color_range_start{0};\n mutable size_t color_range_end{0};\n\n source_loc source;\n string_view_t payload;\n};\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"log_msg-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/log_msg_buffer-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\nnamespace spdlog {\nnamespace details {\n\nSPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)\n : log_msg{orig_msg} {\n buffer.append(logger_name.begin(), logger_name.end());\n buffer.append(payload.begin(), payload.end());\n update_string_views();\n}\n\nSPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)\n : log_msg{other} {\n buffer.append(logger_name.begin(), logger_name.end());\n buffer.append(payload.begin(), payload.end());\n update_string_views();\n}\n\nSPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT\n : log_msg{other},\n buffer{std::move(other.buffer)} {\n update_string_views();\n}\n\nSPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) {\n log_msg::operator=(other);\n buffer.clear();\n buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());\n update_string_views();\n return *this;\n}\n\nSPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT {\n log_msg::operator=(other);\n buffer = std::move(other.buffer);\n update_string_views();\n return *this;\n}\n\nSPDLOG_INLINE void log_msg_buffer::update_string_views() {\n logger_name = string_view_t{buffer.data(), logger_name.size()};\n payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};\n}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/log_msg_buffer.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n\nnamespace spdlog {\nnamespace details {\n\n// Extend log_msg with internal buffer to store its payload.\n// This is needed since log_msg holds string_views that points to stack data.\n\nclass SPDLOG_API log_msg_buffer : public log_msg {\n memory_buf_t buffer;\n void update_string_views();\n\npublic:\n log_msg_buffer() = default;\n explicit log_msg_buffer(const log_msg &orig_msg);\n log_msg_buffer(const log_msg_buffer &other);\n log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;\n log_msg_buffer &operator=(const log_msg_buffer &other);\n log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;\n};\n\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"log_msg_buffer-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/mpmc_blocking_q.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// multi producer-multi consumer blocking queue.\n// enqueue(..) - will block until room found to put the new message.\n// enqueue_nowait(..) - enqueue immediately. overruns oldest message if no \n// room left.\n// dequeue_for(..) - will block until the queue is not empty or timeout have\n// passed.\n\n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\ntemplate \nclass mpmc_blocking_queue {\npublic:\n using item_type = T;\n explicit mpmc_blocking_queue(size_t max_items)\n : q_(max_items) {}\n\n#ifndef __MINGW32__\n // try to enqueue and block if no room left\n void enqueue(T &&item) {\n {\n std::unique_lock lock(queue_mutex_);\n pop_cv_.wait(lock, [this] { return !this->q_.full(); });\n q_.push_back(std::move(item));\n }\n push_cv_.notify_one();\n }\n\n // enqueue immediately. overrun oldest message in the queue if no room left.\n void enqueue_nowait(T &&item) {\n {\n std::unique_lock lock(queue_mutex_);\n q_.push_back(std::move(item));\n }\n push_cv_.notify_one();\n }\n\n void enqueue_if_have_room(T &&item) {\n bool pushed = false;\n {\n std::unique_lock lock(queue_mutex_);\n if (!q_.full()) {\n q_.push_back(std::move(item));\n pushed = true;\n }\n }\n\n if (pushed) {\n push_cv_.notify_one();\n } else {\n ++discard_counter_;\n }\n }\n\n // dequeue with a timeout.\n // Return true, if succeeded dequeue item, false otherwise\n bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {\n {\n std::unique_lock lock(queue_mutex_);\n if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {\n return false;\n }\n popped_item = std::move(q_.front());\n q_.pop_front();\n }\n pop_cv_.notify_one();\n return true;\n }\n\n // blocking dequeue without a timeout.\n void dequeue(T &popped_item) {\n {\n std::unique_lock lock(queue_mutex_);\n push_cv_.wait(lock, [this] { return !this->q_.empty(); });\n popped_item = std::move(q_.front());\n q_.pop_front();\n }\n pop_cv_.notify_one();\n }\n\n#else\n // apparently mingw deadlocks if the mutex is released before cv.notify_one(),\n // so release the mutex at the very end each function.\n\n // try to enqueue and block if no room left\n void enqueue(T &&item) {\n std::unique_lock lock(queue_mutex_);\n pop_cv_.wait(lock, [this] { return !this->q_.full(); });\n q_.push_back(std::move(item));\n push_cv_.notify_one();\n }\n\n // enqueue immediately. overrun oldest message in the queue if no room left.\n void enqueue_nowait(T &&item) {\n std::unique_lock lock(queue_mutex_);\n q_.push_back(std::move(item));\n push_cv_.notify_one();\n }\n\n void enqueue_if_have_room(T &&item) {\n bool pushed = false;\n std::unique_lock lock(queue_mutex_);\n if (!q_.full()) {\n q_.push_back(std::move(item));\n pushed = true;\n }\n\n if (pushed) {\n push_cv_.notify_one();\n } else {\n ++discard_counter_;\n }\n }\n\n // dequeue with a timeout.\n // Return true, if succeeded dequeue item, false otherwise\n bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {\n std::unique_lock lock(queue_mutex_);\n if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {\n return false;\n }\n popped_item = std::move(q_.front());\n q_.pop_front();\n pop_cv_.notify_one();\n return true;\n }\n\n // blocking dequeue without a timeout.\n void dequeue(T &popped_item) {\n std::unique_lock lock(queue_mutex_);\n push_cv_.wait(lock, [this] { return !this->q_.empty(); });\n popped_item = std::move(q_.front());\n q_.pop_front();\n pop_cv_.notify_one();\n }\n\n#endif\n\n size_t overrun_counter() {\n std::lock_guard lock(queue_mutex_);\n return q_.overrun_counter();\n }\n\n size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }\n\n size_t size() {\n std::lock_guard lock(queue_mutex_);\n return q_.size();\n }\n\n void reset_overrun_counter() {\n std::lock_guard lock(queue_mutex_);\n q_.reset_overrun_counter();\n }\n\n void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); }\n\nprivate:\n std::mutex queue_mutex_;\n std::condition_variable push_cv_;\n std::condition_variable pop_cv_;\n spdlog::details::circular_q q_;\n std::atomic discard_counter_{0};\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/null_mutex.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n// null, no cost dummy \"mutex\" and dummy \"atomic\" int\n\nnamespace spdlog {\nnamespace details {\nstruct null_mutex {\n void lock() const {}\n void unlock() const {}\n};\n\nstruct null_atomic_int {\n int value{0};\n null_atomic_int() = default;\n\n explicit null_atomic_int(int new_value)\n : value(new_value) {}\n\n int load(std::memory_order = std::memory_order_relaxed) const { return value; }\n\n void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; }\n\n int exchange(int new_value, std::memory_order = std::memory_order_relaxed) {\n std::swap(new_value, value);\n return new_value; // return value before the call\n }\n};\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/os-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef _WIN32\n#include \n#include // for _get_osfhandle, _isatty, _fileno\n#include // for _get_pid\n\n#ifdef __MINGW32__\n#include \n#endif\n\n#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)\n#include \n#include \n#endif\n\n#include // for _mkdir/_wmkdir\n\n#else // unix\n\n#include \n#include \n\n#ifdef __linux__\n#include //Use gettid() syscall under linux to get thread id\n\n#elif defined(_AIX)\n#include // for pthread_getthrds_np\n\n#elif defined(__DragonFly__) || defined(__FreeBSD__)\n#include // for pthread_getthreadid_np\n\n#elif defined(__NetBSD__)\n#include // for _lwp_self\n\n#elif defined(__sun)\n#include // for thr_self\n#endif\n\n#endif // unix\n\n#if defined __APPLE__\n#include \n#endif\n\n#ifndef __has_feature // Clang - feature checking macros.\n#define __has_feature(x) 0 // Compatibility with non-clang compilers.\n#endif\n\nnamespace spdlog {\nnamespace details {\nnamespace os {\n\nSPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {\n#if defined __linux__ && defined SPDLOG_CLOCK_COARSE\n timespec ts;\n ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);\n return std::chrono::time_point(\n std::chrono::duration_cast(\n std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));\n\n#else\n return log_clock::now();\n#endif\n}\nSPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n std::tm tm;\n ::localtime_s(&tm, &time_tt);\n#else\n std::tm tm;\n ::localtime_r(&time_tt, &tm);\n#endif\n return tm;\n}\n\nSPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT {\n std::time_t now_t = ::time(nullptr);\n return localtime(now_t);\n}\n\nSPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n std::tm tm;\n ::gmtime_s(&tm, &time_tt);\n#else\n std::tm tm;\n ::gmtime_r(&time_tt, &tm);\n#endif\n return tm;\n}\n\nSPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT {\n std::time_t now_t = ::time(nullptr);\n return gmtime(now_t);\n}\n\n// fopen_s on non windows for writing\nSPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {\n#ifdef _WIN32\n#ifdef SPDLOG_WCHAR_FILENAMES\n *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);\n#else\n *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);\n#endif\n#if defined(SPDLOG_PREVENT_CHILD_FD)\n if (*fp != nullptr) {\n auto file_handle = reinterpret_cast(_get_osfhandle(::_fileno(*fp)));\n if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {\n ::fclose(*fp);\n *fp = nullptr;\n }\n }\n#endif\n#else // unix\n#if defined(SPDLOG_PREVENT_CHILD_FD)\n const int mode_flag = mode == SPDLOG_FILENAME_T(\"ab\") ? O_APPEND : O_TRUNC;\n const int fd =\n ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));\n if (fd == -1) {\n return true;\n }\n *fp = ::fdopen(fd, mode.c_str());\n if (*fp == nullptr) {\n ::close(fd);\n }\n#else\n *fp = ::fopen((filename.c_str()), mode.c_str());\n#endif\n#endif\n\n return *fp == nullptr;\n}\n\nSPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT {\n#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)\n return ::_wremove(filename.c_str());\n#else\n return std::remove(filename.c_str());\n#endif\n}\n\nSPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT {\n return path_exists(filename) ? remove(filename) : 0;\n}\n\nSPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT {\n#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)\n return ::_wrename(filename1.c_str(), filename2.c_str());\n#else\n return std::rename(filename1.c_str(), filename2.c_str());\n#endif\n}\n\n// Return true if path exists (file or directory)\nSPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n struct _stat buffer;\n#ifdef SPDLOG_WCHAR_FILENAMES\n return (::_wstat(filename.c_str(), &buffer) == 0);\n#else\n return (::_stat(filename.c_str(), &buffer) == 0);\n#endif\n#else // common linux/unix all have the stat system call\n struct stat buffer;\n return (::stat(filename.c_str(), &buffer) == 0);\n#endif\n}\n\n#ifdef _MSC_VER\n// avoid warning about unreachable statement at the end of filesize()\n#pragma warning(push)\n#pragma warning(disable : 4702)\n#endif\n\n// Return file size according to open FILE* object\nSPDLOG_INLINE size_t filesize(FILE *f) {\n if (f == nullptr) {\n throw_spdlog_ex(\"Failed getting file size. fd is null\");\n }\n#if defined(_WIN32) && !defined(__CYGWIN__)\n int fd = ::_fileno(f);\n#if defined(_WIN64) // 64 bits\n __int64 ret = ::_filelengthi64(fd);\n if (ret >= 0) {\n return static_cast(ret);\n }\n\n#else // windows 32 bits\n long ret = ::_filelength(fd);\n if (ret >= 0) {\n return static_cast(ret);\n }\n#endif\n\n#else // unix\n// OpenBSD and AIX doesn't compile with :: before the fileno(..)\n#if defined(__OpenBSD__) || defined(_AIX)\n int fd = fileno(f);\n#else\n int fd = ::fileno(f);\n#endif\n// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)\n#if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \\\n (defined(__LP64__) || defined(_LP64))\n struct stat64 st;\n if (::fstat64(fd, &st) == 0) {\n return static_cast(st.st_size);\n }\n#else // other unix or linux 32 bits or cygwin\n struct stat st;\n if (::fstat(fd, &st) == 0) {\n return static_cast(st.st_size);\n }\n#endif\n#endif\n throw_spdlog_ex(\"Failed getting file size from fd\", errno);\n return 0; // will not be reached.\n}\n\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif\n\n#if !defined(SPDLOG_NO_TZ_OFFSET)\n#ifdef _WIN32\n// Compare the timestamp as Local (mktime) vs UTC (_mkgmtime) to get the offset.\nSPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {\n std::tm local_tm = tm; // copy since mktime might adjust it (normalize dates, set tm_isdst)\n std::time_t local_time_t = std::mktime(&local_tm);\n if (local_time_t == -1) {\n return 0; // fallback\n }\n\n std::time_t utc_time_t = _mkgmtime(&local_tm);\n if (utc_time_t == -1) {\n return 0; // fallback\n }\n auto offset_seconds = utc_time_t - local_time_t;\n return static_cast(offset_seconds / 60);\n}\n#else\n// On unix simply use tm_gmtoff\nSPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {\n return static_cast(tm.tm_gmtoff / 60);\n}\n#endif // _WIN32\n#endif // SPDLOG_NO_TZ_OFFSET\n\n// Return current thread id as size_t\n// It exists because the std::this_thread::get_id() is much slower(especially\n// under VS 2013)\nSPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n return static_cast(::GetCurrentThreadId());\n#elif defined(__linux__)\n#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)\n#define SYS_gettid __NR_gettid\n#endif\n return static_cast(::syscall(SYS_gettid));\n#elif defined(_AIX)\n struct __pthrdsinfo buf;\n int reg_size = 0;\n pthread_t pt = pthread_self();\n int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, ®_size);\n int tid = (!retval) ? buf.__pi_tid : 0;\n return static_cast(tid);\n#elif defined(__DragonFly__) || defined(__FreeBSD__)\n return static_cast(::pthread_getthreadid_np());\n#elif defined(__NetBSD__)\n return static_cast(::_lwp_self());\n#elif defined(__OpenBSD__)\n return static_cast(::getthrid());\n#elif defined(__sun)\n return static_cast(::thr_self());\n#elif __APPLE__\n uint64_t tid;\n// There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,\n// including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.\n#ifdef MAC_OS_X_VERSION_MAX_ALLOWED\n {\n#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)\n tid = pthread_mach_thread_np(pthread_self());\n#elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060\n if (&pthread_threadid_np) {\n pthread_threadid_np(nullptr, &tid);\n } else {\n tid = pthread_mach_thread_np(pthread_self());\n }\n#else\n pthread_threadid_np(nullptr, &tid);\n#endif\n }\n#else\n pthread_threadid_np(nullptr, &tid);\n#endif\n return static_cast(tid);\n#else // Default to standard C++11 (other Unix)\n return static_cast(std::hash()(std::this_thread::get_id()));\n#endif\n}\n\n// Return current thread id as size_t (from thread local storage)\nSPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {\n#if defined(SPDLOG_NO_TLS)\n return _thread_id();\n#else // cache thread id in tls\n static thread_local const size_t tid = _thread_id();\n return tid;\n#endif\n}\n\n// This is avoid msvc issue in sleep_for that happens if the clock changes.\n// See https://github.com/gabime/spdlog/issues/609\nSPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT {\n#if defined(_WIN32)\n ::Sleep(milliseconds);\n#else\n std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));\n#endif\n}\n\n// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)\n#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)\nSPDLOG_INLINE std::string filename_to_str(const filename_t &filename) {\n memory_buf_t buf;\n wstr_to_utf8buf(filename, buf);\n return SPDLOG_BUF_TO_STRING(buf);\n}\n#else\nSPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; }\n#endif\n\nSPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n return conditional_static_cast(::GetCurrentProcessId());\n#else\n return conditional_static_cast(::getpid());\n#endif\n}\n\n// Determine if the terminal supports colors\n// Based on: https://github.com/agauniyal/rang/\nSPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n return true;\n#else\n\n static const bool result = []() {\n const char *env_colorterm_p = std::getenv(\"COLORTERM\");\n if (env_colorterm_p != nullptr) {\n return true;\n }\n\n static constexpr std::array terms = {\n {\"ansi\", \"color\", \"console\", \"cygwin\", \"gnome\", \"konsole\", \"kterm\", \"linux\", \"msys\",\n \"putty\", \"rxvt\", \"screen\", \"vt100\", \"xterm\", \"alacritty\", \"vt102\"}};\n\n const char *env_term_p = std::getenv(\"TERM\");\n if (env_term_p == nullptr) {\n return false;\n }\n\n return std::any_of(terms.begin(), terms.end(), [&](const char *term) {\n return std::strstr(env_term_p, term) != nullptr;\n });\n }();\n\n return result;\n#endif\n}\n\n// Determine if the terminal attached\n// Source: https://github.com/agauniyal/rang/\nSPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {\n#ifdef _WIN32\n return ::_isatty(_fileno(file)) != 0;\n#else\n return ::isatty(fileno(file)) != 0;\n#endif\n}\n\n#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)\nSPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {\n if (wstr.size() > static_cast((std::numeric_limits::max)()) / 4 - 1) {\n throw_spdlog_ex(\"UTF-16 string is too big to be converted to UTF-8\");\n }\n\n int wstr_size = static_cast(wstr.size());\n if (wstr_size == 0) {\n target.resize(0);\n return;\n }\n\n int result_size = static_cast(target.capacity());\n if ((wstr_size + 1) * 4 > result_size) {\n result_size =\n ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);\n }\n\n if (result_size > 0) {\n target.resize(result_size);\n result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),\n result_size, NULL, NULL);\n\n if (result_size > 0) {\n target.resize(result_size);\n return;\n }\n }\n\n throw_spdlog_ex(\n fmt_lib::format(\"WideCharToMultiByte failed. Last error: {}\", ::GetLastError()));\n}\n\nSPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {\n if (str.size() > static_cast((std::numeric_limits::max)()) - 1) {\n throw_spdlog_ex(\"UTF-8 string is too big to be converted to UTF-16\");\n }\n\n int str_size = static_cast(str.size());\n if (str_size == 0) {\n target.resize(0);\n return;\n }\n\n // find the size to allocate for the result buffer\n int result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);\n\n if (result_size > 0) {\n target.resize(result_size);\n result_size =\n ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(), result_size);\n if (result_size > 0) {\n assert(result_size == static_cast(target.size()));\n return;\n }\n }\n\n throw_spdlog_ex(\n fmt_lib::format(\"MultiByteToWideChar failed. Last error: {}\", ::GetLastError()));\n}\n#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&\n // defined(_WIN32)\n\n// return true on success\nstatic SPDLOG_INLINE bool mkdir_(const filename_t &path) {\n#ifdef _WIN32\n#ifdef SPDLOG_WCHAR_FILENAMES\n return ::_wmkdir(path.c_str()) == 0;\n#else\n return ::_mkdir(path.c_str()) == 0;\n#endif\n#else\n return ::mkdir(path.c_str(), mode_t(0755)) == 0;\n#endif\n}\n\n// create the given directory - and all directories leading to it\n// return true on success or if the directory already exists\nSPDLOG_INLINE bool create_dir(const filename_t &path) {\n if (path_exists(path)) {\n return true;\n }\n\n if (path.empty()) {\n return false;\n }\n\n size_t search_offset = 0;\n do {\n auto token_pos = path.find_first_of(folder_seps_filename, search_offset);\n // treat the entire path as a folder if no folder separator not found\n if (token_pos == filename_t::npos) {\n token_pos = path.size();\n }\n\n auto subdir = path.substr(0, token_pos);\n#ifdef _WIN32\n // if subdir is just a drive letter, add a slash e.g. \"c:\"=>\"c:\\\",\n // otherwise path_exists(subdir) returns false (issue #3079)\n const bool is_drive = subdir.length() == 2 && subdir[1] == ':';\n if (is_drive) {\n subdir += '\\\\';\n token_pos++;\n }\n#endif\n\n if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {\n return false; // return error if failed creating dir\n }\n search_offset = token_pos + 1;\n } while (search_offset < path.size());\n\n return true;\n}\n\n// Return directory name from given path or empty string\n// \"abc/file\" => \"abc\"\n// \"abc/\" => \"abc\"\n// \"abc\" => \"\"\n// \"abc///\" => \"abc//\"\nSPDLOG_INLINE filename_t dir_name(const filename_t &path) {\n auto pos = path.find_last_of(folder_seps_filename);\n return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};\n}\n\n#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning(disable : 4996)\n#endif // _MSC_VER\nstd::string SPDLOG_INLINE getenv(const char *field) {\n#if defined(_MSC_VER) && defined(WINAPI_FAMILY) && defined(WINAPI_FAMILY_DESKTOP_APP) && \\\n (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)\n return std::string{}; // not supported under uwp\n#else\n char *buf = std::getenv(field);\n return buf ? buf : std::string{};\n#endif\n}\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif // _MSC_VER\n\n// Do fsync by FILE handlerpointer\n// Return true on success\nSPDLOG_INLINE bool fsync(FILE *fp) {\n#ifdef _WIN32\n return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0;\n#else\n return ::fsync(fileno(fp)) == 0;\n#endif\n}\n\n// Do non-locking fwrite if possible by the os or use the regular locking fwrite\n// Return true on success.\nSPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {\n#if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED)\n return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;\n#elif defined(SPDLOG_FWRITE_UNLOCKED)\n return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;\n#else\n return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes;\n#endif\n}\n\n} // namespace os\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/os.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include // std::time_t\n#include \n\nnamespace spdlog {\nnamespace details {\nnamespace os {\n\nSPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;\n\nSPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;\n\nSPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;\n\nSPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;\n\nSPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;\n\n// eol definition\n#if !defined(SPDLOG_EOL)\n#ifdef _WIN32\n#define SPDLOG_EOL \"\\r\\n\"\n#else\n#define SPDLOG_EOL \"\\n\"\n#endif\n#endif\n\nSPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;\n\n// folder separator\n#if !defined(SPDLOG_FOLDER_SEPS)\n#ifdef _WIN32\n#define SPDLOG_FOLDER_SEPS \"\\\\/\"\n#else\n#define SPDLOG_FOLDER_SEPS \"/\"\n#endif\n#endif\n\nSPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;\nSPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] =\n SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);\n\n// fopen_s on non windows for writing\nSPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);\n\n// Remove filename. return 0 on success\nSPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;\n\n// Remove file if exists. return 0 on success\n// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)\nSPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;\n\nSPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;\n\n// Return if file exists.\nSPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;\n\n// Return file size according to open FILE* object\nSPDLOG_API size_t filesize(FILE *f);\n\n// Return utc offset in minutes or throw spdlog_ex on failure\nSPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());\n\n// Return current thread id as size_t\n// It exists because the std::this_thread::get_id() is much slower(especially\n// under VS 2013)\nSPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;\n\n// Return current thread id as size_t (from thread local storage)\nSPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;\n\n// This is avoid msvc issue in sleep_for that happens if the clock changes.\n// See https://github.com/gabime/spdlog/issues/609\nSPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT;\n\nSPDLOG_API std::string filename_to_str(const filename_t &filename);\n\nSPDLOG_API int pid() SPDLOG_NOEXCEPT;\n\n// Determine if the terminal supports colors\n// Source: https://github.com/agauniyal/rang/\nSPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;\n\n// Determine if the terminal attached\n// Source: https://github.com/agauniyal/rang/\nSPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;\n\n#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)\nSPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);\n\nSPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);\n#endif\n\n// Return directory name from given path or empty string\n// \"abc/file\" => \"abc\"\n// \"abc/\" => \"abc\"\n// \"abc\" => \"\"\n// \"abc///\" => \"abc//\"\nSPDLOG_API filename_t dir_name(const filename_t &path);\n\n// Create a dir from the given path.\n// Return true if succeeded or if this dir already exists.\nSPDLOG_API bool create_dir(const filename_t &path);\n\n// non thread safe, cross platform getenv/getenv_s\n// return empty string if field not found\nSPDLOG_API std::string getenv(const char *field);\n\n// Do fsync by FILE objectpointer.\n// Return true on success.\nSPDLOG_API bool fsync(FILE *fp);\n\n// Do non-locking fwrite if possible by the os or use the regular locking fwrite\n// Return true on success.\nSPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);\n\n} // namespace os\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"os-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/periodic_worker-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\nnamespace spdlog {\nnamespace details {\n\n// stop the worker thread and join it\nSPDLOG_INLINE periodic_worker::~periodic_worker() {\n if (worker_thread_.joinable()) {\n {\n std::lock_guard lock(mutex_);\n active_ = false;\n }\n cv_.notify_one();\n worker_thread_.join();\n }\n}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/periodic_worker.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// periodic worker thread - periodically executes the given callback function.\n//\n// RAII over the owned thread:\n// creates the thread on construction.\n// stops and joins the thread on destruction (if the thread is executing a callback, wait for it\n// to finish first).\n\n#include \n#include \n#include \n#include \n#include \nnamespace spdlog {\nnamespace details {\n\nclass SPDLOG_API periodic_worker {\npublic:\n template \n periodic_worker(const std::function &callback_fun,\n std::chrono::duration interval) {\n active_ = (interval > std::chrono::duration::zero());\n if (!active_) {\n return;\n }\n\n worker_thread_ = std::thread([this, callback_fun, interval]() {\n for (;;) {\n std::unique_lock lock(this->mutex_);\n if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {\n return; // active_ == false, so exit this thread\n }\n callback_fun();\n }\n });\n }\n std::thread &get_thread() { return worker_thread_; }\n periodic_worker(const periodic_worker &) = delete;\n periodic_worker &operator=(const periodic_worker &) = delete;\n // stop the worker thread and join it\n ~periodic_worker();\n\nprivate:\n bool active_;\n std::thread worker_thread_;\n std::mutex mutex_;\n std::condition_variable cv_;\n};\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"periodic_worker-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/registry-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n#include \n#include \n\n#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER\n// support for the default stdout color logger\n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n#endif // SPDLOG_DISABLE_DEFAULT_LOGGER\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\nSPDLOG_INLINE registry::registry()\n : formatter_(new pattern_formatter()) {\n#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER\n// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).\n#ifdef _WIN32\n auto color_sink = std::make_shared();\n#else\n auto color_sink = std::make_shared();\n#endif\n\n const char *default_logger_name = \"\";\n default_logger_ = std::make_shared(default_logger_name, std::move(color_sink));\n loggers_[default_logger_name] = default_logger_;\n\n#endif // SPDLOG_DISABLE_DEFAULT_LOGGER\n}\n\nSPDLOG_INLINE registry::~registry() = default;\n\nSPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) {\n std::lock_guard lock(logger_map_mutex_);\n register_logger_(std::move(new_logger));\n}\n\nSPDLOG_INLINE void registry::register_or_replace(std::shared_ptr new_logger) {\n std::lock_guard lock(logger_map_mutex_);\n register_or_replace_(std::move(new_logger));\n}\n\nSPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) {\n std::lock_guard lock(logger_map_mutex_);\n new_logger->set_formatter(formatter_->clone());\n\n if (err_handler_) {\n new_logger->set_error_handler(err_handler_);\n }\n\n // set new level according to previously configured level or default level\n auto it = log_levels_.find(new_logger->name());\n auto new_level = it != log_levels_.end() ? it->second : global_log_level_;\n new_logger->set_level(new_level);\n\n new_logger->flush_on(flush_level_);\n\n if (backtrace_n_messages_ > 0) {\n new_logger->enable_backtrace(backtrace_n_messages_);\n }\n\n if (automatic_registration_) {\n register_logger_(std::move(new_logger));\n }\n}\n\nSPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) {\n std::lock_guard lock(logger_map_mutex_);\n auto found = loggers_.find(logger_name);\n return found == loggers_.end() ? nullptr : found->second;\n}\n\nSPDLOG_INLINE std::shared_ptr registry::default_logger() {\n std::lock_guard lock(logger_map_mutex_);\n return default_logger_;\n}\n\n// Return raw ptr to the default logger.\n// To be used directly by the spdlog default api (e.g. spdlog::info)\n// This make the default API faster, but cannot be used concurrently with set_default_logger().\n// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.\nSPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }\n\n// set default logger.\n// the default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.\nSPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) {\n std::lock_guard lock(logger_map_mutex_);\n if (new_default_logger != nullptr) {\n loggers_[new_default_logger->name()] = new_default_logger;\n }\n default_logger_ = std::move(new_default_logger);\n}\n\nSPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) {\n std::lock_guard lock(tp_mutex_);\n tp_ = std::move(tp);\n}\n\nSPDLOG_INLINE std::shared_ptr registry::get_tp() {\n std::lock_guard lock(tp_mutex_);\n return tp_;\n}\n\n// Set global formatter. Each sink in each logger will get a clone of this object\nSPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) {\n std::lock_guard lock(logger_map_mutex_);\n formatter_ = std::move(formatter);\n for (auto &l : loggers_) {\n l.second->set_formatter(formatter_->clone());\n }\n}\n\nSPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) {\n std::lock_guard lock(logger_map_mutex_);\n backtrace_n_messages_ = n_messages;\n\n for (auto &l : loggers_) {\n l.second->enable_backtrace(n_messages);\n }\n}\n\nSPDLOG_INLINE void registry::disable_backtrace() {\n std::lock_guard lock(logger_map_mutex_);\n backtrace_n_messages_ = 0;\n for (auto &l : loggers_) {\n l.second->disable_backtrace();\n }\n}\n\nSPDLOG_INLINE void registry::set_level(level::level_enum log_level) {\n std::lock_guard lock(logger_map_mutex_);\n for (auto &l : loggers_) {\n l.second->set_level(log_level);\n }\n global_log_level_ = log_level;\n}\n\nSPDLOG_INLINE void registry::flush_on(level::level_enum log_level) {\n std::lock_guard lock(logger_map_mutex_);\n for (auto &l : loggers_) {\n l.second->flush_on(log_level);\n }\n flush_level_ = log_level;\n}\n\nSPDLOG_INLINE void registry::set_error_handler(err_handler handler) {\n std::lock_guard lock(logger_map_mutex_);\n for (auto &l : loggers_) {\n l.second->set_error_handler(handler);\n }\n err_handler_ = std::move(handler);\n}\n\nSPDLOG_INLINE void registry::apply_all(\n const std::function)> &fun) {\n std::lock_guard lock(logger_map_mutex_);\n for (auto &l : loggers_) {\n fun(l.second);\n }\n}\n\nSPDLOG_INLINE void registry::flush_all() {\n std::lock_guard lock(logger_map_mutex_);\n for (auto &l : loggers_) {\n l.second->flush();\n }\n}\n\nSPDLOG_INLINE void registry::drop(const std::string &logger_name) {\n std::lock_guard lock(logger_map_mutex_);\n auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;\n loggers_.erase(logger_name);\n if (is_default_logger) {\n default_logger_.reset();\n }\n}\n\nSPDLOG_INLINE void registry::drop_all() {\n std::lock_guard lock(logger_map_mutex_);\n loggers_.clear();\n default_logger_.reset();\n}\n\n// clean all resources and threads started by the registry\nSPDLOG_INLINE void registry::shutdown() {\n {\n std::lock_guard lock(flusher_mutex_);\n periodic_flusher_.reset();\n }\n\n drop_all();\n\n {\n std::lock_guard lock(tp_mutex_);\n tp_.reset();\n }\n}\n\nSPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; }\n\nSPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) {\n std::lock_guard lock(logger_map_mutex_);\n automatic_registration_ = automatic_registration;\n}\n\nSPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) {\n std::lock_guard lock(logger_map_mutex_);\n log_levels_ = std::move(levels);\n auto global_level_requested = global_level != nullptr;\n global_log_level_ = global_level_requested ? *global_level : global_log_level_;\n\n for (auto &logger : loggers_) {\n auto logger_entry = log_levels_.find(logger.first);\n if (logger_entry != log_levels_.end()) {\n logger.second->set_level(logger_entry->second);\n } else if (global_level_requested) {\n logger.second->set_level(*global_level);\n }\n }\n}\n\nSPDLOG_INLINE registry ®istry::instance() {\n static registry s_instance;\n return s_instance;\n}\n\nSPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) {\n std::lock_guard lock(logger_map_mutex_);\n auto it = log_levels_.find(new_logger->name());\n auto new_level = it != log_levels_.end() ? it->second : global_log_level_;\n new_logger->set_level(new_level);\n}\n\nSPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {\n if (loggers_.find(logger_name) != loggers_.end()) {\n throw_spdlog_ex(\"logger with name '\" + logger_name + \"' already exists\");\n }\n}\n\nSPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) {\n const auto &logger_name = new_logger->name();\n throw_if_exists_(logger_name);\n loggers_[logger_name] = std::move(new_logger);\n}\n\nSPDLOG_INLINE void registry::register_or_replace_(std::shared_ptr new_logger) {\n loggers_[new_logger->name()] = std::move(new_logger);\n}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/registry.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// Loggers registry of unique name->logger pointer\n// An attempt to create a logger with an already existing name will result with spdlog_ex exception.\n// If user requests a non existing logger, nullptr will be returned\n// This class is thread safe\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nclass logger;\n\nnamespace details {\nclass thread_pool;\n\nclass SPDLOG_API registry {\npublic:\n using log_levels = std::unordered_map;\n registry(const registry &) = delete;\n registry &operator=(const registry &) = delete;\n\n void register_logger(std::shared_ptr new_logger);\n void register_or_replace(std::shared_ptr new_logger);\n void initialize_logger(std::shared_ptr new_logger);\n std::shared_ptr get(const std::string &logger_name);\n std::shared_ptr default_logger();\n\n // Return raw ptr to the default logger.\n // To be used directly by the spdlog default api (e.g. spdlog::info)\n // This make the default API faster, but cannot be used concurrently with set_default_logger().\n // e.g do not call set_default_logger() from one thread while calling spdlog::info() from\n // another.\n logger *get_default_raw();\n\n // set default logger and add it to the registry if not registered already.\n // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.\n // Note: Make sure to unregister it when no longer needed or before calling again with a new\n // logger.\n void set_default_logger(std::shared_ptr new_default_logger);\n\n void set_tp(std::shared_ptr tp);\n\n std::shared_ptr get_tp();\n\n // Set global formatter. Each sink in each logger will get a clone of this object\n void set_formatter(std::unique_ptr formatter);\n\n void enable_backtrace(size_t n_messages);\n\n void disable_backtrace();\n\n void set_level(level::level_enum log_level);\n\n void flush_on(level::level_enum log_level);\n\n template \n void flush_every(std::chrono::duration interval) {\n std::lock_guard lock(flusher_mutex_);\n auto clbk = [this]() { this->flush_all(); };\n periodic_flusher_ = details::make_unique(clbk, interval);\n }\n\n std::unique_ptr &get_flusher() {\n std::lock_guard lock(flusher_mutex_);\n return periodic_flusher_;\n }\n\n void set_error_handler(err_handler handler);\n\n void apply_all(const std::function)> &fun);\n\n void flush_all();\n\n void drop(const std::string &logger_name);\n\n void drop_all();\n\n // clean all resources and threads started by the registry\n void shutdown();\n\n std::recursive_mutex &tp_mutex();\n\n void set_automatic_registration(bool automatic_registration);\n\n // set levels for all existing/future loggers. global_level can be null if should not set.\n void set_levels(log_levels levels, level::level_enum *global_level);\n\n static registry &instance();\n\n void apply_logger_env_levels(std::shared_ptr new_logger);\n\nprivate:\n registry();\n ~registry();\n\n void throw_if_exists_(const std::string &logger_name);\n void register_logger_(std::shared_ptr new_logger);\n void register_or_replace_(std::shared_ptr new_logger);\n bool set_level_from_cfg_(logger *logger);\n std::mutex logger_map_mutex_, flusher_mutex_;\n std::recursive_mutex tp_mutex_;\n std::unordered_map> loggers_;\n log_levels log_levels_;\n std::unique_ptr formatter_;\n spdlog::level::level_enum global_log_level_ = level::info;\n level::level_enum flush_level_ = level::off;\n err_handler err_handler_;\n std::shared_ptr tp_;\n std::unique_ptr periodic_flusher_;\n std::shared_ptr default_logger_;\n bool automatic_registration_ = true;\n size_t backtrace_n_messages_ = 0;\n};\n\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"registry-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/synchronous_factory.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \"registry.h\"\n\nnamespace spdlog {\n\n// Default logger factory- creates synchronous loggers\nclass logger;\n\nstruct synchronous_factory {\n template \n static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) {\n auto sink = std::make_shared(std::forward(args)...);\n auto new_logger = std::make_shared(std::move(logger_name), std::move(sink));\n details::registry::instance().initialize_logger(new_logger);\n return new_logger;\n }\n};\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/tcp_client-windows.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#define WIN32_LEAN_AND_MEAN\n// tcp client helper\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#pragma comment(lib, \"Ws2_32.lib\")\n#pragma comment(lib, \"Mswsock.lib\")\n#pragma comment(lib, \"AdvApi32.lib\")\n\nnamespace spdlog {\nnamespace details {\nclass tcp_client {\n SOCKET socket_ = INVALID_SOCKET;\n\n static void init_winsock_() {\n WSADATA wsaData;\n auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);\n if (rv != 0) {\n throw_winsock_error_(\"WSAStartup failed\", ::WSAGetLastError());\n }\n }\n\n static void throw_winsock_error_(const std::string &msg, int last_error) {\n char buf[512];\n ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,\n last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,\n (sizeof(buf) / sizeof(char)), NULL);\n\n throw_spdlog_ex(fmt_lib::format(\"tcp_sink - {}: {}\", msg, buf));\n }\n\npublic:\n tcp_client() { init_winsock_(); }\n\n ~tcp_client() {\n close();\n ::WSACleanup();\n }\n\n bool is_connected() const { return socket_ != INVALID_SOCKET; }\n\n void close() {\n ::closesocket(socket_);\n socket_ = INVALID_SOCKET;\n }\n\n SOCKET fd() const { return socket_; }\n\n int connect_socket_with_timeout(SOCKET sockfd,\n const struct sockaddr *addr,\n int addrlen,\n const timeval &tv) {\n // If no timeout requested, do a normal blocking connect.\n if (tv.tv_sec == 0 && tv.tv_usec == 0) {\n int rv = ::connect(sockfd, addr, addrlen);\n if (rv == SOCKET_ERROR && WSAGetLastError() == WSAEISCONN) {\n return 0;\n }\n return rv;\n }\n\n // Switch to non‐blocking mode\n u_long mode = 1UL;\n if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {\n return SOCKET_ERROR;\n }\n\n int rv = ::connect(sockfd, addr, addrlen);\n int last_error = WSAGetLastError();\n if (rv == 0 || last_error == WSAEISCONN) {\n mode = 0UL;\n if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {\n return SOCKET_ERROR;\n }\n return 0;\n }\n if (last_error != WSAEWOULDBLOCK) {\n // Real error\n mode = 0UL;\n if (::ioctlsocket(sockfd, FIONBIO, &mode)) {\n return SOCKET_ERROR;\n }\n return SOCKET_ERROR;\n }\n\n // Wait until socket is writable or timeout expires\n fd_set wfds;\n FD_ZERO(&wfds);\n FD_SET(sockfd, &wfds);\n\n rv = ::select(0, nullptr, &wfds, nullptr, const_cast(&tv));\n\n // Restore blocking mode regardless of select result\n mode = 0UL;\n if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {\n return SOCKET_ERROR;\n }\n\n if (rv == 0) {\n WSASetLastError(WSAETIMEDOUT);\n return SOCKET_ERROR;\n }\n if (rv == SOCKET_ERROR) {\n return SOCKET_ERROR;\n }\n\n int so_error = 0;\n int len = sizeof(so_error);\n if (::getsockopt(sockfd, SOL_SOCKET, SO_ERROR, reinterpret_cast(&so_error), &len) ==\n SOCKET_ERROR) {\n return SOCKET_ERROR;\n }\n if (so_error != 0 && so_error != WSAEISCONN) {\n // connection failed\n WSASetLastError(so_error);\n return SOCKET_ERROR;\n }\n\n return 0; // success\n }\n\n // try to connect or throw on failure\n void connect(const std::string &host, int port, int timeout_ms = 0) {\n if (is_connected()) {\n close();\n }\n struct addrinfo hints {};\n ZeroMemory(&hints, sizeof(hints));\n\n hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on\n hints.ai_socktype = SOCK_STREAM; // TCP\n hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value\n hints.ai_protocol = 0;\n\n timeval tv;\n tv.tv_sec = timeout_ms / 1000;\n tv.tv_usec = (timeout_ms % 1000) * 1000;\n\n auto port_str = std::to_string(port);\n struct addrinfo *addrinfo_result;\n auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);\n int last_error = 0;\n if (rv != 0) {\n last_error = ::WSAGetLastError();\n WSACleanup();\n throw_winsock_error_(\"getaddrinfo failed\", last_error);\n }\n\n // Try each address until we successfully connect(2).\n for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {\n socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);\n if (socket_ == INVALID_SOCKET) {\n last_error = ::WSAGetLastError();\n WSACleanup();\n continue;\n }\n if (connect_socket_with_timeout(socket_, rp->ai_addr, (int)rp->ai_addrlen, tv) == 0) {\n last_error = 0;\n break;\n }\n last_error = WSAGetLastError();\n ::closesocket(socket_);\n socket_ = INVALID_SOCKET;\n }\n ::freeaddrinfo(addrinfo_result);\n if (socket_ == INVALID_SOCKET) {\n WSACleanup();\n throw_winsock_error_(\"connect failed\", last_error);\n }\n if (timeout_ms > 0) {\n DWORD tv = static_cast(timeout_ms);\n ::setsockopt(socket_, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));\n ::setsockopt(socket_, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));\n }\n\n // set TCP_NODELAY\n int enable_flag = 1;\n ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag),\n sizeof(enable_flag));\n }\n\n // Send exactly n_bytes of the given data.\n // On error close the connection and throw.\n void send(const char *data, size_t n_bytes) {\n size_t bytes_sent = 0;\n while (bytes_sent < n_bytes) {\n const int send_flags = 0;\n auto write_result =\n ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);\n if (write_result == SOCKET_ERROR) {\n int last_error = ::WSAGetLastError();\n close();\n throw_winsock_error_(\"send failed\", last_error);\n }\n\n if (write_result == 0) // (probably should not happen but in any case..)\n {\n break;\n }\n bytes_sent += static_cast(write_result);\n }\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/tcp_client.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifdef _WIN32\n#error include tcp_client-windows.h instead\n#endif\n\n// tcp client helper\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace spdlog {\nnamespace details {\nclass tcp_client {\n int socket_ = -1;\n\npublic:\n bool is_connected() const { return socket_ != -1; }\n\n void close() {\n if (is_connected()) {\n ::close(socket_);\n socket_ = -1;\n }\n }\n\n int fd() const { return socket_; }\n\n ~tcp_client() { close(); }\n\n int connect_socket_with_timeout(int sockfd,\n const struct sockaddr *addr,\n socklen_t addrlen,\n const timeval &tv) {\n // Blocking connect if timeout is zero\n if (tv.tv_sec == 0 && tv.tv_usec == 0) {\n int rv = ::connect(sockfd, addr, addrlen);\n if (rv < 0 && errno == EISCONN) {\n // already connected, treat as success\n return 0;\n }\n return rv;\n }\n\n // Non-blocking path\n int orig_flags = ::fcntl(sockfd, F_GETFL, 0);\n if (orig_flags < 0) {\n return -1;\n }\n if (::fcntl(sockfd, F_SETFL, orig_flags | O_NONBLOCK) < 0) {\n return -1;\n }\n\n int rv = ::connect(sockfd, addr, addrlen);\n if (rv == 0 || (rv < 0 && errno == EISCONN)) {\n // immediate connect or already connected\n ::fcntl(sockfd, F_SETFL, orig_flags);\n return 0;\n }\n if (errno != EINPROGRESS) {\n ::fcntl(sockfd, F_SETFL, orig_flags);\n return -1;\n }\n\n // wait for writability\n fd_set wfds;\n FD_ZERO(&wfds);\n FD_SET(sockfd, &wfds);\n\n struct timeval tv_copy = tv;\n rv = ::select(sockfd + 1, nullptr, &wfds, nullptr, &tv_copy);\n if (rv <= 0) {\n // timeout or error\n ::fcntl(sockfd, F_SETFL, orig_flags);\n if (rv == 0) errno = ETIMEDOUT;\n return -1;\n }\n\n // check socket error\n int so_error = 0;\n socklen_t len = sizeof(so_error);\n if (::getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &so_error, &len) < 0) {\n ::fcntl(sockfd, F_SETFL, orig_flags);\n return -1;\n }\n ::fcntl(sockfd, F_SETFL, orig_flags);\n if (so_error != 0 && so_error != EISCONN) {\n errno = so_error;\n return -1;\n }\n\n return 0;\n }\n\n // try to connect or throw on failure\n void connect(const std::string &host, int port, int timeout_ms = 0) {\n close();\n struct addrinfo hints {};\n memset(&hints, 0, sizeof(struct addrinfo));\n hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on\n hints.ai_socktype = SOCK_STREAM; // TCP\n hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value\n hints.ai_protocol = 0;\n\n struct timeval tv;\n tv.tv_sec = timeout_ms / 1000;\n tv.tv_usec = (timeout_ms % 1000) * 1000;\n\n auto port_str = std::to_string(port);\n struct addrinfo *addrinfo_result;\n auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);\n if (rv != 0) {\n throw_spdlog_ex(fmt_lib::format(\"::getaddrinfo failed: {}\", gai_strerror(rv)));\n }\n\n // Try each address until we successfully connect(2).\n int last_errno = 0;\n for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {\n#if defined(SOCK_CLOEXEC)\n const int flags = SOCK_CLOEXEC;\n#else\n const int flags = 0;\n#endif\n socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);\n if (socket_ == -1) {\n last_errno = errno;\n continue;\n }\n ::fcntl(socket_, F_SETFD, FD_CLOEXEC);\n if (connect_socket_with_timeout(socket_, rp->ai_addr, rp->ai_addrlen, tv) == 0) {\n last_errno = 0;\n break;\n }\n last_errno = errno;\n ::close(socket_);\n socket_ = -1;\n }\n ::freeaddrinfo(addrinfo_result);\n if (socket_ == -1) {\n throw_spdlog_ex(\"::connect failed\", last_errno);\n }\n\n if (timeout_ms > 0) {\n // Set timeouts for send and recv\n ::setsockopt(socket_, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));\n ::setsockopt(socket_, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));\n }\n\n // set TCP_NODELAY\n int enable_flag = 1;\n ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&enable_flag),\n sizeof(enable_flag));\n\n // prevent sigpipe on systems where MSG_NOSIGNAL is not available\n#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)\n ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&enable_flag),\n sizeof(enable_flag));\n#endif\n\n#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)\n#error \"tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available\"\n#endif\n }\n\n // Send exactly n_bytes of the given data.\n // On error close the connection and throw.\n void send(const char *data, size_t n_bytes) {\n size_t bytes_sent = 0;\n while (bytes_sent < n_bytes) {\n#if defined(MSG_NOSIGNAL)\n const int send_flags = MSG_NOSIGNAL;\n#else\n const int send_flags = 0;\n#endif\n auto write_result =\n ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);\n if (write_result < 0) {\n close();\n throw_spdlog_ex(\"write(2) failed\", errno);\n }\n\n if (write_result == 0) // (probably should not happen but in any case..)\n {\n break;\n }\n bytes_sent += static_cast(write_result);\n }\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/thread_pool-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\nSPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,\n size_t threads_n,\n std::function on_thread_start,\n std::function on_thread_stop)\n : q_(q_max_items) {\n if (threads_n == 0 || threads_n > 1000) {\n throw_spdlog_ex(\n \"spdlog::thread_pool(): invalid threads_n param (valid \"\n \"range is 1-1000)\");\n }\n for (size_t i = 0; i < threads_n; i++) {\n threads_.emplace_back([this, on_thread_start, on_thread_stop] {\n on_thread_start();\n this->thread_pool::worker_loop_();\n on_thread_stop();\n });\n }\n}\n\nSPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,\n size_t threads_n,\n std::function on_thread_start)\n : thread_pool(q_max_items, threads_n, std::move(on_thread_start), [] {}) {}\n\nSPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)\n : thread_pool(q_max_items, threads_n, [] {}, [] {}) {}\n\n// message all threads to terminate gracefully join them\nSPDLOG_INLINE thread_pool::~thread_pool() {\n SPDLOG_TRY {\n for (size_t i = 0; i < threads_.size(); i++) {\n post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);\n }\n\n for (auto &t : threads_) {\n t.join();\n }\n }\n SPDLOG_CATCH_STD\n}\n\nvoid SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,\n const details::log_msg &msg,\n async_overflow_policy overflow_policy) {\n async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);\n post_async_msg_(std::move(async_m), overflow_policy);\n}\n\nvoid SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr,\n async_overflow_policy overflow_policy) {\n post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);\n}\n\nsize_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); }\n\nvoid SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); }\n\nsize_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); }\n\nvoid SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); }\n\nsize_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); }\n\nvoid SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg,\n async_overflow_policy overflow_policy) {\n if (overflow_policy == async_overflow_policy::block) {\n q_.enqueue(std::move(new_msg));\n } else if (overflow_policy == async_overflow_policy::overrun_oldest) {\n q_.enqueue_nowait(std::move(new_msg));\n } else {\n assert(overflow_policy == async_overflow_policy::discard_new);\n q_.enqueue_if_have_room(std::move(new_msg));\n }\n}\n\nvoid SPDLOG_INLINE thread_pool::worker_loop_() {\n while (process_next_msg_()) {\n }\n}\n\n// process next message in the queue\n// returns true if this thread should still be active (while no terminated msg was received)\nbool SPDLOG_INLINE thread_pool::process_next_msg_() {\n async_msg incoming_async_msg;\n q_.dequeue(incoming_async_msg);\n\n switch (incoming_async_msg.msg_type) {\n case async_msg_type::log: {\n incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);\n return true;\n }\n case async_msg_type::flush: {\n incoming_async_msg.worker_ptr->backend_flush_();\n return true;\n }\n\n case async_msg_type::terminate: {\n return false;\n }\n\n default: {\n assert(false);\n }\n }\n\n return true;\n}\n\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/thread_pool.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nclass async_logger;\n\nnamespace details {\n\nusing async_logger_ptr = std::shared_ptr;\n\nenum class async_msg_type { log, flush, terminate };\n\n// Async msg to move to/from the queue\n// Movable only. should never be copied\nstruct async_msg : log_msg_buffer {\n async_msg_type msg_type{async_msg_type::log};\n async_logger_ptr worker_ptr;\n\n async_msg() = default;\n ~async_msg() = default;\n\n // should only be moved in or out of the queue..\n async_msg(const async_msg &) = delete;\n\n// support for vs2013 move\n#if defined(_MSC_VER) && _MSC_VER <= 1800\n async_msg(async_msg &&other)\n : log_msg_buffer(std::move(other)),\n msg_type(other.msg_type),\n worker_ptr(std::move(other.worker_ptr)) {}\n\n async_msg &operator=(async_msg &&other) {\n *static_cast(this) = std::move(other);\n msg_type = other.msg_type;\n worker_ptr = std::move(other.worker_ptr);\n return *this;\n }\n#else // (_MSC_VER) && _MSC_VER <= 1800\n async_msg(async_msg &&) = default;\n async_msg &operator=(async_msg &&) = default;\n#endif\n\n // construct from log_msg with given type\n async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)\n : log_msg_buffer{m},\n msg_type{the_type},\n worker_ptr{std::move(worker)} {}\n\n async_msg(async_logger_ptr &&worker, async_msg_type the_type)\n : log_msg_buffer{},\n msg_type{the_type},\n worker_ptr{std::move(worker)} {}\n\n explicit async_msg(async_msg_type the_type)\n : async_msg{nullptr, the_type} {}\n};\n\nclass SPDLOG_API thread_pool {\npublic:\n using item_type = async_msg;\n using q_type = details::mpmc_blocking_queue;\n\n thread_pool(size_t q_max_items,\n size_t threads_n,\n std::function on_thread_start,\n std::function on_thread_stop);\n thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start);\n thread_pool(size_t q_max_items, size_t threads_n);\n\n // message all threads to terminate gracefully and join them\n ~thread_pool();\n\n thread_pool(const thread_pool &) = delete;\n thread_pool &operator=(thread_pool &&) = delete;\n\n void post_log(async_logger_ptr &&worker_ptr,\n const details::log_msg &msg,\n async_overflow_policy overflow_policy);\n void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);\n size_t overrun_counter();\n void reset_overrun_counter();\n size_t discard_counter();\n void reset_discard_counter();\n size_t queue_size();\n\nprivate:\n q_type q_;\n\n std::vector threads_;\n\n void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);\n void worker_loop_();\n\n // process next message in the queue\n // return true if this thread should still be active (while no terminate msg\n // was received)\n bool process_next_msg_();\n};\n\n} // namespace details\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"thread_pool-inl.h\"\n#endif\n" }, { "path": "include/spdlog/details/udp_client-windows.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// Helper RAII over winsock udp client socket.\n// Will throw on construction if socket creation failed.\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if defined(_MSC_VER)\n#pragma comment(lib, \"Ws2_32.lib\")\n#pragma comment(lib, \"Mswsock.lib\")\n#pragma comment(lib, \"AdvApi32.lib\")\n#endif\n\nnamespace spdlog {\nnamespace details {\nclass udp_client {\n static constexpr int TX_BUFFER_SIZE = 1024 * 10;\n SOCKET socket_ = INVALID_SOCKET;\n sockaddr_in addr_ = {};\n\n static void init_winsock_() {\n WSADATA wsaData;\n auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);\n if (rv != 0) {\n throw_winsock_error_(\"WSAStartup failed\", ::WSAGetLastError());\n }\n }\n\n static void throw_winsock_error_(const std::string &msg, int last_error) {\n char buf[512];\n ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,\n last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf,\n (sizeof(buf) / sizeof(char)), NULL);\n\n throw_spdlog_ex(fmt_lib::format(\"udp_sink - {}: {}\", msg, buf));\n }\n\n void cleanup_() {\n if (socket_ != INVALID_SOCKET) {\n ::closesocket(socket_);\n }\n socket_ = INVALID_SOCKET;\n ::WSACleanup();\n }\n\npublic:\n udp_client(const std::string &host, uint16_t port) {\n init_winsock_();\n\n addr_.sin_family = PF_INET;\n addr_.sin_port = htons(port);\n addr_.sin_addr.s_addr = INADDR_ANY;\n if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) {\n int last_error = ::WSAGetLastError();\n ::WSACleanup();\n throw_winsock_error_(\"error: Invalid address!\", last_error);\n }\n\n socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);\n if (socket_ == INVALID_SOCKET) {\n int last_error = ::WSAGetLastError();\n ::WSACleanup();\n throw_winsock_error_(\"error: Create Socket failed\", last_error);\n }\n\n int option_value = TX_BUFFER_SIZE;\n if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,\n reinterpret_cast(&option_value), sizeof(option_value)) < 0) {\n int last_error = ::WSAGetLastError();\n cleanup_();\n throw_winsock_error_(\"error: setsockopt(SO_SNDBUF) Failed!\", last_error);\n }\n }\n\n ~udp_client() { cleanup_(); }\n\n SOCKET fd() const { return socket_; }\n\n void send(const char *data, size_t n_bytes) {\n socklen_t tolen = sizeof(struct sockaddr);\n if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr *)&addr_,\n tolen) == -1) {\n throw_spdlog_ex(\"sendto(2) failed\", errno);\n }\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/udp_client.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// Helper RAII over unix udp client socket.\n// Will throw on construction if the socket creation failed.\n\n#ifdef _WIN32\n#error \"include udp_client-windows.h instead\"\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace spdlog {\nnamespace details {\n\nclass udp_client {\n static constexpr int TX_BUFFER_SIZE = 1024 * 10;\n int socket_ = -1;\n struct sockaddr_in sockAddr_;\n\n void cleanup_() {\n if (socket_ != -1) {\n ::close(socket_);\n socket_ = -1;\n }\n }\n\npublic:\n udp_client(const std::string &host, uint16_t port) {\n socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);\n if (socket_ < 0) {\n throw_spdlog_ex(\"error: Create Socket Failed!\");\n }\n\n int option_value = TX_BUFFER_SIZE;\n if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,\n reinterpret_cast(&option_value), sizeof(option_value)) < 0) {\n cleanup_();\n throw_spdlog_ex(\"error: setsockopt(SO_SNDBUF) Failed!\");\n }\n\n sockAddr_.sin_family = AF_INET;\n sockAddr_.sin_port = htons(port);\n\n if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) {\n cleanup_();\n throw_spdlog_ex(\"error: Invalid address!\");\n }\n\n ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));\n }\n\n ~udp_client() { cleanup_(); }\n\n int fd() const { return socket_; }\n\n // Send exactly n_bytes of the given data.\n // On error close the connection and throw.\n void send(const char *data, size_t n_bytes) {\n socklen_t tolen = sizeof(sockAddr_);\n if (::sendto(socket_, data, n_bytes, 0, reinterpret_cast(&sockAddr_),\n tolen) == -1) {\n throw_spdlog_ex(\"sendto(2) failed\", errno);\n }\n }\n};\n} // namespace details\n} // namespace spdlog\n" }, { "path": "include/spdlog/details/windows_include.h", "content": "#pragma once\n\n#ifndef NOMINMAX\n#define NOMINMAX // prevent windows redefining min/max\n#endif\n\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n\n#include \n" }, { "path": "include/spdlog/fmt/bin_to_hex.h", "content": "//\n// Copyright(c) 2015 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n\n#include \n#include \n\n#if defined(__has_include)\n#if __has_include()\n#include \n#endif\n#endif\n\n#if __cpp_lib_span >= 202002L\n#include \n#endif\n\n//\n// Support for logging binary data as hex\n// format flags, any combination of the following:\n// {:X} - print in uppercase.\n// {:s} - don't separate each byte with space.\n// {:p} - don't print the position on each line start.\n// {:n} - don't split the output to lines.\n// {:a} - show ASCII if :n is not set\n\n//\n// Examples:\n//\n// std::vector v(200, 0x0b);\n// logger->info(\"Some buffer {}\", spdlog::to_hex(v));\n// char buf[128];\n// logger->info(\"Some buffer {:X}\", spdlog::to_hex(std::begin(buf), std::end(buf)));\n// logger->info(\"Some buffer {:X}\", spdlog::to_hex(std::begin(buf), std::end(buf), 16));\n\nnamespace spdlog {\nnamespace details {\n\ntemplate \nclass dump_info {\npublic:\n dump_info(It range_begin, It range_end, size_t size_per_line)\n : begin_(range_begin),\n end_(range_end),\n size_per_line_(size_per_line) {}\n\n // do not use begin() and end() to avoid collision with fmt/ranges\n It get_begin() const { return begin_; }\n It get_end() const { return end_; }\n size_t size_per_line() const { return size_per_line_; }\n\nprivate:\n It begin_, end_;\n size_t size_per_line_;\n};\n} // namespace details\n\n// create a dump_info that wraps the given container\ntemplate \ninline details::dump_info to_hex(const Container &container,\n size_t size_per_line = 32) {\n static_assert(sizeof(typename Container::value_type) == 1,\n \"sizeof(Container::value_type) != 1\");\n using Iter = typename Container::const_iterator;\n return details::dump_info(std::begin(container), std::end(container), size_per_line);\n}\n\n#if __cpp_lib_span >= 202002L\n\ntemplate \ninline details::dump_info::iterator> to_hex(\n const std::span &container, size_t size_per_line = 32) {\n using Container = std::span;\n static_assert(sizeof(typename Container::value_type) == 1,\n \"sizeof(Container::value_type) != 1\");\n using Iter = typename Container::iterator;\n return details::dump_info(std::begin(container), std::end(container), size_per_line);\n}\n\n#endif\n\n// create dump_info from ranges\ntemplate \ninline details::dump_info to_hex(const It range_begin,\n const It range_end,\n size_t size_per_line = 32) {\n return details::dump_info(range_begin, range_end, size_per_line);\n}\n\n} // namespace spdlog\n\nnamespace\n#ifdef SPDLOG_USE_STD_FORMAT\n std\n#else\n fmt\n#endif\n{\n\ntemplate \nstruct formatter, char> {\n char delimiter = ' ';\n bool put_newlines = true;\n bool put_delimiters = true;\n bool use_uppercase = false;\n bool put_positions = true; // position on start of each line\n bool show_ascii = false;\n\n // parse the format string flags\n template \n SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {\n auto it = ctx.begin();\n while (it != ctx.end() && *it != '}') {\n switch (*it) {\n case 'X':\n use_uppercase = true;\n break;\n case 's':\n put_delimiters = false;\n break;\n case 'p':\n put_positions = false;\n break;\n case 'n':\n put_newlines = false;\n show_ascii = false;\n break;\n case 'a':\n if (put_newlines) {\n show_ascii = true;\n }\n break;\n }\n\n ++it;\n }\n return it;\n }\n\n // format the given bytes range as hex\n template \n auto format(const spdlog::details::dump_info &the_range,\n FormatContext &ctx) const -> decltype(ctx.out()) {\n SPDLOG_CONSTEXPR const char *hex_upper = \"0123456789ABCDEF\";\n SPDLOG_CONSTEXPR const char *hex_lower = \"0123456789abcdef\";\n const char *hex_chars = use_uppercase ? hex_upper : hex_lower;\n\n#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000\n auto inserter = ctx.begin();\n#else\n auto inserter = ctx.out();\n#endif\n\n int size_per_line = static_cast(the_range.size_per_line());\n auto start_of_line = the_range.get_begin();\n for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) {\n auto ch = static_cast(*i);\n\n if (put_newlines &&\n (i == the_range.get_begin() || i - start_of_line >= size_per_line)) {\n if (show_ascii && i != the_range.get_begin()) {\n *inserter++ = delimiter;\n *inserter++ = delimiter;\n for (auto j = start_of_line; j < i; j++) {\n auto pc = static_cast(*j);\n *inserter++ = std::isprint(pc) ? static_cast(*j) : '.';\n }\n }\n\n put_newline(inserter, static_cast(i - the_range.get_begin()));\n\n // put first byte without delimiter in front of it\n *inserter++ = hex_chars[(ch >> 4) & 0x0f];\n *inserter++ = hex_chars[ch & 0x0f];\n start_of_line = i;\n continue;\n }\n\n if (put_delimiters && i != the_range.get_begin()) {\n *inserter++ = delimiter;\n }\n\n *inserter++ = hex_chars[(ch >> 4) & 0x0f];\n *inserter++ = hex_chars[ch & 0x0f];\n }\n if (show_ascii) // add ascii to last line\n {\n if (the_range.get_end() - the_range.get_begin() > size_per_line) {\n auto blank_num = size_per_line - (the_range.get_end() - start_of_line);\n while (blank_num-- > 0) {\n *inserter++ = delimiter;\n *inserter++ = delimiter;\n if (put_delimiters) {\n *inserter++ = delimiter;\n }\n }\n }\n *inserter++ = delimiter;\n *inserter++ = delimiter;\n for (auto j = start_of_line; j != the_range.get_end(); j++) {\n auto pc = static_cast(*j);\n *inserter++ = std::isprint(pc) ? static_cast(*j) : '.';\n }\n }\n return inserter;\n }\n\n // put newline(and position header)\n template \n void put_newline(It inserter, std::size_t pos) const {\n#ifdef _WIN32\n *inserter++ = '\\r';\n#endif\n *inserter++ = '\\n';\n\n if (put_positions) {\n spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING(\"{:04X}: \"), pos);\n }\n }\n};\n} // namespace std\n" }, { "path": "include/spdlog/fmt/bundled/args.h", "content": "// Formatting library for C++ - dynamic argument lists\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_ARGS_H_\n#define FMT_ARGS_H_\n\n#ifndef FMT_MODULE\n# include // std::reference_wrapper\n# include // std::unique_ptr\n# include \n#endif\n\n#include \"format.h\" // std_string_view\n\nFMT_BEGIN_NAMESPACE\nnamespace detail {\n\ntemplate struct is_reference_wrapper : std::false_type {};\ntemplate \nstruct is_reference_wrapper> : std::true_type {};\n\ntemplate auto unwrap(const T& v) -> const T& { return v; }\ntemplate \nauto unwrap(const std::reference_wrapper& v) -> const T& {\n return static_cast(v);\n}\n\n// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC\n// 2022 (v17.10.0).\n//\n// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for\n// templates it doesn't complain about inability to deduce single translation\n// unit for placing vtable. So node is made a fake template.\ntemplate struct node {\n virtual ~node() = default;\n std::unique_ptr> next;\n};\n\nclass dynamic_arg_list {\n template struct typed_node : node<> {\n T value;\n\n template \n FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}\n\n template \n FMT_CONSTEXPR typed_node(const basic_string_view& arg)\n : value(arg.data(), arg.size()) {}\n };\n\n std::unique_ptr> head_;\n\n public:\n template auto push(const Arg& arg) -> const T& {\n auto new_node = std::unique_ptr>(new typed_node(arg));\n auto& value = new_node->value;\n new_node->next = std::move(head_);\n head_ = std::move(new_node);\n return value;\n }\n};\n} // namespace detail\n\n/**\n * A dynamic list of formatting arguments with storage.\n *\n * It can be implicitly converted into `fmt::basic_format_args` for passing\n * into type-erased formatting functions such as `fmt::vformat`.\n */\nFMT_EXPORT template class dynamic_format_arg_store {\n private:\n using char_type = typename Context::char_type;\n\n template struct need_copy {\n static constexpr detail::type mapped_type =\n detail::mapped_type_constant::value;\n\n enum {\n value = !(detail::is_reference_wrapper::value ||\n std::is_same>::value ||\n std::is_same>::value ||\n (mapped_type != detail::type::cstring_type &&\n mapped_type != detail::type::string_type &&\n mapped_type != detail::type::custom_type))\n };\n };\n\n template \n using stored_t = conditional_t<\n std::is_convertible>::value &&\n !detail::is_reference_wrapper::value,\n std::basic_string, T>;\n\n // Storage of basic_format_arg must be contiguous.\n std::vector> data_;\n std::vector> named_info_;\n\n // Storage of arguments not fitting into basic_format_arg must grow\n // without relocation because items in data_ refer to it.\n detail::dynamic_arg_list dynamic_args_;\n\n friend class basic_format_args;\n\n auto data() const -> const basic_format_arg* {\n return named_info_.empty() ? data_.data() : data_.data() + 1;\n }\n\n template void emplace_arg(const T& arg) {\n data_.emplace_back(arg);\n }\n\n template \n void emplace_arg(const detail::named_arg& arg) {\n if (named_info_.empty())\n data_.insert(data_.begin(), basic_format_arg(nullptr, 0));\n data_.emplace_back(detail::unwrap(arg.value));\n auto pop_one = [](std::vector>* data) {\n data->pop_back();\n };\n std::unique_ptr>, decltype(pop_one)>\n guard{&data_, pop_one};\n named_info_.push_back({arg.name, static_cast(data_.size() - 2u)});\n data_[0] = {named_info_.data(), named_info_.size()};\n guard.release();\n }\n\n public:\n constexpr dynamic_format_arg_store() = default;\n\n operator basic_format_args() const {\n return basic_format_args(data(), static_cast(data_.size()),\n !named_info_.empty());\n }\n\n /**\n * Adds an argument into the dynamic store for later passing to a formatting\n * function.\n *\n * Note that custom types and string types (but not string views) are copied\n * into the store dynamically allocating memory if necessary.\n *\n * **Example**:\n *\n * fmt::dynamic_format_arg_store store;\n * store.push_back(42);\n * store.push_back(\"abc\");\n * store.push_back(1.5f);\n * std::string result = fmt::vformat(\"{} and {} and {}\", store);\n */\n template void push_back(const T& arg) {\n if (detail::const_check(need_copy::value))\n emplace_arg(dynamic_args_.push>(arg));\n else\n emplace_arg(detail::unwrap(arg));\n }\n\n /**\n * Adds a reference to the argument into the dynamic store for later passing\n * to a formatting function.\n *\n * **Example**:\n *\n * fmt::dynamic_format_arg_store store;\n * char band[] = \"Rolling Stones\";\n * store.push_back(std::cref(band));\n * band[9] = 'c'; // Changing str affects the output.\n * std::string result = fmt::vformat(\"{}\", store);\n * // result == \"Rolling Scones\"\n */\n template void push_back(std::reference_wrapper arg) {\n static_assert(\n need_copy::value,\n \"objects of built-in types and string views are always copied\");\n emplace_arg(arg.get());\n }\n\n /**\n * Adds named argument into the dynamic store for later passing to a\n * formatting function. `std::reference_wrapper` is supported to avoid\n * copying of the argument. The name is always copied into the store.\n */\n template \n void push_back(const detail::named_arg& arg) {\n const char_type* arg_name =\n dynamic_args_.push>(arg.name).c_str();\n if (detail::const_check(need_copy::value)) {\n emplace_arg(\n fmt::arg(arg_name, dynamic_args_.push>(arg.value)));\n } else {\n emplace_arg(fmt::arg(arg_name, arg.value));\n }\n }\n\n /// Erase all elements from the store.\n void clear() {\n data_.clear();\n named_info_.clear();\n dynamic_args_ = {};\n }\n\n /// Reserves space to store at least `new_cap` arguments including\n /// `new_cap_named` named arguments.\n void reserve(size_t new_cap, size_t new_cap_named) {\n FMT_ASSERT(new_cap >= new_cap_named,\n \"set of arguments includes set of named arguments\");\n data_.reserve(new_cap);\n named_info_.reserve(new_cap_named);\n }\n\n /// Returns the number of elements in the store.\n auto size() const noexcept -> size_t { return data_.size(); }\n};\n\nFMT_END_NAMESPACE\n\n#endif // FMT_ARGS_H_\n" }, { "path": "include/spdlog/fmt/bundled/base.h", "content": "// Formatting library for C++ - the base API for char/UTF-8\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_BASE_H_\n#define FMT_BASE_H_\n\n#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE)\n# define FMT_MODULE\n#endif\n\n#ifndef FMT_MODULE\n# include // CHAR_BIT\n# include // FILE\n# include // memcmp\n\n# include // std::enable_if\n#endif\n\n// The fmt library version in the form major * 10000 + minor * 100 + patch.\n#define FMT_VERSION 120100\n\n// Detect compiler versions.\n#if defined(__clang__) && !defined(__ibmxl__)\n# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)\n#else\n# define FMT_CLANG_VERSION 0\n#endif\n#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)\n# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)\n#else\n# define FMT_GCC_VERSION 0\n#endif\n#if defined(__ICL)\n# define FMT_ICC_VERSION __ICL\n#elif defined(__INTEL_COMPILER)\n# define FMT_ICC_VERSION __INTEL_COMPILER\n#else\n# define FMT_ICC_VERSION 0\n#endif\n#if defined(_MSC_VER)\n# define FMT_MSC_VERSION _MSC_VER\n#else\n# define FMT_MSC_VERSION 0\n#endif\n\n// Detect standard library versions.\n#ifdef _GLIBCXX_RELEASE\n# define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE\n#else\n# define FMT_GLIBCXX_RELEASE 0\n#endif\n#ifdef _LIBCPP_VERSION\n# define FMT_LIBCPP_VERSION _LIBCPP_VERSION\n#else\n# define FMT_LIBCPP_VERSION 0\n#endif\n\n#ifdef _MSVC_LANG\n# define FMT_CPLUSPLUS _MSVC_LANG\n#else\n# define FMT_CPLUSPLUS __cplusplus\n#endif\n\n// Detect __has_*.\n#ifdef __has_feature\n# define FMT_HAS_FEATURE(x) __has_feature(x)\n#else\n# define FMT_HAS_FEATURE(x) 0\n#endif\n#ifdef __has_include\n# define FMT_HAS_INCLUDE(x) __has_include(x)\n#else\n# define FMT_HAS_INCLUDE(x) 0\n#endif\n#ifdef __has_builtin\n# define FMT_HAS_BUILTIN(x) __has_builtin(x)\n#else\n# define FMT_HAS_BUILTIN(x) 0\n#endif\n#ifdef __has_cpp_attribute\n# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n# define FMT_HAS_CPP_ATTRIBUTE(x) 0\n#endif\n\n#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \\\n (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))\n\n#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \\\n (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))\n\n// Detect C++14 relaxed constexpr.\n#ifdef FMT_USE_CONSTEXPR\n// Use the provided definition.\n#elif FMT_GCC_VERSION >= 702 && FMT_CPLUSPLUS >= 201402L\n// GCC only allows constexpr member functions in non-literal types since 7.2:\n// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66297.\n# define FMT_USE_CONSTEXPR 1\n#elif FMT_ICC_VERSION\n# define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628\n#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912\n# define FMT_USE_CONSTEXPR 1\n#else\n# define FMT_USE_CONSTEXPR 0\n#endif\n#if FMT_USE_CONSTEXPR\n# define FMT_CONSTEXPR constexpr\n#else\n# define FMT_CONSTEXPR\n#endif\n\n// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.\n#ifdef FMT_USE_CONSTEVAL\n// Use the provided definition.\n#elif !defined(__cpp_lib_is_constant_evaluated)\n# define FMT_USE_CONSTEVAL 0\n#elif FMT_CPLUSPLUS < 201709L\n# define FMT_USE_CONSTEVAL 0\n#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10\n# define FMT_USE_CONSTEVAL 0\n#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000\n# define FMT_USE_CONSTEVAL 0\n#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L\n# define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14.\n#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929\n# define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10.\n#elif defined(__cpp_consteval)\n# define FMT_USE_CONSTEVAL 1\n#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101\n# define FMT_USE_CONSTEVAL 1\n#else\n# define FMT_USE_CONSTEVAL 0\n#endif\n#if FMT_USE_CONSTEVAL\n# define FMT_CONSTEVAL consteval\n# define FMT_CONSTEXPR20 constexpr\n#else\n# define FMT_CONSTEVAL\n# define FMT_CONSTEXPR20\n#endif\n\n// Check if exceptions are disabled.\n#ifdef FMT_USE_EXCEPTIONS\n// Use the provided definition.\n#elif defined(__GNUC__) && !defined(__EXCEPTIONS)\n# define FMT_USE_EXCEPTIONS 0\n#elif defined(__clang__) && !defined(__cpp_exceptions)\n# define FMT_USE_EXCEPTIONS 0\n#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS\n# define FMT_USE_EXCEPTIONS 0\n#else\n# define FMT_USE_EXCEPTIONS 1\n#endif\n#if FMT_USE_EXCEPTIONS\n# define FMT_TRY try\n# define FMT_CATCH(x) catch (x)\n#else\n# define FMT_TRY if (true)\n# define FMT_CATCH(x) if (false)\n#endif\n\n#ifdef FMT_NO_UNIQUE_ADDRESS\n// Use the provided definition.\n#elif FMT_CPLUSPLUS < 202002L\n// Not supported.\n#elif FMT_HAS_CPP_ATTRIBUTE(no_unique_address)\n# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]\n// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485).\n#elif FMT_MSC_VERSION >= 1929 && !FMT_CLANG_VERSION\n# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]\n#endif\n#ifndef FMT_NO_UNIQUE_ADDRESS\n# define FMT_NO_UNIQUE_ADDRESS\n#endif\n\n#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)\n# define FMT_FALLTHROUGH [[fallthrough]]\n#elif defined(__clang__)\n# define FMT_FALLTHROUGH [[clang::fallthrough]]\n#elif FMT_GCC_VERSION >= 700 && \\\n (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)\n# define FMT_FALLTHROUGH [[gnu::fallthrough]]\n#else\n# define FMT_FALLTHROUGH\n#endif\n\n// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.\n#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)\n# define FMT_NORETURN [[noreturn]]\n#else\n# define FMT_NORETURN\n#endif\n\n#ifdef FMT_NODISCARD\n// Use the provided definition.\n#elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard)\n# define FMT_NODISCARD [[nodiscard]]\n#else\n# define FMT_NODISCARD\n#endif\n\n#if FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_VISIBILITY(value) __attribute__((visibility(value)))\n#else\n# define FMT_VISIBILITY(value)\n#endif\n\n// Detect pragmas.\n#define FMT_PRAGMA_IMPL(x) _Pragma(#x)\n#if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)\n// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884\n// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.\n# define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x)\n#else\n# define FMT_PRAGMA_GCC(x)\n#endif\n#if FMT_CLANG_VERSION\n# define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x)\n#else\n# define FMT_PRAGMA_CLANG(x)\n#endif\n#if FMT_MSC_VERSION\n# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))\n#else\n# define FMT_MSC_WARNING(...)\n#endif\n\n// Enable minimal optimizations for more compact code in debug mode.\nFMT_PRAGMA_GCC(push_options)\n#if !defined(__OPTIMIZE__) && !defined(__CUDACC__) && !defined(FMT_MODULE)\nFMT_PRAGMA_GCC(optimize(\"Og\"))\n# define FMT_GCC_OPTIMIZED\n#endif\nFMT_PRAGMA_CLANG(diagnostic push)\nFMT_PRAGMA_GCC(diagnostic push)\n\n#ifdef FMT_ALWAYS_INLINE\n// Use the provided definition.\n#elif FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_ALWAYS_INLINE inline __attribute__((always_inline))\n#else\n# define FMT_ALWAYS_INLINE inline\n#endif\n// A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode.\n#if defined(NDEBUG) || defined(FMT_GCC_OPTIMIZED)\n# define FMT_INLINE FMT_ALWAYS_INLINE\n#else\n# define FMT_INLINE inline\n#endif\n\n#ifndef FMT_BEGIN_NAMESPACE\n# define FMT_BEGIN_NAMESPACE \\\n namespace fmt { \\\n inline namespace v12 {\n# define FMT_END_NAMESPACE \\\n } \\\n }\n#endif\n\n#ifndef FMT_EXPORT\n# define FMT_EXPORT\n# define FMT_BEGIN_EXPORT\n# define FMT_END_EXPORT\n#endif\n\n#ifdef _WIN32\n# define FMT_WIN32 1\n#else\n# define FMT_WIN32 0\n#endif\n\n#if !defined(FMT_HEADER_ONLY) && FMT_WIN32\n# if defined(FMT_LIB_EXPORT)\n# define FMT_API __declspec(dllexport)\n# elif defined(FMT_SHARED)\n# define FMT_API __declspec(dllimport)\n# endif\n#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)\n# define FMT_API FMT_VISIBILITY(\"default\")\n#endif\n#ifndef FMT_API\n# define FMT_API\n#endif\n\n#ifndef FMT_OPTIMIZE_SIZE\n# define FMT_OPTIMIZE_SIZE 0\n#endif\n\n// FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher\n// per-call binary size by passing built-in types through the extension API.\n#ifndef FMT_BUILTIN_TYPES\n# define FMT_BUILTIN_TYPES 1\n#endif\n\n#define FMT_APPLY_VARIADIC(expr) \\\n using unused = int[]; \\\n (void)unused { 0, (expr, 0)... }\n\nFMT_BEGIN_NAMESPACE\n\n// Implementations of enable_if_t and other metafunctions for older systems.\ntemplate \nusing enable_if_t = typename std::enable_if::type;\ntemplate \nusing conditional_t = typename std::conditional::type;\ntemplate using bool_constant = std::integral_constant;\ntemplate \nusing remove_reference_t = typename std::remove_reference::type;\ntemplate \nusing remove_const_t = typename std::remove_const::type;\ntemplate \nusing remove_cvref_t = typename std::remove_cv>::type;\ntemplate \nusing make_unsigned_t = typename std::make_unsigned::type;\ntemplate \nusing underlying_t = typename std::underlying_type::type;\ntemplate using decay_t = typename std::decay::type;\nusing nullptr_t = decltype(nullptr);\n\n#if (FMT_GCC_VERSION && FMT_GCC_VERSION < 500) || FMT_MSC_VERSION\n// A workaround for gcc 4.9 & MSVC v141 to make void_t work in a SFINAE context.\ntemplate struct void_t_impl {\n using type = void;\n};\ntemplate using void_t = typename void_t_impl::type;\n#else\ntemplate using void_t = void;\n#endif\n\nstruct monostate {\n constexpr monostate() {}\n};\n\n// An enable_if helper to be used in template parameters which results in much\n// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed\n// to workaround a bug in MSVC 2019 (see #1140 and #1186).\n#ifdef FMT_DOC\n# define FMT_ENABLE_IF(...)\n#else\n# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0\n#endif\n\ntemplate constexpr auto min_of(T a, T b) -> T {\n return a < b ? a : b;\n}\ntemplate constexpr auto max_of(T a, T b) -> T {\n return a > b ? a : b;\n}\n\nFMT_NORETURN FMT_API void assert_fail(const char* file, int line,\n const char* message);\n\nnamespace detail {\n// Suppresses \"unused variable\" warnings with the method described in\n// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.\n// (void)var does not work on many Intel compilers.\ntemplate FMT_CONSTEXPR void ignore_unused(const T&...) {}\n\nconstexpr auto is_constant_evaluated(bool default_value = false) noexcept\n -> bool {\n// Workaround for incompatibility between clang 14 and libstdc++ consteval-based\n// std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247.\n#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \\\n (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)\n ignore_unused(default_value);\n return __builtin_is_constant_evaluated();\n#elif defined(__cpp_lib_is_constant_evaluated)\n ignore_unused(default_value);\n return std::is_constant_evaluated();\n#else\n return default_value;\n#endif\n}\n\n// Suppresses \"conditional expression is constant\" warnings.\ntemplate FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T {\n return val;\n}\n\nFMT_NORETURN FMT_API void assert_fail(const char* file, int line,\n const char* message);\n\n#if defined(FMT_ASSERT)\n// Use the provided definition.\n#elif defined(NDEBUG)\n// FMT_ASSERT is not empty to avoid -Wempty-body.\n# define FMT_ASSERT(condition, message) \\\n fmt::detail::ignore_unused((condition), (message))\n#else\n# define FMT_ASSERT(condition, message) \\\n ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \\\n ? (void)0 \\\n : ::fmt::assert_fail(__FILE__, __LINE__, (message)))\n#endif\n\n#ifdef FMT_USE_INT128\n// Use the provided definition.\n#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \\\n !(FMT_CLANG_VERSION && FMT_MSC_VERSION)\n# define FMT_USE_INT128 1\nusing int128_opt = __int128_t; // An optional native 128-bit integer.\nusing uint128_opt = __uint128_t;\ninline auto map(int128_opt x) -> int128_opt { return x; }\ninline auto map(uint128_opt x) -> uint128_opt { return x; }\n#else\n# define FMT_USE_INT128 0\n#endif\n#if !FMT_USE_INT128\nenum class int128_opt {};\nenum class uint128_opt {};\n// Reduce template instantiations.\ninline auto map(int128_opt) -> monostate { return {}; }\ninline auto map(uint128_opt) -> monostate { return {}; }\n#endif\n\n#ifdef FMT_USE_BITINT\n// Use the provided definition.\n#elif FMT_CLANG_VERSION >= 1500 && !defined(__CUDACC__)\n# define FMT_USE_BITINT 1\n#else\n# define FMT_USE_BITINT 0\n#endif\n\n#if FMT_USE_BITINT\nFMT_PRAGMA_CLANG(diagnostic ignored \"-Wbit-int-extension\")\ntemplate using bitint = _BitInt(N);\ntemplate using ubitint = unsigned _BitInt(N);\n#else\ntemplate struct bitint {};\ntemplate struct ubitint {};\n#endif // FMT_USE_BITINT\n\n// Casts a nonnegative integer to unsigned.\ntemplate \nFMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t {\n FMT_ASSERT(std::is_unsigned::value || value >= 0, \"negative value\");\n return static_cast>(value);\n}\n\ntemplate \nusing unsigned_char = conditional_t;\n\n// A heuristic to detect std::string and std::[experimental::]string_view.\n// It is mainly used to avoid dependency on <[experimental/]string_view>.\ntemplate \nstruct is_std_string_like : std::false_type {};\ntemplate \nstruct is_std_string_like().find_first_of(\n typename T::value_type(), 0))>>\n : std::is_convertible().data()),\n const typename T::value_type*> {};\n\n// Check if the literal encoding is UTF-8.\nenum { is_utf8_enabled = \"\\u00A7\"[1] == '\\xA7' };\nenum { use_utf8 = !FMT_WIN32 || is_utf8_enabled };\n\n#ifndef FMT_UNICODE\n# define FMT_UNICODE 1\n#endif\n\nstatic_assert(!FMT_UNICODE || use_utf8,\n \"Unicode support requires compiling with /utf-8\");\n\ntemplate constexpr auto narrow(T*) -> char* { return nullptr; }\nconstexpr FMT_ALWAYS_INLINE auto narrow(const char* s) -> const char* {\n return s;\n}\n\ntemplate \nFMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, size_t n) -> int {\n if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);\n for (; n != 0; ++s1, ++s2, --n) {\n if (*s1 < *s2) return -1;\n if (*s1 > *s2) return 1;\n }\n return 0;\n}\n\nnamespace adl {\nusing namespace std;\n\ntemplate \nauto invoke_back_inserter()\n -> decltype(back_inserter(std::declval()));\n} // namespace adl\n\ntemplate \nstruct is_back_insert_iterator : std::false_type {};\n\ntemplate \nstruct is_back_insert_iterator<\n It, bool_constant()),\n It>::value>> : std::true_type {};\n\n// Extracts a reference to the container from *insert_iterator.\ntemplate \ninline FMT_CONSTEXPR20 auto get_container(OutputIt it) ->\n typename OutputIt::container_type& {\n struct accessor : OutputIt {\n FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {}\n using OutputIt::container;\n };\n return *accessor(it).container;\n}\n} // namespace detail\n\n// Parsing-related public API and forward declarations.\nFMT_BEGIN_EXPORT\n\n/**\n * An implementation of `std::basic_string_view` for pre-C++17. It provides a\n * subset of the API. `fmt::basic_string_view` is used for format strings even\n * if `std::basic_string_view` is available to prevent issues when a library is\n * compiled with a different `-std` option than the client code (which is not\n * recommended).\n */\ntemplate class basic_string_view {\n private:\n const Char* data_;\n size_t size_;\n\n public:\n using value_type = Char;\n using iterator = const Char*;\n\n constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}\n\n /// Constructs a string view object from a C string and a size.\n constexpr basic_string_view(const Char* s, size_t count) noexcept\n : data_(s), size_(count) {}\n\n constexpr basic_string_view(nullptr_t) = delete;\n\n /// Constructs a string view object from a C string.\n#if FMT_GCC_VERSION\n FMT_ALWAYS_INLINE\n#endif\n FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {\n#if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION\n if (std::is_same::value && !detail::is_constant_evaluated()) {\n size_ = __builtin_strlen(detail::narrow(s)); // strlen is not constexpr.\n return;\n }\n#endif\n size_t len = 0;\n while (*s++) ++len;\n size_ = len;\n }\n\n /// Constructs a string view from a `std::basic_string` or a\n /// `std::basic_string_view` object.\n template ::value&& std::is_same<\n typename S::value_type, Char>::value)>\n FMT_CONSTEXPR basic_string_view(const S& s) noexcept\n : data_(s.data()), size_(s.size()) {}\n\n /// Returns a pointer to the string data.\n constexpr auto data() const noexcept -> const Char* { return data_; }\n\n /// Returns the string size.\n constexpr auto size() const noexcept -> size_t { return size_; }\n\n constexpr auto begin() const noexcept -> iterator { return data_; }\n constexpr auto end() const noexcept -> iterator { return data_ + size_; }\n\n constexpr auto operator[](size_t pos) const noexcept -> const Char& {\n return data_[pos];\n }\n\n FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {\n data_ += n;\n size_ -= n;\n }\n\n FMT_CONSTEXPR auto starts_with(basic_string_view sv) const noexcept\n -> bool {\n return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0;\n }\n FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool {\n return size_ >= 1 && *data_ == c;\n }\n FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool {\n return starts_with(basic_string_view(s));\n }\n\n FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {\n int result =\n detail::compare(data_, other.data_, min_of(size_, other.size_));\n if (result != 0) return result;\n return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);\n }\n\n FMT_CONSTEXPR friend auto operator==(basic_string_view lhs,\n basic_string_view rhs) -> bool {\n return lhs.compare(rhs) == 0;\n }\n friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {\n return lhs.compare(rhs) != 0;\n }\n friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {\n return lhs.compare(rhs) < 0;\n }\n friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {\n return lhs.compare(rhs) <= 0;\n }\n friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {\n return lhs.compare(rhs) > 0;\n }\n friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {\n return lhs.compare(rhs) >= 0;\n }\n};\n\nusing string_view = basic_string_view;\n\ntemplate class basic_appender;\nusing appender = basic_appender;\n\n// Checks whether T is a container with contiguous storage.\ntemplate struct is_contiguous : std::false_type {};\n\nclass context;\ntemplate class generic_context;\ntemplate class parse_context;\n\n// Longer aliases for C++20 compatibility.\ntemplate using basic_format_parse_context = parse_context;\nusing format_parse_context = parse_context;\ntemplate \nusing basic_format_context =\n conditional_t::value, context,\n generic_context>;\nusing format_context = context;\n\ntemplate \nusing buffered_context =\n conditional_t::value, context,\n generic_context, Char>>;\n\ntemplate class basic_format_arg;\ntemplate class basic_format_args;\n\n// A separate type would result in shorter symbols but break ABI compatibility\n// between clang and gcc on ARM (#1919).\nusing format_args = basic_format_args;\n\n// A formatter for objects of type T.\ntemplate \nstruct formatter {\n // A deleted default constructor indicates a disabled formatter.\n formatter() = delete;\n};\n\n/// Reports a format error at compile time or, via a `format_error` exception,\n/// at runtime.\n// This function is intentionally not constexpr to give a compile-time error.\nFMT_NORETURN FMT_API void report_error(const char* message);\n\nenum class presentation_type : unsigned char {\n // Common specifiers:\n none = 0,\n debug = 1, // '?'\n string = 2, // 's' (string, bool)\n\n // Integral, bool and character specifiers:\n dec = 3, // 'd'\n hex, // 'x' or 'X'\n oct, // 'o'\n bin, // 'b' or 'B'\n chr, // 'c'\n\n // String and pointer specifiers:\n pointer = 3, // 'p'\n\n // Floating-point specifiers:\n exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation)\n fixed, // 'f' or 'F'\n general, // 'g' or 'G'\n hexfloat // 'a' or 'A'\n};\n\nenum class align { none, left, right, center, numeric };\nenum class sign { none, minus, plus, space };\nenum class arg_id_kind { none, index, name };\n\n// Basic format specifiers for built-in and string types.\nclass basic_specs {\n private:\n // Data is arranged as follows:\n //\n // 0 1 2 3\n // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n // |type |align| w | p | s |u|#|L| f | unused |\n // +-----+-----+---+---+---+-+-+-+-----+---------------------------+\n //\n // w - dynamic width info\n // p - dynamic precision info\n // s - sign\n // u - uppercase (e.g. 'X' for 'x')\n // # - alternate form ('#')\n // L - localized\n // f - fill size\n //\n // Bitfields are not used because of compiler bugs such as gcc bug 61414.\n enum : unsigned {\n type_mask = 0x00007,\n align_mask = 0x00038,\n width_mask = 0x000C0,\n precision_mask = 0x00300,\n sign_mask = 0x00C00,\n uppercase_mask = 0x01000,\n alternate_mask = 0x02000,\n localized_mask = 0x04000,\n fill_size_mask = 0x38000,\n\n align_shift = 3,\n width_shift = 6,\n precision_shift = 8,\n sign_shift = 10,\n fill_size_shift = 15,\n\n max_fill_size = 4\n };\n\n unsigned data_ = 1 << fill_size_shift;\n static_assert(sizeof(basic_specs::data_) * CHAR_BIT >= 18, \"\");\n\n // Character (code unit) type is erased to prevent template bloat.\n char fill_data_[max_fill_size] = {' '};\n\n FMT_CONSTEXPR void set_fill_size(size_t size) {\n data_ = (data_ & ~fill_size_mask) |\n (static_cast(size) << fill_size_shift);\n }\n\n public:\n constexpr auto type() const -> presentation_type {\n return static_cast(data_ & type_mask);\n }\n FMT_CONSTEXPR void set_type(presentation_type t) {\n data_ = (data_ & ~type_mask) | static_cast(t);\n }\n\n constexpr auto align() const -> align {\n return static_cast((data_ & align_mask) >> align_shift);\n }\n FMT_CONSTEXPR void set_align(fmt::align a) {\n data_ = (data_ & ~align_mask) | (static_cast(a) << align_shift);\n }\n\n constexpr auto dynamic_width() const -> arg_id_kind {\n return static_cast((data_ & width_mask) >> width_shift);\n }\n FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w) {\n data_ = (data_ & ~width_mask) | (static_cast(w) << width_shift);\n }\n\n FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind {\n return static_cast((data_ & precision_mask) >>\n precision_shift);\n }\n FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) {\n data_ = (data_ & ~precision_mask) |\n (static_cast(p) << precision_shift);\n }\n\n constexpr auto dynamic() const -> bool {\n return (data_ & (width_mask | precision_mask)) != 0;\n }\n\n constexpr auto sign() const -> sign {\n return static_cast((data_ & sign_mask) >> sign_shift);\n }\n FMT_CONSTEXPR void set_sign(fmt::sign s) {\n data_ = (data_ & ~sign_mask) | (static_cast(s) << sign_shift);\n }\n\n constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }\n FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; }\n\n constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }\n FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; }\n FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; }\n\n constexpr auto localized() const -> bool {\n return (data_ & localized_mask) != 0;\n }\n FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; }\n\n constexpr auto fill_size() const -> size_t {\n return (data_ & fill_size_mask) >> fill_size_shift;\n }\n\n template ::value)>\n constexpr auto fill() const -> const Char* {\n return fill_data_;\n }\n template ::value)>\n constexpr auto fill() const -> const Char* {\n return nullptr;\n }\n\n template constexpr auto fill_unit() const -> Char {\n using uchar = unsigned char;\n return static_cast(static_cast(fill_data_[0]) |\n (static_cast(fill_data_[1]) << 8) |\n (static_cast(fill_data_[2]) << 16));\n }\n\n FMT_CONSTEXPR void set_fill(char c) {\n fill_data_[0] = c;\n set_fill_size(1);\n }\n\n template \n FMT_CONSTEXPR void set_fill(basic_string_view s) {\n auto size = s.size();\n set_fill_size(size);\n if (size == 1) {\n unsigned uchar = static_cast>(s[0]);\n fill_data_[0] = static_cast(uchar);\n fill_data_[1] = static_cast(uchar >> 8);\n fill_data_[2] = static_cast(uchar >> 16);\n return;\n }\n FMT_ASSERT(size <= max_fill_size, \"invalid fill\");\n for (size_t i = 0; i < size; ++i)\n fill_data_[i & 3] = static_cast(s[i]);\n }\n\n FMT_CONSTEXPR void copy_fill_from(const basic_specs& specs) {\n set_fill_size(specs.fill_size());\n for (size_t i = 0; i < max_fill_size; ++i)\n fill_data_[i] = specs.fill_data_[i];\n }\n};\n\n// Format specifiers for built-in and string types.\nstruct format_specs : basic_specs {\n int width;\n int precision;\n\n constexpr format_specs() : width(0), precision(-1) {}\n};\n\n/**\n * Parsing context consisting of a format string range being parsed and an\n * argument counter for automatic indexing.\n */\ntemplate class parse_context {\n private:\n basic_string_view fmt_;\n int next_arg_id_;\n\n enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 };\n\n FMT_CONSTEXPR void do_check_arg_id(int arg_id);\n\n public:\n using char_type = Char;\n using iterator = const Char*;\n\n constexpr explicit parse_context(basic_string_view fmt,\n int next_arg_id = 0)\n : fmt_(fmt), next_arg_id_(next_arg_id) {}\n\n /// Returns an iterator to the beginning of the format string range being\n /// parsed.\n constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); }\n\n /// Returns an iterator past the end of the format string range being parsed.\n constexpr auto end() const noexcept -> iterator { return fmt_.end(); }\n\n /// Advances the begin iterator to `it`.\n FMT_CONSTEXPR void advance_to(iterator it) {\n fmt_.remove_prefix(detail::to_unsigned(it - begin()));\n }\n\n /// Reports an error if using the manual argument indexing; otherwise returns\n /// the next argument index and switches to the automatic indexing.\n FMT_CONSTEXPR auto next_arg_id() -> int {\n if (next_arg_id_ < 0) {\n report_error(\"cannot switch from manual to automatic argument indexing\");\n return 0;\n }\n int id = next_arg_id_++;\n do_check_arg_id(id);\n return id;\n }\n\n /// Reports an error if using the automatic argument indexing; otherwise\n /// switches to the manual indexing.\n FMT_CONSTEXPR void check_arg_id(int id) {\n if (next_arg_id_ > 0) {\n report_error(\"cannot switch from automatic to manual argument indexing\");\n return;\n }\n next_arg_id_ = -1;\n do_check_arg_id(id);\n }\n FMT_CONSTEXPR void check_arg_id(basic_string_view) {\n next_arg_id_ = -1;\n }\n FMT_CONSTEXPR void check_dynamic_spec(int arg_id);\n};\n\n#ifndef FMT_USE_LOCALE\n# define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1)\n#endif\n\n// A type-erased reference to std::locale to avoid the heavy include.\nclass locale_ref {\n#if FMT_USE_LOCALE\n private:\n const void* locale_; // A type-erased pointer to std::locale.\n\n public:\n constexpr locale_ref() : locale_(nullptr) {}\n\n template \n locale_ref(const Locale& loc) : locale_(&loc) {\n // Check if std::isalpha is found via ADL to reduce the chance of misuse.\n detail::ignore_unused(isalpha('x', loc));\n }\n\n inline explicit operator bool() const noexcept { return locale_ != nullptr; }\n#endif // FMT_USE_LOCALE\n\n public:\n template auto get() const -> Locale;\n};\n\nFMT_END_EXPORT\n\nnamespace detail {\n\n// Specifies if `T` is a code unit type.\ntemplate struct is_code_unit : std::false_type {};\ntemplate <> struct is_code_unit : std::true_type {};\ntemplate <> struct is_code_unit : std::true_type {};\ntemplate <> struct is_code_unit : std::true_type {};\ntemplate <> struct is_code_unit : std::true_type {};\n#ifdef __cpp_char8_t\ntemplate <> struct is_code_unit : bool_constant {};\n#endif\n\n// Constructs fmt::basic_string_view from types implicitly convertible\n// to it, deducing Char. Explicitly convertible types such as the ones returned\n// from FMT_STRING are intentionally excluded.\ntemplate ::value)>\nconstexpr auto to_string_view(const Char* s) -> basic_string_view {\n return s;\n}\ntemplate ::value)>\nconstexpr auto to_string_view(const T& s)\n -> basic_string_view {\n return s;\n}\ntemplate \nconstexpr auto to_string_view(basic_string_view s)\n -> basic_string_view {\n return s;\n}\n\ntemplate \nstruct has_to_string_view : std::false_type {};\n// detail:: is intentional since to_string_view is not an extension point.\ntemplate \nstruct has_to_string_view<\n T, void_t()))>>\n : std::true_type {};\n\n/// String's character (code unit) type. detail:: is intentional to prevent ADL.\ntemplate ()))>\nusing char_t = typename V::value_type;\n\nenum class type {\n none_type,\n // Integer types should go first,\n int_type,\n uint_type,\n long_long_type,\n ulong_long_type,\n int128_type,\n uint128_type,\n bool_type,\n char_type,\n last_integer_type = char_type,\n // followed by floating-point types.\n float_type,\n double_type,\n long_double_type,\n last_numeric_type = long_double_type,\n cstring_type,\n string_type,\n pointer_type,\n custom_type\n};\n\n// Maps core type T to the corresponding type enum constant.\ntemplate \nstruct type_constant : std::integral_constant {};\n\n#define FMT_TYPE_CONSTANT(Type, constant) \\\n template \\\n struct type_constant \\\n : std::integral_constant {}\n\nFMT_TYPE_CONSTANT(int, int_type);\nFMT_TYPE_CONSTANT(unsigned, uint_type);\nFMT_TYPE_CONSTANT(long long, long_long_type);\nFMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);\nFMT_TYPE_CONSTANT(int128_opt, int128_type);\nFMT_TYPE_CONSTANT(uint128_opt, uint128_type);\nFMT_TYPE_CONSTANT(bool, bool_type);\nFMT_TYPE_CONSTANT(Char, char_type);\nFMT_TYPE_CONSTANT(float, float_type);\nFMT_TYPE_CONSTANT(double, double_type);\nFMT_TYPE_CONSTANT(long double, long_double_type);\nFMT_TYPE_CONSTANT(const Char*, cstring_type);\nFMT_TYPE_CONSTANT(basic_string_view, string_type);\nFMT_TYPE_CONSTANT(const void*, pointer_type);\n\nconstexpr auto is_integral_type(type t) -> bool {\n return t > type::none_type && t <= type::last_integer_type;\n}\nconstexpr auto is_arithmetic_type(type t) -> bool {\n return t > type::none_type && t <= type::last_numeric_type;\n}\n\nconstexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); }\nconstexpr auto in(type t, int set) -> bool {\n return ((set >> static_cast(t)) & 1) != 0;\n}\n\n// Bitsets of types.\nenum {\n sint_set =\n set(type::int_type) | set(type::long_long_type) | set(type::int128_type),\n uint_set = set(type::uint_type) | set(type::ulong_long_type) |\n set(type::uint128_type),\n bool_set = set(type::bool_type),\n char_set = set(type::char_type),\n float_set = set(type::float_type) | set(type::double_type) |\n set(type::long_double_type),\n string_set = set(type::string_type),\n cstring_set = set(type::cstring_type),\n pointer_set = set(type::pointer_type)\n};\n\nstruct view {};\n\ntemplate \nstruct is_view : std::false_type {};\ntemplate \nstruct is_view> : std::is_base_of {};\n\ntemplate struct named_arg;\ntemplate struct is_named_arg : std::false_type {};\ntemplate struct is_static_named_arg : std::false_type {};\n\ntemplate \nstruct is_named_arg> : std::true_type {};\n\ntemplate struct named_arg : view {\n const Char* name;\n const T& value;\n\n named_arg(const Char* n, const T& v) : name(n), value(v) {}\n static_assert(!is_named_arg::value, \"nested named arguments\");\n};\n\ntemplate constexpr auto count() -> int { return B ? 1 : 0; }\ntemplate constexpr auto count() -> int {\n return (B1 ? 1 : 0) + count();\n}\n\ntemplate constexpr auto count_named_args() -> int {\n return count::value...>();\n}\ntemplate constexpr auto count_static_named_args() -> int {\n return count::value...>();\n}\n\ntemplate struct named_arg_info {\n const Char* name;\n int id;\n};\n\n// named_args is non-const to suppress a bogus -Wmaybe-uninitialized in gcc 13.\ntemplate \nFMT_CONSTEXPR void check_for_duplicate(named_arg_info* named_args,\n int named_arg_index,\n basic_string_view arg_name) {\n for (int i = 0; i < named_arg_index; ++i) {\n if (named_args[i].name == arg_name) report_error(\"duplicate named arg\");\n }\n}\n\ntemplate ::value)>\nvoid init_named_arg(named_arg_info*, int& arg_index, int&, const T&) {\n ++arg_index;\n}\ntemplate ::value)>\nvoid init_named_arg(named_arg_info* named_args, int& arg_index,\n int& named_arg_index, const T& arg) {\n check_for_duplicate(named_args, named_arg_index, arg.name);\n named_args[named_arg_index++] = {arg.name, arg_index++};\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR void init_static_named_arg(named_arg_info*, int& arg_index,\n int&) {\n ++arg_index;\n}\ntemplate ::value)>\nFMT_CONSTEXPR void init_static_named_arg(named_arg_info* named_args,\n int& arg_index, int& named_arg_index) {\n check_for_duplicate(named_args, named_arg_index, T::name);\n named_args[named_arg_index++] = {T::name, arg_index++};\n}\n\n// To minimize the number of types we need to deal with, long is translated\n// either to int or to long long depending on its size.\nenum { long_short = sizeof(long) == sizeof(int) && FMT_BUILTIN_TYPES };\nusing long_type = conditional_t;\nusing ulong_type = conditional_t;\n\ntemplate \nusing format_as_result =\n remove_cvref_t()))>;\ntemplate \nusing format_as_member_result =\n remove_cvref_t::format_as(std::declval()))>;\n\ntemplate \nstruct use_format_as : std::false_type {};\n// format_as member is only used to avoid injection into the std namespace.\ntemplate \nstruct use_format_as_member : std::false_type {};\n\n// Only map owning types because mapping views can be unsafe.\ntemplate \nstruct use_format_as<\n T, bool_constant>::value>>\n : std::true_type {};\ntemplate \nstruct use_format_as_member<\n T, bool_constant>::value>>\n : std::true_type {};\n\ntemplate >\nusing use_formatter =\n bool_constant<(std::is_class::value || std::is_enum::value ||\n std::is_union::value || std::is_array::value) &&\n !has_to_string_view::value && !is_named_arg::value &&\n !use_format_as::value && !use_format_as_member::value>;\n\ntemplate >\nauto has_formatter_impl(T* p, buffered_context* ctx = nullptr)\n -> decltype(formatter().format(*p, *ctx), std::true_type());\ntemplate auto has_formatter_impl(...) -> std::false_type;\n\n// T can be const-qualified to check if it is const-formattable.\ntemplate constexpr auto has_formatter() -> bool {\n return decltype(has_formatter_impl(static_cast(nullptr)))::value;\n}\n\n// Maps formatting argument types to natively supported types or user-defined\n// types with formatters. Returns void on errors to be SFINAE-friendly.\ntemplate struct type_mapper {\n static auto map(signed char) -> int;\n static auto map(unsigned char) -> unsigned;\n static auto map(short) -> int;\n static auto map(unsigned short) -> unsigned;\n static auto map(int) -> int;\n static auto map(unsigned) -> unsigned;\n static auto map(long) -> long_type;\n static auto map(unsigned long) -> ulong_type;\n static auto map(long long) -> long long;\n static auto map(unsigned long long) -> unsigned long long;\n static auto map(int128_opt) -> int128_opt;\n static auto map(uint128_opt) -> uint128_opt;\n static auto map(bool) -> bool;\n\n template \n static auto map(bitint) -> conditional_t;\n template \n static auto map(ubitint)\n -> conditional_t;\n\n template ::value)>\n static auto map(T) -> conditional_t<\n std::is_same::value || std::is_same::value, Char, void>;\n\n static auto map(float) -> float;\n static auto map(double) -> double;\n static auto map(long double) -> long double;\n\n static auto map(Char*) -> const Char*;\n static auto map(const Char*) -> const Char*;\n template ,\n FMT_ENABLE_IF(!std::is_pointer::value)>\n static auto map(const T&) -> conditional_t::value,\n basic_string_view, void>;\n\n static auto map(void*) -> const void*;\n static auto map(const void*) -> const void*;\n static auto map(volatile void*) -> const void*;\n static auto map(const volatile void*) -> const void*;\n static auto map(nullptr_t) -> const void*;\n template ::value ||\n std::is_member_pointer::value)>\n static auto map(const T&) -> void;\n\n template ::value)>\n static auto map(const T& x) -> decltype(map(format_as(x)));\n template ::value)>\n static auto map(const T& x) -> decltype(map(formatter::format_as(x)));\n\n template ::value)>\n static auto map(T&) -> conditional_t(), T&, void>;\n\n template ::value)>\n static auto map(const T& named_arg) -> decltype(map(named_arg.value));\n};\n\n// detail:: is used to workaround a bug in MSVC 2017.\ntemplate \nusing mapped_t = decltype(detail::type_mapper::map(std::declval()));\n\n// A type constant after applying type_mapper.\ntemplate \nusing mapped_type_constant = type_constant, Char>;\n\ntemplate ::value>\nusing stored_type_constant = std::integral_constant<\n type, Context::builtin_types || TYPE == type::int_type ? TYPE\n : type::custom_type>;\n// A parse context with extra data used only in compile-time checks.\ntemplate \nclass compile_parse_context : public parse_context {\n private:\n int num_args_;\n const type* types_;\n using base = parse_context;\n\n public:\n FMT_CONSTEXPR explicit compile_parse_context(basic_string_view fmt,\n int num_args, const type* types,\n int next_arg_id = 0)\n : base(fmt, next_arg_id), num_args_(num_args), types_(types) {}\n\n constexpr auto num_args() const -> int { return num_args_; }\n constexpr auto arg_type(int id) const -> type { return types_[id]; }\n\n FMT_CONSTEXPR auto next_arg_id() -> int {\n int id = base::next_arg_id();\n if (id >= num_args_) report_error(\"argument not found\");\n return id;\n }\n\n FMT_CONSTEXPR void check_arg_id(int id) {\n base::check_arg_id(id);\n if (id >= num_args_) report_error(\"argument not found\");\n }\n using base::check_arg_id;\n\n FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {\n ignore_unused(arg_id);\n if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))\n report_error(\"width/precision is not integer\");\n }\n};\n\n// An argument reference.\ntemplate union arg_ref {\n FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}\n FMT_CONSTEXPR arg_ref(basic_string_view n) : name(n) {}\n\n int index;\n basic_string_view name;\n};\n\n// Format specifiers with width and precision resolved at formatting rather\n// than parsing time to allow reusing the same parsed specifiers with\n// different sets of arguments (precompilation of format strings).\ntemplate struct dynamic_format_specs : format_specs {\n arg_ref width_ref;\n arg_ref precision_ref;\n};\n\n// Converts a character to ASCII. Returns '\\0' on conversion failure.\ntemplate ::value)>\nconstexpr auto to_ascii(Char c) -> char {\n return c <= 0xff ? static_cast(c) : '\\0';\n}\n\n// Returns the number of code units in a code point or 1 on error.\ntemplate \nFMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {\n if (const_check(sizeof(Char) != 1)) return 1;\n auto c = static_cast(*begin);\n return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1;\n}\n\n// Parses the range [begin, end) as an unsigned integer. This function assumes\n// that the range is non-empty and the first character is a digit.\ntemplate \nFMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,\n int error_value) noexcept -> int {\n FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', \"\");\n unsigned value = 0, prev = 0;\n auto p = begin;\n do {\n prev = value;\n value = value * 10 + unsigned(*p - '0');\n ++p;\n } while (p != end && '0' <= *p && *p <= '9');\n auto num_digits = p - begin;\n begin = p;\n int digits10 = static_cast(sizeof(int) * CHAR_BIT * 3 / 10);\n if (num_digits <= digits10) return static_cast(value);\n // Check for overflow.\n unsigned max = INT_MAX;\n return num_digits == digits10 + 1 &&\n prev * 10ull + unsigned(p[-1] - '0') <= max\n ? static_cast(value)\n : error_value;\n}\n\nFMT_CONSTEXPR inline auto parse_align(char c) -> align {\n switch (c) {\n case '<': return align::left;\n case '>': return align::right;\n case '^': return align::center;\n }\n return align::none;\n}\n\ntemplate constexpr auto is_name_start(Char c) -> bool {\n return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';\n}\n\ntemplate \nFMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end,\n Handler&& handler) -> const Char* {\n Char c = *begin;\n if (c >= '0' && c <= '9') {\n int index = 0;\n if (c != '0')\n index = parse_nonnegative_int(begin, end, INT_MAX);\n else\n ++begin;\n if (begin == end || (*begin != '}' && *begin != ':'))\n report_error(\"invalid format string\");\n else\n handler.on_index(index);\n return begin;\n }\n if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) {\n report_error(\"invalid format string\");\n return begin;\n }\n auto it = begin;\n do {\n ++it;\n } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));\n handler.on_name({begin, to_unsigned(it - begin)});\n return it;\n}\n\ntemplate struct dynamic_spec_handler {\n parse_context& ctx;\n arg_ref& ref;\n arg_id_kind& kind;\n\n FMT_CONSTEXPR void on_index(int id) {\n ref = id;\n kind = arg_id_kind::index;\n ctx.check_arg_id(id);\n ctx.check_dynamic_spec(id);\n }\n FMT_CONSTEXPR void on_name(basic_string_view id) {\n ref = id;\n kind = arg_id_kind::name;\n ctx.check_arg_id(id);\n }\n};\n\ntemplate struct parse_dynamic_spec_result {\n const Char* end;\n arg_id_kind kind;\n};\n\n// Parses integer | \"{\" [arg_id] \"}\".\ntemplate \nFMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,\n int& value, arg_ref& ref,\n parse_context& ctx)\n -> parse_dynamic_spec_result {\n FMT_ASSERT(begin != end, \"\");\n auto kind = arg_id_kind::none;\n if ('0' <= *begin && *begin <= '9') {\n int val = parse_nonnegative_int(begin, end, -1);\n if (val == -1) report_error(\"number is too big\");\n value = val;\n } else {\n if (*begin == '{') {\n ++begin;\n if (begin != end) {\n Char c = *begin;\n if (c == '}' || c == ':') {\n int id = ctx.next_arg_id();\n ref = id;\n kind = arg_id_kind::index;\n ctx.check_dynamic_spec(id);\n } else {\n begin = parse_arg_id(begin, end,\n dynamic_spec_handler{ctx, ref, kind});\n }\n }\n if (begin != end && *begin == '}') return {++begin, kind};\n }\n report_error(\"invalid format string\");\n }\n return {begin, kind};\n}\n\ntemplate \nFMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,\n format_specs& specs, arg_ref& width_ref,\n parse_context& ctx) -> const Char* {\n auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx);\n specs.set_dynamic_width(result.kind);\n return result.end;\n}\n\ntemplate \nFMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,\n format_specs& specs,\n arg_ref& precision_ref,\n parse_context& ctx) -> const Char* {\n ++begin;\n if (begin == end) {\n report_error(\"invalid precision\");\n return begin;\n }\n auto result =\n parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);\n specs.set_dynamic_precision(result.kind);\n return result.end;\n}\n\nenum class state { start, align, sign, hash, zero, width, precision, locale };\n\n// Parses standard format specifiers.\ntemplate \nFMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,\n dynamic_format_specs& specs,\n parse_context& ctx, type arg_type)\n -> const Char* {\n auto c = '\\0';\n if (end - begin > 1) {\n auto next = to_ascii(begin[1]);\n c = parse_align(next) == align::none ? to_ascii(*begin) : '\\0';\n } else {\n if (begin == end) return begin;\n c = to_ascii(*begin);\n }\n\n struct {\n state current_state = state::start;\n FMT_CONSTEXPR void operator()(state s, bool valid = true) {\n if (current_state >= s || !valid)\n report_error(\"invalid format specifier\");\n current_state = s;\n }\n } enter_state;\n\n using pres = presentation_type;\n constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;\n struct {\n const Char*& begin;\n format_specs& specs;\n type arg_type;\n\n FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {\n if (!in(arg_type, set)) report_error(\"invalid format specifier\");\n specs.set_type(pres_type);\n return begin + 1;\n }\n } parse_presentation_type{begin, specs, arg_type};\n\n for (;;) {\n switch (c) {\n case '<':\n case '>':\n case '^':\n enter_state(state::align);\n specs.set_align(parse_align(c));\n ++begin;\n break;\n case '+':\n case ' ':\n specs.set_sign(c == ' ' ? sign::space : sign::plus);\n FMT_FALLTHROUGH;\n case '-':\n enter_state(state::sign, in(arg_type, sint_set | float_set));\n ++begin;\n break;\n case '#':\n enter_state(state::hash, is_arithmetic_type(arg_type));\n specs.set_alt();\n ++begin;\n break;\n case '0':\n enter_state(state::zero);\n if (!is_arithmetic_type(arg_type))\n report_error(\"format specifier requires numeric argument\");\n if (specs.align() == align::none) {\n // Ignore 0 if align is specified for compatibility with std::format.\n specs.set_align(align::numeric);\n specs.set_fill('0');\n }\n ++begin;\n break;\n // clang-format off\n case '1': case '2': case '3': case '4': case '5':\n case '6': case '7': case '8': case '9': case '{':\n // clang-format on\n enter_state(state::width);\n begin = parse_width(begin, end, specs, specs.width_ref, ctx);\n break;\n case '.':\n enter_state(state::precision,\n in(arg_type, float_set | string_set | cstring_set));\n begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);\n break;\n case 'L':\n enter_state(state::locale, is_arithmetic_type(arg_type));\n specs.set_localized();\n ++begin;\n break;\n case 'd': return parse_presentation_type(pres::dec, integral_set);\n case 'X': specs.set_upper(); FMT_FALLTHROUGH;\n case 'x': return parse_presentation_type(pres::hex, integral_set);\n case 'o': return parse_presentation_type(pres::oct, integral_set);\n case 'B': specs.set_upper(); FMT_FALLTHROUGH;\n case 'b': return parse_presentation_type(pres::bin, integral_set);\n case 'E': specs.set_upper(); FMT_FALLTHROUGH;\n case 'e': return parse_presentation_type(pres::exp, float_set);\n case 'F': specs.set_upper(); FMT_FALLTHROUGH;\n case 'f': return parse_presentation_type(pres::fixed, float_set);\n case 'G': specs.set_upper(); FMT_FALLTHROUGH;\n case 'g': return parse_presentation_type(pres::general, float_set);\n case 'A': specs.set_upper(); FMT_FALLTHROUGH;\n case 'a': return parse_presentation_type(pres::hexfloat, float_set);\n case 'c':\n if (arg_type == type::bool_type) report_error(\"invalid format specifier\");\n return parse_presentation_type(pres::chr, integral_set);\n case 's':\n return parse_presentation_type(pres::string,\n bool_set | string_set | cstring_set);\n case 'p':\n return parse_presentation_type(pres::pointer, pointer_set | cstring_set);\n case '?':\n return parse_presentation_type(pres::debug,\n char_set | string_set | cstring_set);\n case '}': return begin;\n default: {\n if (*begin == '}') return begin;\n // Parse fill and alignment.\n auto fill_end = begin + code_point_length(begin);\n if (end - fill_end <= 0) {\n report_error(\"invalid format specifier\");\n return begin;\n }\n if (*begin == '{') {\n report_error(\"invalid fill character '{'\");\n return begin;\n }\n auto alignment = parse_align(to_ascii(*fill_end));\n enter_state(state::align, alignment != align::none);\n specs.set_fill(\n basic_string_view(begin, to_unsigned(fill_end - begin)));\n specs.set_align(alignment);\n begin = fill_end + 1;\n }\n }\n if (begin == end) return begin;\n c = to_ascii(*begin);\n }\n}\n\ntemplate \nFMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin,\n const Char* end,\n Handler&& handler)\n -> const Char* {\n ++begin;\n if (begin == end) {\n handler.on_error(\"invalid format string\");\n return end;\n }\n int arg_id = 0;\n switch (*begin) {\n case '}':\n handler.on_replacement_field(handler.on_arg_id(), begin);\n return begin + 1;\n case '{': handler.on_text(begin, begin + 1); return begin + 1;\n case ':': arg_id = handler.on_arg_id(); break;\n default: {\n struct id_adapter {\n Handler& handler;\n int arg_id;\n\n FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }\n FMT_CONSTEXPR void on_name(basic_string_view id) {\n arg_id = handler.on_arg_id(id);\n }\n } adapter = {handler, 0};\n begin = parse_arg_id(begin, end, adapter);\n arg_id = adapter.arg_id;\n Char c = begin != end ? *begin : Char();\n if (c == '}') {\n handler.on_replacement_field(arg_id, begin);\n return begin + 1;\n }\n if (c != ':') {\n handler.on_error(\"missing '}' in format string\");\n return end;\n }\n break;\n }\n }\n begin = handler.on_format_specs(arg_id, begin + 1, end);\n if (begin == end || *begin != '}')\n return handler.on_error(\"unknown format specifier\"), end;\n return begin + 1;\n}\n\ntemplate \nFMT_CONSTEXPR void parse_format_string(basic_string_view fmt,\n Handler&& handler) {\n auto begin = fmt.data(), end = begin + fmt.size();\n auto p = begin;\n while (p != end) {\n auto c = *p++;\n if (c == '{') {\n handler.on_text(begin, p - 1);\n begin = p = parse_replacement_field(p - 1, end, handler);\n } else if (c == '}') {\n if (p == end || *p != '}')\n return handler.on_error(\"unmatched '}' in format string\");\n handler.on_text(begin, p);\n begin = ++p;\n }\n }\n handler.on_text(begin, end);\n}\n\n// Checks char specs and returns true iff the presentation type is char-like.\nFMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool {\n auto type = specs.type();\n if (type != presentation_type::none && type != presentation_type::chr &&\n type != presentation_type::debug) {\n return false;\n }\n if (specs.align() == align::numeric || specs.sign() != sign::none ||\n specs.alt()) {\n report_error(\"invalid format specifier for char\");\n }\n return true;\n}\n\n// A base class for compile-time strings.\nstruct compile_string {};\n\ntemplate \nFMT_VISIBILITY(\"hidden\") // Suppress an ld warning on macOS (#3769).\nFMT_CONSTEXPR auto invoke_parse(parse_context& ctx) -> const Char* {\n using mapped_type = remove_cvref_t>;\n constexpr bool formattable =\n std::is_constructible>::value;\n if (!formattable) return ctx.begin(); // Error is reported in the value ctor.\n using formatted_type = conditional_t;\n return formatter().parse(ctx);\n}\n\ntemplate struct arg_pack {};\n\ntemplate \nclass format_string_checker {\n private:\n type types_[max_of(1, NUM_ARGS)];\n named_arg_info named_args_[max_of(1, NUM_NAMED_ARGS)];\n compile_parse_context context_;\n\n using parse_func = auto (*)(parse_context&) -> const Char*;\n parse_func parse_funcs_[max_of(1, NUM_ARGS)];\n\n public:\n template \n FMT_CONSTEXPR explicit format_string_checker(basic_string_view fmt,\n arg_pack)\n : types_{mapped_type_constant::value...},\n named_args_{},\n context_(fmt, NUM_ARGS, types_),\n parse_funcs_{&invoke_parse...} {\n int arg_index = 0, named_arg_index = 0;\n FMT_APPLY_VARIADIC(\n init_static_named_arg(named_args_, arg_index, named_arg_index));\n ignore_unused(arg_index, named_arg_index);\n }\n\n FMT_CONSTEXPR void on_text(const Char*, const Char*) {}\n\n FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }\n FMT_CONSTEXPR auto on_arg_id(int id) -> int {\n context_.check_arg_id(id);\n return id;\n }\n FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int {\n for (int i = 0; i < NUM_NAMED_ARGS; ++i) {\n if (named_args_[i].name == id) return named_args_[i].id;\n }\n if (!DYNAMIC_NAMES) on_error(\"argument not found\");\n return -1;\n }\n\n FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {\n on_format_specs(id, begin, begin); // Call parse() on empty specs.\n }\n\n FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end)\n -> const Char* {\n context_.advance_to(begin);\n if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_);\n\n // If id is out of range, it means we do not know the type and cannot parse\n // the format at compile time. Instead, skip over content until we finish\n // the format spec, accounting for any nested replacements.\n for (int bracket_count = 0;\n begin != end && (bracket_count > 0 || *begin != '}'); ++begin) {\n if (*begin == '{')\n ++bracket_count;\n else if (*begin == '}')\n --bracket_count;\n }\n return begin;\n }\n\n FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) {\n report_error(message);\n }\n};\n\n/// A contiguous memory buffer with an optional growing ability. It is an\n/// internal class and shouldn't be used directly, only via `memory_buffer`.\ntemplate class buffer {\n private:\n T* ptr_;\n size_t size_;\n size_t capacity_;\n\n using grow_fun = void (*)(buffer& buf, size_t capacity);\n grow_fun grow_;\n\n protected:\n // Don't initialize ptr_ since it is not accessed to save a few cycles.\n FMT_MSC_WARNING(suppress : 26495)\n FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept\n : size_(sz), capacity_(sz), grow_(grow) {}\n\n constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0,\n size_t cap = 0) noexcept\n : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}\n\n FMT_CONSTEXPR20 ~buffer() = default;\n buffer(buffer&&) = default;\n\n /// Sets the buffer data and capacity.\n FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {\n ptr_ = buf_data;\n capacity_ = buf_capacity;\n }\n\n public:\n using value_type = T;\n using const_reference = const T&;\n\n buffer(const buffer&) = delete;\n void operator=(const buffer&) = delete;\n\n auto begin() noexcept -> T* { return ptr_; }\n auto end() noexcept -> T* { return ptr_ + size_; }\n\n auto begin() const noexcept -> const T* { return ptr_; }\n auto end() const noexcept -> const T* { return ptr_ + size_; }\n\n /// Returns the size of this buffer.\n constexpr auto size() const noexcept -> size_t { return size_; }\n\n /// Returns the capacity of this buffer.\n constexpr auto capacity() const noexcept -> size_t { return capacity_; }\n\n /// Returns a pointer to the buffer data (not null-terminated).\n FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }\n FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }\n\n /// Clears this buffer.\n FMT_CONSTEXPR void clear() { size_ = 0; }\n\n // Tries resizing the buffer to contain `count` elements. If T is a POD type\n // the new elements may not be initialized.\n FMT_CONSTEXPR void try_resize(size_t count) {\n try_reserve(count);\n size_ = min_of(count, capacity_);\n }\n\n // Tries increasing the buffer capacity to `new_capacity`. It can increase the\n // capacity by a smaller amount than requested but guarantees there is space\n // for at least one additional element either by increasing the capacity or by\n // flushing the buffer if it is full.\n FMT_CONSTEXPR void try_reserve(size_t new_capacity) {\n if (new_capacity > capacity_) grow_(*this, new_capacity);\n }\n\n FMT_CONSTEXPR void push_back(const T& value) {\n try_reserve(size_ + 1);\n ptr_[size_++] = value;\n }\n\n /// Appends data to the end of the buffer.\n template \n// Workaround for MSVC2019 to fix error C2893: Failed to specialize function\n// template 'void fmt::v11::detail::buffer::append(const U *,const U *)'.\n#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940\n FMT_CONSTEXPR20\n#endif\n void\n append(const U* begin, const U* end) {\n while (begin != end) {\n auto size = size_;\n auto free_cap = capacity_ - size;\n auto count = to_unsigned(end - begin);\n if (free_cap < count) {\n grow_(*this, size + count);\n size = size_;\n free_cap = capacity_ - size;\n count = count < free_cap ? count : free_cap;\n }\n // A loop is faster than memcpy on small sizes.\n T* out = ptr_ + size;\n for (size_t i = 0; i < count; ++i) out[i] = begin[i];\n size_ += count;\n begin += count;\n }\n }\n\n template FMT_CONSTEXPR auto operator[](Idx index) -> T& {\n return ptr_[index];\n }\n template \n FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {\n return ptr_[index];\n }\n};\n\nstruct buffer_traits {\n constexpr explicit buffer_traits(size_t) {}\n constexpr auto count() const -> size_t { return 0; }\n constexpr auto limit(size_t size) const -> size_t { return size; }\n};\n\nclass fixed_buffer_traits {\n private:\n size_t count_ = 0;\n size_t limit_;\n\n public:\n constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}\n constexpr auto count() const -> size_t { return count_; }\n FMT_CONSTEXPR auto limit(size_t size) -> size_t {\n size_t n = limit_ > count_ ? limit_ - count_ : 0;\n count_ += size;\n return min_of(size, n);\n }\n};\n\n// A buffer that writes to an output iterator when flushed.\ntemplate \nclass iterator_buffer : public Traits, public buffer {\n private:\n OutputIt out_;\n enum { buffer_size = 256 };\n T data_[buffer_size];\n\n static FMT_CONSTEXPR void grow(buffer& buf, size_t) {\n if (buf.size() == buffer_size) static_cast(buf).flush();\n }\n\n void flush() {\n auto size = this->size();\n this->clear();\n const T* begin = data_;\n const T* end = begin + this->limit(size);\n while (begin != end) *out_++ = *begin++;\n }\n\n public:\n explicit iterator_buffer(OutputIt out, size_t n = buffer_size)\n : Traits(n), buffer(grow, data_, 0, buffer_size), out_(out) {}\n iterator_buffer(iterator_buffer&& other) noexcept\n : Traits(other),\n buffer(grow, data_, 0, buffer_size),\n out_(other.out_) {}\n ~iterator_buffer() {\n // Don't crash if flush fails during unwinding.\n FMT_TRY { flush(); }\n FMT_CATCH(...) {}\n }\n\n auto out() -> OutputIt {\n flush();\n return out_;\n }\n auto count() const -> size_t { return Traits::count() + this->size(); }\n};\n\ntemplate \nclass iterator_buffer : public fixed_buffer_traits,\n public buffer {\n private:\n T* out_;\n enum { buffer_size = 256 };\n T data_[buffer_size];\n\n static FMT_CONSTEXPR void grow(buffer& buf, size_t) {\n if (buf.size() == buf.capacity())\n static_cast(buf).flush();\n }\n\n void flush() {\n size_t n = this->limit(this->size());\n if (this->data() == out_) {\n out_ += n;\n this->set(data_, buffer_size);\n }\n this->clear();\n }\n\n public:\n explicit iterator_buffer(T* out, size_t n = buffer_size)\n : fixed_buffer_traits(n), buffer(grow, out, 0, n), out_(out) {}\n iterator_buffer(iterator_buffer&& other) noexcept\n : fixed_buffer_traits(other),\n buffer(static_cast(other)),\n out_(other.out_) {\n if (this->data() != out_) {\n this->set(data_, buffer_size);\n this->clear();\n }\n }\n ~iterator_buffer() { flush(); }\n\n auto out() -> T* {\n flush();\n return out_;\n }\n auto count() const -> size_t {\n return fixed_buffer_traits::count() + this->size();\n }\n};\n\ntemplate class iterator_buffer : public buffer {\n public:\n explicit iterator_buffer(T* out, size_t = 0)\n : buffer([](buffer&, size_t) {}, out, 0, ~size_t()) {}\n\n auto out() -> T* { return &*this->end(); }\n};\n\ntemplate \nclass container_buffer : public buffer {\n private:\n using value_type = typename Container::value_type;\n\n static FMT_CONSTEXPR void grow(buffer& buf, size_t capacity) {\n auto& self = static_cast(buf);\n self.container.resize(capacity);\n self.set(&self.container[0], capacity);\n }\n\n public:\n Container& container;\n\n explicit container_buffer(Container& c)\n : buffer(grow, c.size()), container(c) {}\n};\n\n// A buffer that writes to a container with the contiguous storage.\ntemplate \nclass iterator_buffer<\n OutputIt,\n enable_if_t::value &&\n is_contiguous::value,\n typename OutputIt::container_type::value_type>>\n : public container_buffer {\n private:\n using base = container_buffer;\n\n public:\n explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {}\n explicit iterator_buffer(OutputIt out, size_t = 0)\n : base(get_container(out)) {}\n\n auto out() -> OutputIt { return OutputIt(this->container); }\n};\n\n// A buffer that counts the number of code units written discarding the output.\ntemplate class counting_buffer : public buffer {\n private:\n enum { buffer_size = 256 };\n T data_[buffer_size];\n size_t count_ = 0;\n\n static FMT_CONSTEXPR void grow(buffer& buf, size_t) {\n if (buf.size() != buffer_size) return;\n static_cast(buf).count_ += buf.size();\n buf.clear();\n }\n\n public:\n FMT_CONSTEXPR counting_buffer() : buffer(grow, data_, 0, buffer_size) {}\n\n constexpr auto count() const noexcept -> size_t {\n return count_ + this->size();\n }\n};\n\ntemplate \nstruct is_back_insert_iterator> : std::true_type {};\n\ntemplate \nstruct has_back_insert_iterator_container_append : std::false_type {};\ntemplate \nstruct has_back_insert_iterator_container_append<\n OutputIt, InputIt,\n void_t())\n .append(std::declval(),\n std::declval()))>> : std::true_type {};\n\ntemplate \nstruct has_back_insert_iterator_container_insert_at_end : std::false_type {};\n\ntemplate \nstruct has_back_insert_iterator_container_insert_at_end<\n OutputIt, InputIt,\n void_t())\n .insert(get_container(std::declval()).end(),\n std::declval(),\n std::declval()))>> : std::true_type {};\n\n// An optimized version of std::copy with the output value type (T).\ntemplate ::value&&\n has_back_insert_iterator_container_append<\n OutputIt, InputIt>::value)>\nFMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)\n -> OutputIt {\n get_container(out).append(begin, end);\n return out;\n}\n\ntemplate ::value &&\n !has_back_insert_iterator_container_append<\n OutputIt, InputIt>::value &&\n has_back_insert_iterator_container_insert_at_end<\n OutputIt, InputIt>::value)>\nFMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)\n -> OutputIt {\n auto& c = get_container(out);\n c.insert(c.end(), begin, end);\n return out;\n}\n\ntemplate ::value &&\n (has_back_insert_iterator_container_append<\n OutputIt, InputIt>::value ||\n has_back_insert_iterator_container_insert_at_end<\n OutputIt, InputIt>::value)))>\nFMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {\n while (begin != end) *out++ = static_cast(*begin++);\n return out;\n}\n\ntemplate \nFMT_CONSTEXPR auto copy(basic_string_view s, OutputIt out) -> OutputIt {\n return copy(s.begin(), s.end(), out);\n}\n\ntemplate \nstruct is_buffer_appender : std::false_type {};\ntemplate \nstruct is_buffer_appender<\n It, bool_constant<\n is_back_insert_iterator::value &&\n std::is_base_of,\n typename It::container_type>::value>>\n : std::true_type {};\n\n// Maps an output iterator to a buffer.\ntemplate ::value)>\nauto get_buffer(OutputIt out) -> iterator_buffer {\n return iterator_buffer(out);\n}\ntemplate ::value)>\nauto get_buffer(OutputIt out) -> buffer& {\n return get_container(out);\n}\n\ntemplate \nauto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {\n return buf.out();\n}\ntemplate \nauto get_iterator(buffer&, OutputIt out) -> OutputIt {\n return out;\n}\n\n// This type is intentionally undefined, only used for errors.\ntemplate struct type_is_unformattable_for;\n\ntemplate struct string_value {\n const Char* data;\n size_t size;\n auto str() const -> basic_string_view { return {data, size}; }\n};\n\ntemplate struct custom_value {\n using char_type = typename Context::char_type;\n void* value;\n void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);\n};\n\ntemplate struct named_arg_value {\n const named_arg_info* data;\n size_t size;\n};\n\nstruct custom_tag {};\n\n#if !FMT_BUILTIN_TYPES\n# define FMT_BUILTIN , monostate\n#else\n# define FMT_BUILTIN\n#endif\n\n// A formatting argument value.\ntemplate class value {\n public:\n using char_type = typename Context::char_type;\n\n union {\n monostate no_value;\n int int_value;\n unsigned uint_value;\n long long long_long_value;\n unsigned long long ulong_long_value;\n int128_opt int128_value;\n uint128_opt uint128_value;\n bool bool_value;\n char_type char_value;\n float float_value;\n double double_value;\n long double long_double_value;\n const void* pointer;\n string_value string;\n custom_value custom;\n named_arg_value named_args;\n };\n\n constexpr FMT_INLINE value() : no_value() {}\n constexpr FMT_INLINE value(signed char x) : int_value(x) {}\n constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN) : uint_value(x) {}\n constexpr FMT_INLINE value(signed short x) : int_value(x) {}\n constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN) : uint_value(x) {}\n constexpr FMT_INLINE value(int x) : int_value(x) {}\n constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {}\n FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN) : value(long_type(x)) {}\n FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN)\n : value(ulong_type(x)) {}\n constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {}\n constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN)\n : ulong_long_value(x) {}\n FMT_INLINE value(int128_opt x FMT_BUILTIN) : int128_value(x) {}\n FMT_INLINE value(uint128_opt x FMT_BUILTIN) : uint128_value(x) {}\n constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {}\n\n template \n constexpr FMT_INLINE value(bitint x FMT_BUILTIN) : long_long_value(x) {\n static_assert(N <= 64, \"unsupported _BitInt\");\n }\n template \n constexpr FMT_INLINE value(ubitint x FMT_BUILTIN) : ulong_long_value(x) {\n static_assert(N <= 64, \"unsupported _BitInt\");\n }\n\n template ::value)>\n constexpr FMT_INLINE value(T x FMT_BUILTIN) : char_value(x) {\n static_assert(\n std::is_same::value || std::is_same::value,\n \"mixing character types is disallowed\");\n }\n\n constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {}\n constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {}\n FMT_INLINE value(long double x FMT_BUILTIN) : long_double_value(x) {}\n\n FMT_CONSTEXPR FMT_INLINE value(char_type* x FMT_BUILTIN) {\n string.data = x;\n if (is_constant_evaluated()) string.size = 0;\n }\n FMT_CONSTEXPR FMT_INLINE value(const char_type* x FMT_BUILTIN) {\n string.data = x;\n if (is_constant_evaluated()) string.size = 0;\n }\n template ,\n FMT_ENABLE_IF(!std::is_pointer::value)>\n FMT_CONSTEXPR value(const T& x FMT_BUILTIN) {\n static_assert(std::is_same::value,\n \"mixing character types is disallowed\");\n auto sv = to_string_view(x);\n string.data = sv.data();\n string.size = sv.size();\n }\n FMT_INLINE value(void* x FMT_BUILTIN) : pointer(x) {}\n FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {}\n FMT_INLINE value(volatile void* x FMT_BUILTIN)\n : pointer(const_cast(x)) {}\n FMT_INLINE value(const volatile void* x FMT_BUILTIN)\n : pointer(const_cast(x)) {}\n FMT_INLINE value(nullptr_t) : pointer(nullptr) {}\n\n template ::value ||\n std::is_member_pointer::value)>\n value(const T&) {\n // Formatting of arbitrary pointers is disallowed. If you want to format a\n // pointer cast it to `void*` or `const void*`. In particular, this forbids\n // formatting of `[const] volatile char*` printed as bool by iostreams.\n static_assert(sizeof(T) == 0,\n \"formatting of non-void pointers is disallowed\");\n }\n\n template ::value)>\n value(const T& x) : value(format_as(x)) {}\n template ::value)>\n value(const T& x) : value(formatter::format_as(x)) {}\n\n template ::value)>\n value(const T& named_arg) : value(named_arg.value) {}\n\n template ::value || !FMT_BUILTIN_TYPES)>\n FMT_CONSTEXPR20 FMT_INLINE value(T& x) : value(x, custom_tag()) {}\n\n FMT_ALWAYS_INLINE value(const named_arg_info* args, size_t size)\n : named_args{args, size} {}\n\n private:\n template ())>\n FMT_CONSTEXPR value(T& x, custom_tag) {\n using value_type = remove_const_t;\n // T may overload operator& e.g. std::vector::reference in libc++.\n if (!is_constant_evaluated()) {\n custom.value =\n const_cast(&reinterpret_cast(x));\n } else {\n custom.value = nullptr;\n#if defined(__cpp_if_constexpr)\n if constexpr (std::is_same*>::value)\n custom.value = const_cast(&x);\n#endif\n }\n custom.format = format_custom;\n }\n\n template ())>\n FMT_CONSTEXPR value(const T&, custom_tag) {\n // Cannot format an argument; to make type T formattable provide a\n // formatter specialization: https://fmt.dev/latest/api.html#udt.\n type_is_unformattable_for _;\n }\n\n // Formats an argument of a custom type, such as a user-defined class.\n template \n static void format_custom(void* arg, parse_context& parse_ctx,\n Context& ctx) {\n auto f = formatter();\n parse_ctx.advance_to(f.parse(parse_ctx));\n using qualified_type =\n conditional_t(), const T, T>;\n // format must be const for compatibility with std::format and compilation.\n const auto& cf = f;\n ctx.advance_to(cf.format(*static_cast(arg), ctx));\n }\n};\n\nenum { packed_arg_bits = 4 };\n// Maximum number of arguments with packed types.\nenum { max_packed_args = 62 / packed_arg_bits };\nenum : unsigned long long { is_unpacked_bit = 1ULL << 63 };\nenum : unsigned long long { has_named_args_bit = 1ULL << 62 };\n\ntemplate \nstruct is_output_iterator : std::false_type {};\n\ntemplate <> struct is_output_iterator : std::true_type {};\n\ntemplate \nstruct is_output_iterator<\n It, T,\n enable_if_t&>()++),\n T>::value>> : std::true_type {};\n\ntemplate constexpr auto encode_types() -> unsigned long long {\n return 0;\n}\n\ntemplate \nconstexpr auto encode_types() -> unsigned long long {\n return static_cast(stored_type_constant::value) |\n (encode_types() << packed_arg_bits);\n}\n\ntemplate \nconstexpr auto make_descriptor() -> unsigned long long {\n return NUM_ARGS <= max_packed_args ? encode_types()\n : is_unpacked_bit | NUM_ARGS;\n}\n\ntemplate \nusing arg_t = conditional_t,\n basic_format_arg>;\n\ntemplate \nstruct named_arg_store {\n // args_[0].named_args points to named_args to avoid bloating format_args.\n arg_t args[1u + NUM_ARGS];\n named_arg_info\n named_args[static_cast(NUM_NAMED_ARGS)];\n\n template \n FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T&... values)\n : args{{named_args, NUM_NAMED_ARGS}, values...} {\n int arg_index = 0, named_arg_index = 0;\n FMT_APPLY_VARIADIC(\n init_named_arg(named_args, arg_index, named_arg_index, values));\n }\n\n named_arg_store(named_arg_store&& rhs) {\n args[0] = {named_args, NUM_NAMED_ARGS};\n for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i)\n args[i] = rhs.args[i];\n for (size_t i = 0; i < NUM_NAMED_ARGS; ++i)\n named_args[i] = rhs.named_args[i];\n }\n\n named_arg_store(const named_arg_store& rhs) = delete;\n auto operator=(const named_arg_store& rhs) -> named_arg_store& = delete;\n auto operator=(named_arg_store&& rhs) -> named_arg_store& = delete;\n operator const arg_t*() const { return args + 1; }\n};\n\n// An array of references to arguments. It can be implicitly converted to\n// `basic_format_args` for passing into type-erased formatting functions\n// such as `vformat`. It is a plain struct to reduce binary size in debug mode.\ntemplate \nstruct format_arg_store {\n // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.\n using type =\n conditional_t[max_of(1, NUM_ARGS)],\n named_arg_store>;\n type args;\n};\n\n// TYPE can be different from type_constant, e.g. for __float128.\ntemplate struct native_formatter {\n private:\n dynamic_format_specs specs_;\n\n public:\n using nonlocking = void;\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();\n auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE);\n if (const_check(TYPE == type::char_type)) check_char_specs(specs_);\n return end;\n }\n\n template \n FMT_CONSTEXPR void set_debug_format(bool set = true) {\n specs_.set_type(set ? presentation_type::debug : presentation_type::none);\n }\n\n FMT_PRAGMA_CLANG(diagnostic ignored \"-Wundefined-inline\")\n template \n FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const\n -> decltype(ctx.out());\n};\n\ntemplate \nstruct locking\n : bool_constant::value == type::custom_type> {};\ntemplate \nstruct locking>::nonlocking>>\n : std::false_type {};\n\ntemplate FMT_CONSTEXPR inline auto is_locking() -> bool {\n return locking::value;\n}\ntemplate \nFMT_CONSTEXPR inline auto is_locking() -> bool {\n return locking::value || is_locking();\n}\n\nFMT_API void vformat_to(buffer& buf, string_view fmt, format_args args,\n locale_ref loc = {});\n\n#if FMT_WIN32\nFMT_API void vprint_mojibake(FILE*, string_view, format_args, bool);\n#else // format_args is passed by reference since it is defined later.\ninline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {}\n#endif\n} // namespace detail\n\n// The main public API.\n\ntemplate \nFMT_CONSTEXPR void parse_context::do_check_arg_id(int arg_id) {\n // Argument id is only checked at compile time during parsing because\n // formatting has its own validation.\n if (detail::is_constant_evaluated() && use_constexpr_cast) {\n auto ctx = static_cast*>(this);\n if (arg_id >= ctx->num_args()) report_error(\"argument not found\");\n }\n}\n\ntemplate \nFMT_CONSTEXPR void parse_context::check_dynamic_spec(int arg_id) {\n using detail::compile_parse_context;\n if (detail::is_constant_evaluated() && use_constexpr_cast)\n static_cast*>(this)->check_dynamic_spec(arg_id);\n}\n\nFMT_BEGIN_EXPORT\n\n// An output iterator that appends to a buffer. It is used instead of\n// back_insert_iterator to reduce symbol sizes and avoid dependency.\ntemplate class basic_appender {\n protected:\n detail::buffer* container;\n\n public:\n using container_type = detail::buffer;\n\n FMT_CONSTEXPR basic_appender(detail::buffer& buf) : container(&buf) {}\n\n FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& {\n container->push_back(c);\n return *this;\n }\n FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; }\n FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; }\n FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; }\n};\n\n// A formatting argument. Context is a template parameter for the compiled API\n// where output can be unbuffered.\ntemplate class basic_format_arg {\n private:\n detail::value value_;\n detail::type type_;\n\n friend class basic_format_args;\n\n using char_type = typename Context::char_type;\n\n public:\n class handle {\n private:\n detail::custom_value custom_;\n\n public:\n explicit handle(detail::custom_value custom) : custom_(custom) {}\n\n void format(parse_context& parse_ctx, Context& ctx) const {\n custom_.format(custom_.value, parse_ctx, ctx);\n }\n };\n\n constexpr basic_format_arg() : type_(detail::type::none_type) {}\n basic_format_arg(const detail::named_arg_info* args, size_t size)\n : value_(args, size) {}\n template \n basic_format_arg(T&& val)\n : value_(val), type_(detail::stored_type_constant::value) {}\n\n constexpr explicit operator bool() const noexcept {\n return type_ != detail::type::none_type;\n }\n auto type() const -> detail::type { return type_; }\n\n /**\n * Visits an argument dispatching to the appropriate visit method based on\n * the argument type. For example, if the argument type is `double` then\n * `vis(value)` will be called with the value of type `double`.\n */\n template \n FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {\n using detail::map;\n switch (type_) {\n case detail::type::none_type: break;\n case detail::type::int_type: return vis(value_.int_value);\n case detail::type::uint_type: return vis(value_.uint_value);\n case detail::type::long_long_type: return vis(value_.long_long_value);\n case detail::type::ulong_long_type: return vis(value_.ulong_long_value);\n case detail::type::int128_type: return vis(map(value_.int128_value));\n case detail::type::uint128_type: return vis(map(value_.uint128_value));\n case detail::type::bool_type: return vis(value_.bool_value);\n case detail::type::char_type: return vis(value_.char_value);\n case detail::type::float_type: return vis(value_.float_value);\n case detail::type::double_type: return vis(value_.double_value);\n case detail::type::long_double_type: return vis(value_.long_double_value);\n case detail::type::cstring_type: return vis(value_.string.data);\n case detail::type::string_type: return vis(value_.string.str());\n case detail::type::pointer_type: return vis(value_.pointer);\n case detail::type::custom_type: return vis(handle(value_.custom));\n }\n return vis(monostate());\n }\n\n auto format_custom(const char_type* parse_begin,\n parse_context& parse_ctx, Context& ctx)\n -> bool {\n if (type_ != detail::type::custom_type) return false;\n parse_ctx.advance_to(parse_begin);\n value_.custom.format(value_.custom.value, parse_ctx, ctx);\n return true;\n }\n};\n\n/**\n * A view of a collection of formatting arguments. To avoid lifetime issues it\n * should only be used as a parameter type in type-erased functions such as\n * `vformat`:\n *\n * void vlog(fmt::string_view fmt, fmt::format_args args); // OK\n * fmt::format_args args = fmt::make_format_args(); // Dangling reference\n */\ntemplate class basic_format_args {\n private:\n // A descriptor that contains information about formatting arguments.\n // If the number of arguments is less or equal to max_packed_args then\n // argument types are passed in the descriptor. This reduces binary code size\n // per formatting function call.\n unsigned long long desc_;\n union {\n // If is_packed() returns true then argument values are stored in values_;\n // otherwise they are stored in args_. This is done to improve cache\n // locality and reduce compiled code size since storing larger objects\n // may require more code (at least on x86-64) even if the same amount of\n // data is actually copied to stack. It saves ~10% on the bloat test.\n const detail::value* values_;\n const basic_format_arg* args_;\n };\n\n constexpr auto is_packed() const -> bool {\n return (desc_ & detail::is_unpacked_bit) == 0;\n }\n constexpr auto has_named_args() const -> bool {\n return (desc_ & detail::has_named_args_bit) != 0;\n }\n\n FMT_CONSTEXPR auto type(int index) const -> detail::type {\n int shift = index * detail::packed_arg_bits;\n unsigned mask = (1 << detail::packed_arg_bits) - 1;\n return static_cast((desc_ >> shift) & mask);\n }\n\n template \n using store =\n detail::format_arg_store;\n\n public:\n using format_arg = basic_format_arg;\n\n constexpr basic_format_args() : desc_(0), args_(nullptr) {}\n\n /// Constructs a `basic_format_args` object from `format_arg_store`.\n template \n constexpr FMT_ALWAYS_INLINE basic_format_args(\n const store& s)\n : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),\n values_(s.args) {}\n\n template detail::max_packed_args)>\n constexpr basic_format_args(const store& s)\n : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),\n args_(s.args) {}\n\n /// Constructs a `basic_format_args` object from a dynamic list of arguments.\n constexpr basic_format_args(const format_arg* args, int count,\n bool has_named = false)\n : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) |\n (has_named ? +detail::has_named_args_bit : 0)),\n args_(args) {}\n\n /// Returns the argument with the specified id.\n FMT_CONSTEXPR auto get(int id) const -> format_arg {\n auto arg = format_arg();\n if (!is_packed()) {\n if (id < max_size()) arg = args_[id];\n return arg;\n }\n if (static_cast(id) >= detail::max_packed_args) return arg;\n arg.type_ = type(id);\n if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];\n return arg;\n }\n\n template \n auto get(basic_string_view name) const -> format_arg {\n int id = get_id(name);\n return id >= 0 ? get(id) : format_arg();\n }\n\n template \n FMT_CONSTEXPR auto get_id(basic_string_view name) const -> int {\n if (!has_named_args()) return -1;\n const auto& named_args =\n (is_packed() ? values_[-1] : args_[-1].value_).named_args;\n for (size_t i = 0; i < named_args.size; ++i) {\n if (named_args.data[i].name == name) return named_args.data[i].id;\n }\n return -1;\n }\n\n auto max_size() const -> int {\n unsigned long long max_packed = detail::max_packed_args;\n return static_cast(is_packed() ? max_packed\n : desc_ & ~detail::is_unpacked_bit);\n }\n};\n\n// A formatting context.\nclass context {\n private:\n appender out_;\n format_args args_;\n FMT_NO_UNIQUE_ADDRESS locale_ref loc_;\n\n public:\n using char_type = char; ///< The character type for the output.\n using iterator = appender;\n using format_arg = basic_format_arg;\n enum { builtin_types = FMT_BUILTIN_TYPES };\n\n /// Constructs a `context` object. References to the arguments are stored\n /// in the object so make sure they have appropriate lifetimes.\n FMT_CONSTEXPR context(iterator out, format_args args, locale_ref loc = {})\n : out_(out), args_(args), loc_(loc) {}\n context(context&&) = default;\n context(const context&) = delete;\n void operator=(const context&) = delete;\n\n FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }\n inline auto arg(string_view name) const -> format_arg {\n return args_.get(name);\n }\n FMT_CONSTEXPR auto arg_id(string_view name) const -> int {\n return args_.get_id(name);\n }\n auto args() const -> const format_args& { return args_; }\n\n // Returns an iterator to the beginning of the output range.\n FMT_CONSTEXPR auto out() const -> iterator { return out_; }\n\n // Advances the begin iterator to `it`.\n FMT_CONSTEXPR void advance_to(iterator) {}\n\n FMT_CONSTEXPR auto locale() const -> locale_ref { return loc_; }\n};\n\ntemplate struct runtime_format_string {\n basic_string_view str;\n};\n\n/**\n * Creates a runtime format string.\n *\n * **Example**:\n *\n * // Check format string at runtime instead of compile-time.\n * fmt::print(fmt::runtime(\"{:d}\"), \"I am not a number\");\n */\ninline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }\n\n/// A compile-time format string. Use `format_string` in the public API to\n/// prevent type deduction.\ntemplate struct fstring {\n private:\n static constexpr int num_static_named_args =\n detail::count_static_named_args();\n\n using checker = detail::format_string_checker<\n char, static_cast(sizeof...(T)), num_static_named_args,\n num_static_named_args != detail::count_named_args()>;\n\n using arg_pack = detail::arg_pack;\n\n public:\n string_view str;\n using t = fstring;\n\n // Reports a compile-time error if S is not a valid format string for T.\n template \n FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) {\n using namespace detail;\n static_assert(count<(is_view>::value &&\n std::is_reference::value)...>() == 0,\n \"passing views as lvalues is disallowed\");\n if (FMT_USE_CONSTEVAL) parse_format_string(s, checker(s, arg_pack()));\n#ifdef FMT_ENFORCE_COMPILE_STRING\n static_assert(\n FMT_USE_CONSTEVAL && sizeof(s) != 0,\n \"FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING\");\n#endif\n }\n template ::value)>\n FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) {\n auto sv = string_view(str);\n if (FMT_USE_CONSTEVAL)\n detail::parse_format_string(sv, checker(sv, arg_pack()));\n#ifdef FMT_ENFORCE_COMPILE_STRING\n static_assert(\n FMT_USE_CONSTEVAL && sizeof(s) != 0,\n \"FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING\");\n#endif\n }\n template ::value&&\n std::is_same::value)>\n FMT_ALWAYS_INLINE fstring(const S&) : str(S()) {\n FMT_CONSTEXPR auto sv = string_view(S());\n FMT_CONSTEXPR int unused =\n (parse_format_string(sv, checker(sv, arg_pack())), 0);\n detail::ignore_unused(unused);\n }\n fstring(runtime_format_string<> fmt) : str(fmt.str) {}\n\n // Returning by reference generates better code in debug mode.\n FMT_ALWAYS_INLINE operator const string_view&() const { return str; }\n auto get() const -> string_view { return str; }\n};\n\ntemplate using format_string = typename fstring::t;\n\ntemplate \nusing is_formattable = bool_constant::value, int*, T>, Char>,\n void>::value>;\n#ifdef __cpp_concepts\ntemplate \nconcept formattable = is_formattable, Char>::value;\n#endif\n\n// A formatter specialization for natively supported types.\ntemplate \nstruct formatter::value !=\n detail::type::custom_type>>\n : detail::native_formatter::value> {\n};\n\n/**\n * Constructs an object that stores references to arguments and can be\n * implicitly converted to `format_args`. `Context` can be omitted in which case\n * it defaults to `context`. See `arg` for lifetime considerations.\n */\n// Take arguments by lvalue references to avoid some lifetime issues, e.g.\n// auto args = make_format_args(std::string());\ntemplate (),\n unsigned long long DESC = detail::make_descriptor()>\nconstexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args)\n -> detail::format_arg_store {\n // Suppress warnings for pathological types convertible to detail::value.\n FMT_PRAGMA_GCC(diagnostic ignored \"-Wconversion\")\n return {{args...}};\n}\n\ntemplate \nusing vargs =\n detail::format_arg_store(),\n detail::make_descriptor()>;\n\n/**\n * Returns a named argument to be used in a formatting function.\n * It should only be used in a call to a formatting function.\n *\n * **Example**:\n *\n * fmt::print(\"The answer is {answer}.\", fmt::arg(\"answer\", 42));\n */\ntemplate \ninline auto arg(const Char* name, const T& arg) -> detail::named_arg {\n return {name, arg};\n}\n\n/// Formats a string and writes the output to `out`.\ntemplate ,\n char>::value)>\nauto vformat_to(OutputIt&& out, string_view fmt, format_args args)\n -> remove_cvref_t {\n auto&& buf = detail::get_buffer(out);\n detail::vformat_to(buf, fmt, args, {});\n return detail::get_iterator(buf, out);\n}\n\n/**\n * Formats `args` according to specifications in `fmt`, writes the result to\n * the output iterator `out` and returns the iterator past the end of the output\n * range. `format_to` does not append a terminating null character.\n *\n * **Example**:\n *\n * auto out = std::vector();\n * fmt::format_to(std::back_inserter(out), \"{}\", 42);\n */\ntemplate ,\n char>::value)>\nFMT_INLINE auto format_to(OutputIt&& out, format_string fmt, T&&... args)\n -> remove_cvref_t {\n return vformat_to(out, fmt.str, vargs{{args...}});\n}\n\ntemplate struct format_to_n_result {\n /// Iterator past the end of the output range.\n OutputIt out;\n /// Total (not truncated) output size.\n size_t size;\n};\n\ntemplate ::value)>\nauto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)\n -> format_to_n_result {\n using traits = detail::fixed_buffer_traits;\n auto buf = detail::iterator_buffer(out, n);\n detail::vformat_to(buf, fmt, args, {});\n return {buf.out(), buf.count()};\n}\n\n/**\n * Formats `args` according to specifications in `fmt`, writes up to `n`\n * characters of the result to the output iterator `out` and returns the total\n * (not truncated) output size and the iterator past the end of the output\n * range. `format_to_n` does not append a terminating null character.\n */\ntemplate ::value)>\nFMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt,\n T&&... args) -> format_to_n_result {\n return vformat_to_n(out, n, fmt.str, vargs{{args...}});\n}\n\nstruct format_to_result {\n /// Pointer to just after the last successful write in the array.\n char* out;\n /// Specifies if the output was truncated.\n bool truncated;\n\n FMT_CONSTEXPR operator char*() const {\n // Report truncation to prevent silent data loss.\n if (truncated) report_error(\"output is truncated\");\n return out;\n }\n};\n\ntemplate \nauto vformat_to(char (&out)[N], string_view fmt, format_args args)\n -> format_to_result {\n auto result = vformat_to_n(out, N, fmt, args);\n return {result.out, result.size > N};\n}\n\ntemplate \nFMT_INLINE auto format_to(char (&out)[N], format_string fmt, T&&... args)\n -> format_to_result {\n auto result = vformat_to_n(out, N, fmt.str, vargs{{args...}});\n return {result.out, result.size > N};\n}\n\n/// Returns the number of chars in the output of `format(fmt, args...)`.\ntemplate \nFMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt,\n T&&... args) -> size_t {\n auto buf = detail::counting_buffer<>();\n detail::vformat_to(buf, fmt.str, vargs{{args...}}, {});\n return buf.count();\n}\n\nFMT_API void vprint(string_view fmt, format_args args);\nFMT_API void vprint(FILE* f, string_view fmt, format_args args);\nFMT_API void vprintln(FILE* f, string_view fmt, format_args args);\nFMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args);\n\n/**\n * Formats `args` according to specifications in `fmt` and writes the output\n * to `stdout`.\n *\n * **Example**:\n *\n * fmt::print(\"The answer is {}.\", 42);\n */\ntemplate \nFMT_INLINE void print(format_string fmt, T&&... args) {\n vargs va = {{args...}};\n if (detail::const_check(!detail::use_utf8))\n return detail::vprint_mojibake(stdout, fmt.str, va, false);\n return detail::is_locking() ? vprint_buffered(stdout, fmt.str, va)\n : vprint(fmt.str, va);\n}\n\n/**\n * Formats `args` according to specifications in `fmt` and writes the\n * output to the file `f`.\n *\n * **Example**:\n *\n * fmt::print(stderr, \"Don't {}!\", \"panic\");\n */\ntemplate \nFMT_INLINE void print(FILE* f, format_string fmt, T&&... args) {\n vargs va = {{args...}};\n if (detail::const_check(!detail::use_utf8))\n return detail::vprint_mojibake(f, fmt.str, va, false);\n return detail::is_locking() ? vprint_buffered(f, fmt.str, va)\n : vprint(f, fmt.str, va);\n}\n\n/// Formats `args` according to specifications in `fmt` and writes the output\n/// to the file `f` followed by a newline.\ntemplate \nFMT_INLINE void println(FILE* f, format_string fmt, T&&... args) {\n vargs va = {{args...}};\n return detail::const_check(detail::use_utf8)\n ? vprintln(f, fmt.str, va)\n : detail::vprint_mojibake(f, fmt.str, va, true);\n}\n\n/// Formats `args` according to specifications in `fmt` and writes the output\n/// to `stdout` followed by a newline.\ntemplate \nFMT_INLINE void println(format_string fmt, T&&... args) {\n return fmt::println(stdout, fmt, static_cast(args)...);\n}\n\nFMT_PRAGMA_GCC(diagnostic pop)\nFMT_PRAGMA_CLANG(diagnostic pop)\nFMT_PRAGMA_GCC(pop_options)\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#ifdef FMT_HEADER_ONLY\n# include \"format.h\"\n#endif\n#endif // FMT_BASE_H_\n" }, { "path": "include/spdlog/fmt/bundled/chrono.h", "content": "// Formatting library for C++ - chrono support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_CHRONO_H_\n#define FMT_CHRONO_H_\n\n#ifndef FMT_MODULE\n# include \n# include \n# include // std::isfinite\n# include // std::memcpy\n# include \n# include \n# include \n# include \n# include \n#endif\n\n#include \"format.h\"\n\nFMT_BEGIN_NAMESPACE\n\n// Enable safe chrono durations, unless explicitly disabled.\n#ifndef FMT_SAFE_DURATION_CAST\n# define FMT_SAFE_DURATION_CAST 1\n#endif\n#if FMT_SAFE_DURATION_CAST\n\n// For conversion between std::chrono::durations without undefined\n// behaviour or erroneous results.\n// This is a stripped down version of duration_cast, for inclusion in fmt.\n// See https://github.com/pauldreik/safe_duration_cast\n//\n// Copyright Paul Dreik 2019\nnamespace safe_duration_cast {\n\n// DEPRECATED!\ntemplate ::value &&\n std::numeric_limits::is_signed ==\n std::numeric_limits::is_signed)>\nFMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)\n -> To {\n ec = 0;\n using F = std::numeric_limits;\n using T = std::numeric_limits;\n static_assert(F::is_integer, \"From must be integral\");\n static_assert(T::is_integer, \"To must be integral\");\n\n // A and B are both signed, or both unsigned.\n if (detail::const_check(F::digits <= T::digits)) {\n // From fits in To without any problem.\n } else {\n // From does not always fit in To, resort to a dynamic check.\n if (from < (T::min)() || from > (T::max)()) {\n // outside range.\n ec = 1;\n return {};\n }\n }\n return static_cast(from);\n}\n\n/// Converts From to To, without loss. If the dynamic value of from\n/// can't be converted to To without loss, ec is set.\ntemplate ::value &&\n std::numeric_limits::is_signed !=\n std::numeric_limits::is_signed)>\nFMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)\n -> To {\n ec = 0;\n using F = std::numeric_limits;\n using T = std::numeric_limits;\n static_assert(F::is_integer, \"From must be integral\");\n static_assert(T::is_integer, \"To must be integral\");\n\n if (detail::const_check(F::is_signed && !T::is_signed)) {\n // From may be negative, not allowed!\n if (fmt::detail::is_negative(from)) {\n ec = 1;\n return {};\n }\n // From is positive. Can it always fit in To?\n if (detail::const_check(F::digits > T::digits) &&\n from > static_cast(detail::max_value())) {\n ec = 1;\n return {};\n }\n }\n\n if (detail::const_check(!F::is_signed && T::is_signed &&\n F::digits >= T::digits) &&\n from > static_cast(detail::max_value())) {\n ec = 1;\n return {};\n }\n return static_cast(from); // Lossless conversion.\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)\n -> To {\n ec = 0;\n return from;\n} // function\n\n// clang-format off\n/**\n * converts From to To if possible, otherwise ec is set.\n *\n * input | output\n * ---------------------------------|---------------\n * NaN | NaN\n * Inf | Inf\n * normal, fits in output | converted (possibly lossy)\n * normal, does not fit in output | ec is set\n * subnormal | best effort\n * -Inf | -Inf\n */\n// clang-format on\ntemplate ::value)>\nFMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {\n ec = 0;\n using T = std::numeric_limits;\n static_assert(std::is_floating_point::value, \"From must be floating\");\n static_assert(std::is_floating_point::value, \"To must be floating\");\n\n // catch the only happy case\n if (std::isfinite(from)) {\n if (from >= T::lowest() && from <= (T::max)()) {\n return static_cast(from);\n }\n // not within range.\n ec = 1;\n return {};\n }\n\n // nan and inf will be preserved\n return static_cast(from);\n} // function\n\ntemplate ::value)>\nFMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {\n ec = 0;\n static_assert(std::is_floating_point::value, \"From must be floating\");\n return from;\n}\n\n/// Safe duration_cast between floating point durations\ntemplate ::value),\n FMT_ENABLE_IF(std::is_floating_point::value)>\nauto safe_duration_cast(std::chrono::duration from,\n int& ec) -> To {\n using From = std::chrono::duration;\n ec = 0;\n\n // the basic idea is that we need to convert from count() in the from type\n // to count() in the To type, by multiplying it with this:\n struct Factor\n : std::ratio_divide {};\n\n static_assert(Factor::num > 0, \"num must be positive\");\n static_assert(Factor::den > 0, \"den must be positive\");\n\n // the conversion is like this: multiply from.count() with Factor::num\n // /Factor::den and convert it to To::rep, all this without\n // overflow/underflow. let's start by finding a suitable type that can hold\n // both To, From and Factor::num\n using IntermediateRep =\n typename std::common_type::type;\n\n // force conversion of From::rep -> IntermediateRep to be safe,\n // even if it will never happen be narrowing in this context.\n IntermediateRep count =\n safe_float_conversion(from.count(), ec);\n if (ec) {\n return {};\n }\n\n // multiply with Factor::num without overflow or underflow\n if (detail::const_check(Factor::num != 1)) {\n constexpr auto max1 = detail::max_value() /\n static_cast(Factor::num);\n if (count > max1) {\n ec = 1;\n return {};\n }\n constexpr auto min1 = std::numeric_limits::lowest() /\n static_cast(Factor::num);\n if (count < min1) {\n ec = 1;\n return {};\n }\n count *= static_cast(Factor::num);\n }\n\n // this can't go wrong, right? den>0 is checked earlier.\n if (detail::const_check(Factor::den != 1)) {\n using common_t = typename std::common_type::type;\n count /= static_cast(Factor::den);\n }\n\n // convert to the to type, safely\n using ToRep = typename To::rep;\n\n const ToRep tocount = safe_float_conversion(count, ec);\n if (ec) {\n return {};\n }\n return To{tocount};\n}\n} // namespace safe_duration_cast\n#endif\n\nnamespace detail {\n\n// Check if std::chrono::utc_time is available.\n#ifdef FMT_USE_UTC_TIME\n// Use the provided definition.\n#elif defined(__cpp_lib_chrono)\n# define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L)\n#else\n# define FMT_USE_UTC_TIME 0\n#endif\n#if FMT_USE_UTC_TIME\nusing utc_clock = std::chrono::utc_clock;\n#else\nstruct utc_clock {\n template void to_sys(T);\n};\n#endif\n\n// Check if std::chrono::local_time is available.\n#ifdef FMT_USE_LOCAL_TIME\n// Use the provided definition.\n#elif defined(__cpp_lib_chrono)\n# define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L)\n#else\n# define FMT_USE_LOCAL_TIME 0\n#endif\n#if FMT_USE_LOCAL_TIME\nusing local_t = std::chrono::local_t;\n#else\nstruct local_t {};\n#endif\n\n} // namespace detail\n\ntemplate \nusing sys_time = std::chrono::time_point;\n\ntemplate \nusing utc_time = std::chrono::time_point;\n\ntemplate \nusing local_time = std::chrono::time_point;\n\nnamespace detail {\n\n// Prevents expansion of a preceding token as a function-style macro.\n// Usage: f FMT_NOMACRO()\n#define FMT_NOMACRO\n\ntemplate struct null {};\ninline auto gmtime_r(...) -> null<> { return null<>(); }\ninline auto gmtime_s(...) -> null<> { return null<>(); }\n\n// It is defined here and not in ostream.h because the latter has expensive\n// includes.\ntemplate class formatbuf : public StreamBuf {\n private:\n using char_type = typename StreamBuf::char_type;\n using streamsize = decltype(std::declval().sputn(nullptr, 0));\n using int_type = typename StreamBuf::int_type;\n using traits_type = typename StreamBuf::traits_type;\n\n buffer& buffer_;\n\n public:\n explicit formatbuf(buffer& buf) : buffer_(buf) {}\n\n protected:\n // The put area is always empty. This makes the implementation simpler and has\n // the advantage that the streambuf and the buffer are always in sync and\n // sputc never writes into uninitialized memory. A disadvantage is that each\n // call to sputc always results in a (virtual) call to overflow. There is no\n // disadvantage here for sputn since this always results in a call to xsputn.\n\n auto overflow(int_type ch) -> int_type override {\n if (!traits_type::eq_int_type(ch, traits_type::eof()))\n buffer_.push_back(static_cast(ch));\n return ch;\n }\n\n auto xsputn(const char_type* s, streamsize count) -> streamsize override {\n buffer_.append(s, s + count);\n return count;\n }\n};\n\ninline auto get_classic_locale() -> const std::locale& {\n static const auto& locale = std::locale::classic();\n return locale;\n}\n\ntemplate struct codecvt_result {\n static constexpr size_t max_size = 32;\n CodeUnit buf[max_size];\n CodeUnit* end;\n};\n\ntemplate \nvoid write_codecvt(codecvt_result& out, string_view in,\n const std::locale& loc) {\n FMT_PRAGMA_CLANG(diagnostic push)\n FMT_PRAGMA_CLANG(diagnostic ignored \"-Wdeprecated\")\n auto& f = std::use_facet>(loc);\n FMT_PRAGMA_CLANG(diagnostic pop)\n auto mb = std::mbstate_t();\n const char* from_next = nullptr;\n auto result = f.in(mb, in.begin(), in.end(), from_next, std::begin(out.buf),\n std::end(out.buf), out.end);\n if (result != std::codecvt_base::ok)\n FMT_THROW(format_error(\"failed to format time\"));\n}\n\ntemplate \nauto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)\n -> OutputIt {\n if (const_check(detail::use_utf8) && loc != get_classic_locale()) {\n // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and\n // gcc-4.\n#if FMT_MSC_VERSION != 0 || \\\n (defined(__GLIBCXX__) && \\\n (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0))\n // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5\n // and newer.\n using code_unit = wchar_t;\n#else\n using code_unit = char32_t;\n#endif\n\n using unit_t = codecvt_result;\n unit_t unit;\n write_codecvt(unit, in, loc);\n // In UTF-8 is used one to four one-byte code units.\n auto u =\n to_utf8>();\n if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))\n FMT_THROW(format_error(\"failed to format time\"));\n return copy(u.c_str(), u.c_str() + u.size(), out);\n }\n return copy(in.data(), in.data() + in.size(), out);\n}\n\ntemplate ::value)>\nauto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)\n -> OutputIt {\n codecvt_result unit;\n write_codecvt(unit, sv, loc);\n return copy(unit.buf, unit.end, out);\n}\n\ntemplate ::value)>\nauto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)\n -> OutputIt {\n return write_encoded_tm_str(out, sv, loc);\n}\n\ntemplate \ninline void do_write(buffer& buf, const std::tm& time,\n const std::locale& loc, char format, char modifier) {\n auto&& format_buf = formatbuf>(buf);\n auto&& os = std::basic_ostream(&format_buf);\n os.imbue(loc);\n const auto& facet = std::use_facet>(loc);\n auto end = facet.put(os, os, Char(' '), &time, format, modifier);\n if (end.failed()) FMT_THROW(format_error(\"failed to format time\"));\n}\n\ntemplate ::value)>\nauto write(OutputIt out, const std::tm& time, const std::locale& loc,\n char format, char modifier = 0) -> OutputIt {\n auto&& buf = get_buffer(out);\n do_write(buf, time, loc, format, modifier);\n return get_iterator(buf, out);\n}\n\ntemplate ::value)>\nauto write(OutputIt out, const std::tm& time, const std::locale& loc,\n char format, char modifier = 0) -> OutputIt {\n auto&& buf = basic_memory_buffer();\n do_write(buf, time, loc, format, modifier);\n return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);\n}\n\ntemplate \nusing is_similar_arithmetic_type =\n bool_constant<(std::is_integral::value && std::is_integral::value) ||\n (std::is_floating_point::value &&\n std::is_floating_point::value)>;\n\nFMT_NORETURN inline void throw_duration_error() {\n FMT_THROW(format_error(\"cannot format duration\"));\n}\n\n// Cast one integral duration to another with an overflow check.\ntemplate ::value&&\n std::is_integral::value)>\nauto duration_cast(std::chrono::duration from) -> To {\n#if !FMT_SAFE_DURATION_CAST\n return std::chrono::duration_cast(from);\n#else\n // The conversion factor: to.count() == factor * from.count().\n using factor = std::ratio_divide;\n\n using common_rep = typename std::common_type::type;\n common_rep count = from.count(); // This conversion is lossless.\n\n // Multiply from.count() by factor and check for overflow.\n if (const_check(factor::num != 1)) {\n if (count > max_value() / factor::num) throw_duration_error();\n const auto min = (std::numeric_limits::min)() / factor::num;\n if (const_check(!std::is_unsigned::value) && count < min)\n throw_duration_error();\n count *= factor::num;\n }\n if (const_check(factor::den != 1)) count /= factor::den;\n int ec = 0;\n auto to =\n To(safe_duration_cast::lossless_integral_conversion(\n count, ec));\n if (ec) throw_duration_error();\n return to;\n#endif\n}\n\ntemplate ::value&&\n std::is_floating_point::value)>\nauto duration_cast(std::chrono::duration from) -> To {\n#if FMT_SAFE_DURATION_CAST\n // Preserve infinity and NaN.\n if (!isfinite(from.count())) return static_cast(from.count());\n // Throwing version of safe_duration_cast is only available for\n // integer to integer or float to float casts.\n int ec;\n To to = safe_duration_cast::safe_duration_cast(from, ec);\n if (ec) throw_duration_error();\n return to;\n#else\n // Standard duration cast, may overflow.\n return std::chrono::duration_cast(from);\n#endif\n}\n\ntemplate ::value)>\nauto duration_cast(std::chrono::duration from) -> To {\n // Mixed integer <-> float cast is not supported by safe duration_cast.\n return std::chrono::duration_cast(from);\n}\n\ntemplate \nauto to_time_t(sys_time time_point) -> std::time_t {\n // Cannot use std::chrono::system_clock::to_time_t since this would first\n // require a cast to std::chrono::system_clock::time_point, which could\n // overflow.\n return detail::duration_cast>(\n time_point.time_since_epoch())\n .count();\n}\n\n} // namespace detail\n\nFMT_BEGIN_EXPORT\n\n/**\n * Converts given time since epoch as `std::time_t` value into calendar time,\n * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this\n * function is thread-safe on most platforms.\n */\ninline auto gmtime(std::time_t time) -> std::tm {\n struct dispatcher {\n std::time_t time_;\n std::tm tm_;\n\n inline dispatcher(std::time_t t) : time_(t) {}\n\n inline auto run() -> bool {\n using namespace fmt::detail;\n return handle(gmtime_r(&time_, &tm_));\n }\n\n inline auto handle(std::tm* tm) -> bool { return tm != nullptr; }\n\n inline auto handle(detail::null<>) -> bool {\n using namespace fmt::detail;\n return fallback(gmtime_s(&tm_, &time_));\n }\n\n inline auto fallback(int res) -> bool { return res == 0; }\n\n#if !FMT_MSC_VERSION\n inline auto fallback(detail::null<>) -> bool {\n std::tm* tm = std::gmtime(&time_);\n if (tm) tm_ = *tm;\n return tm != nullptr;\n }\n#endif\n };\n auto gt = dispatcher(time);\n // Too big time values may be unsupported.\n if (!gt.run()) FMT_THROW(format_error(\"time_t value out of range\"));\n return gt.tm_;\n}\n\ntemplate \ninline auto gmtime(sys_time time_point) -> std::tm {\n return gmtime(detail::to_time_t(time_point));\n}\n\nnamespace detail {\n\n// Writes two-digit numbers a, b and c separated by sep to buf.\n// The method by Pavel Novikov based on\n// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.\ninline void write_digit2_separated(char* buf, unsigned a, unsigned b,\n unsigned c, char sep) {\n unsigned long long digits =\n a | (b << 24) | (static_cast(c) << 48);\n // Convert each value to BCD.\n // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.\n // The difference is\n // y - x = a * 6\n // a can be found from x:\n // a = floor(x / 10)\n // then\n // y = x + a * 6 = x + floor(x / 10) * 6\n // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).\n digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;\n // Put low nibbles to high bytes and high nibbles to low bytes.\n digits = ((digits & 0x00f00000f00000f0) >> 4) |\n ((digits & 0x000f00000f00000f) << 8);\n auto usep = static_cast(sep);\n // Add ASCII '0' to each digit byte and insert separators.\n digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);\n\n constexpr size_t len = 8;\n if (const_check(is_big_endian())) {\n char tmp[len];\n std::memcpy(tmp, &digits, len);\n std::reverse_copy(tmp, tmp + len, buf);\n } else {\n std::memcpy(buf, &digits, len);\n }\n}\n\ntemplate \nFMT_CONSTEXPR inline auto get_units() -> const char* {\n if (std::is_same::value) return \"as\";\n if (std::is_same::value) return \"fs\";\n if (std::is_same::value) return \"ps\";\n if (std::is_same::value) return \"ns\";\n if (std::is_same::value)\n return detail::use_utf8 ? \"µs\" : \"us\";\n if (std::is_same::value) return \"ms\";\n if (std::is_same::value) return \"cs\";\n if (std::is_same::value) return \"ds\";\n if (std::is_same>::value) return \"s\";\n if (std::is_same::value) return \"das\";\n if (std::is_same::value) return \"hs\";\n if (std::is_same::value) return \"ks\";\n if (std::is_same::value) return \"Ms\";\n if (std::is_same::value) return \"Gs\";\n if (std::is_same::value) return \"Ts\";\n if (std::is_same::value) return \"Ps\";\n if (std::is_same::value) return \"Es\";\n if (std::is_same>::value) return \"min\";\n if (std::is_same>::value) return \"h\";\n if (std::is_same>::value) return \"d\";\n return nullptr;\n}\n\nenum class numeric_system {\n standard,\n // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.\n alternative\n};\n\n// Glibc extensions for formatting numeric values.\nenum class pad_type {\n // Pad a numeric result string with zeros (the default).\n zero,\n // Do not pad a numeric result string.\n none,\n // Pad a numeric result string with spaces.\n space,\n};\n\ntemplate \nauto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {\n if (pad == pad_type::none) return out;\n return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0');\n}\n\ntemplate \nauto write_padding(OutputIt out, pad_type pad) -> OutputIt {\n if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0';\n return out;\n}\n\n// Parses a put_time-like format string and invokes handler actions.\ntemplate \nFMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,\n Handler&& handler) -> const Char* {\n if (begin == end || *begin == '}') return begin;\n if (*begin != '%') FMT_THROW(format_error(\"invalid format\"));\n auto ptr = begin;\n while (ptr != end) {\n pad_type pad = pad_type::zero;\n auto c = *ptr;\n if (c == '}') break;\n if (c != '%') {\n ++ptr;\n continue;\n }\n if (begin != ptr) handler.on_text(begin, ptr);\n ++ptr; // consume '%'\n if (ptr == end) FMT_THROW(format_error(\"invalid format\"));\n c = *ptr;\n switch (c) {\n case '_':\n pad = pad_type::space;\n ++ptr;\n break;\n case '-':\n pad = pad_type::none;\n ++ptr;\n break;\n }\n if (ptr == end) FMT_THROW(format_error(\"invalid format\"));\n c = *ptr++;\n switch (c) {\n case '%': handler.on_text(ptr - 1, ptr); break;\n case 'n': {\n const Char newline[] = {'\\n'};\n handler.on_text(newline, newline + 1);\n break;\n }\n case 't': {\n const Char tab[] = {'\\t'};\n handler.on_text(tab, tab + 1);\n break;\n }\n // Year:\n case 'Y': handler.on_year(numeric_system::standard, pad); break;\n case 'y': handler.on_short_year(numeric_system::standard); break;\n case 'C': handler.on_century(numeric_system::standard); break;\n case 'G': handler.on_iso_week_based_year(); break;\n case 'g': handler.on_iso_week_based_short_year(); break;\n // Day of the week:\n case 'a': handler.on_abbr_weekday(); break;\n case 'A': handler.on_full_weekday(); break;\n case 'w': handler.on_dec0_weekday(numeric_system::standard); break;\n case 'u': handler.on_dec1_weekday(numeric_system::standard); break;\n // Month:\n case 'b':\n case 'h': handler.on_abbr_month(); break;\n case 'B': handler.on_full_month(); break;\n case 'm': handler.on_dec_month(numeric_system::standard, pad); break;\n // Day of the year/month:\n case 'U':\n handler.on_dec0_week_of_year(numeric_system::standard, pad);\n break;\n case 'W':\n handler.on_dec1_week_of_year(numeric_system::standard, pad);\n break;\n case 'V': handler.on_iso_week_of_year(numeric_system::standard, pad); break;\n case 'j': handler.on_day_of_year(pad); break;\n case 'd': handler.on_day_of_month(numeric_system::standard, pad); break;\n case 'e':\n handler.on_day_of_month(numeric_system::standard, pad_type::space);\n break;\n // Hour, minute, second:\n case 'H': handler.on_24_hour(numeric_system::standard, pad); break;\n case 'I': handler.on_12_hour(numeric_system::standard, pad); break;\n case 'M': handler.on_minute(numeric_system::standard, pad); break;\n case 'S': handler.on_second(numeric_system::standard, pad); break;\n // Other:\n case 'c': handler.on_datetime(numeric_system::standard); break;\n case 'x': handler.on_loc_date(numeric_system::standard); break;\n case 'X': handler.on_loc_time(numeric_system::standard); break;\n case 'D': handler.on_us_date(); break;\n case 'F': handler.on_iso_date(); break;\n case 'r': handler.on_12_hour_time(); break;\n case 'R': handler.on_24_hour_time(); break;\n case 'T': handler.on_iso_time(); break;\n case 'p': handler.on_am_pm(); break;\n case 'Q': handler.on_duration_value(); break;\n case 'q': handler.on_duration_unit(); break;\n case 'z': handler.on_utc_offset(numeric_system::standard); break;\n case 'Z': handler.on_tz_name(); break;\n // Alternative representation:\n case 'E': {\n if (ptr == end) FMT_THROW(format_error(\"invalid format\"));\n c = *ptr++;\n switch (c) {\n case 'Y': handler.on_year(numeric_system::alternative, pad); break;\n case 'y': handler.on_offset_year(); break;\n case 'C': handler.on_century(numeric_system::alternative); break;\n case 'c': handler.on_datetime(numeric_system::alternative); break;\n case 'x': handler.on_loc_date(numeric_system::alternative); break;\n case 'X': handler.on_loc_time(numeric_system::alternative); break;\n case 'z': handler.on_utc_offset(numeric_system::alternative); break;\n default: FMT_THROW(format_error(\"invalid format\"));\n }\n break;\n }\n case 'O':\n if (ptr == end) FMT_THROW(format_error(\"invalid format\"));\n c = *ptr++;\n switch (c) {\n case 'y': handler.on_short_year(numeric_system::alternative); break;\n case 'm': handler.on_dec_month(numeric_system::alternative, pad); break;\n case 'U':\n handler.on_dec0_week_of_year(numeric_system::alternative, pad);\n break;\n case 'W':\n handler.on_dec1_week_of_year(numeric_system::alternative, pad);\n break;\n case 'V':\n handler.on_iso_week_of_year(numeric_system::alternative, pad);\n break;\n case 'd':\n handler.on_day_of_month(numeric_system::alternative, pad);\n break;\n case 'e':\n handler.on_day_of_month(numeric_system::alternative, pad_type::space);\n break;\n case 'w': handler.on_dec0_weekday(numeric_system::alternative); break;\n case 'u': handler.on_dec1_weekday(numeric_system::alternative); break;\n case 'H': handler.on_24_hour(numeric_system::alternative, pad); break;\n case 'I': handler.on_12_hour(numeric_system::alternative, pad); break;\n case 'M': handler.on_minute(numeric_system::alternative, pad); break;\n case 'S': handler.on_second(numeric_system::alternative, pad); break;\n case 'z': handler.on_utc_offset(numeric_system::alternative); break;\n default: FMT_THROW(format_error(\"invalid format\"));\n }\n break;\n default: FMT_THROW(format_error(\"invalid format\"));\n }\n begin = ptr;\n }\n if (begin != ptr) handler.on_text(begin, ptr);\n return ptr;\n}\n\ntemplate struct null_chrono_spec_handler {\n FMT_CONSTEXPR void unsupported() {\n static_cast(this)->unsupported();\n }\n FMT_CONSTEXPR void on_year(numeric_system, pad_type) { unsupported(); }\n FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_offset_year() { unsupported(); }\n FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); }\n FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); }\n FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); }\n FMT_CONSTEXPR void on_full_weekday() { unsupported(); }\n FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_abbr_month() { unsupported(); }\n FMT_CONSTEXPR void on_full_month() { unsupported(); }\n FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) { unsupported(); }\n FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {\n unsupported();\n }\n FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {\n unsupported();\n }\n FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {\n unsupported();\n }\n FMT_CONSTEXPR void on_day_of_year(pad_type) { unsupported(); }\n FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {\n unsupported();\n }\n FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_us_date() { unsupported(); }\n FMT_CONSTEXPR void on_iso_date() { unsupported(); }\n FMT_CONSTEXPR void on_12_hour_time() { unsupported(); }\n FMT_CONSTEXPR void on_24_hour_time() { unsupported(); }\n FMT_CONSTEXPR void on_iso_time() { unsupported(); }\n FMT_CONSTEXPR void on_am_pm() { unsupported(); }\n FMT_CONSTEXPR void on_duration_value() { unsupported(); }\n FMT_CONSTEXPR void on_duration_unit() { unsupported(); }\n FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); }\n FMT_CONSTEXPR void on_tz_name() { unsupported(); }\n};\n\nclass tm_format_checker : public null_chrono_spec_handler {\n private:\n bool has_timezone_ = false;\n\n public:\n constexpr explicit tm_format_checker(bool has_timezone)\n : has_timezone_(has_timezone) {}\n\n FMT_NORETURN inline void unsupported() {\n FMT_THROW(format_error(\"no format\"));\n }\n\n template \n FMT_CONSTEXPR void on_text(const Char*, const Char*) {}\n FMT_CONSTEXPR void on_year(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_short_year(numeric_system) {}\n FMT_CONSTEXPR void on_offset_year() {}\n FMT_CONSTEXPR void on_century(numeric_system) {}\n FMT_CONSTEXPR void on_iso_week_based_year() {}\n FMT_CONSTEXPR void on_iso_week_based_short_year() {}\n FMT_CONSTEXPR void on_abbr_weekday() {}\n FMT_CONSTEXPR void on_full_weekday() {}\n FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {}\n FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {}\n FMT_CONSTEXPR void on_abbr_month() {}\n FMT_CONSTEXPR void on_full_month() {}\n FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_day_of_year(pad_type) {}\n FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_datetime(numeric_system) {}\n FMT_CONSTEXPR void on_loc_date(numeric_system) {}\n FMT_CONSTEXPR void on_loc_time(numeric_system) {}\n FMT_CONSTEXPR void on_us_date() {}\n FMT_CONSTEXPR void on_iso_date() {}\n FMT_CONSTEXPR void on_12_hour_time() {}\n FMT_CONSTEXPR void on_24_hour_time() {}\n FMT_CONSTEXPR void on_iso_time() {}\n FMT_CONSTEXPR void on_am_pm() {}\n FMT_CONSTEXPR void on_utc_offset(numeric_system) {\n if (!has_timezone_) FMT_THROW(format_error(\"no timezone\"));\n }\n FMT_CONSTEXPR void on_tz_name() {\n if (!has_timezone_) FMT_THROW(format_error(\"no timezone\"));\n }\n};\n\ninline auto tm_wday_full_name(int wday) -> const char* {\n static constexpr const char* full_name_list[] = {\n \"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\",\n \"Thursday\", \"Friday\", \"Saturday\"};\n return wday >= 0 && wday <= 6 ? full_name_list[wday] : \"?\";\n}\ninline auto tm_wday_short_name(int wday) -> const char* {\n static constexpr const char* short_name_list[] = {\"Sun\", \"Mon\", \"Tue\", \"Wed\",\n \"Thu\", \"Fri\", \"Sat\"};\n return wday >= 0 && wday <= 6 ? short_name_list[wday] : \"???\";\n}\n\ninline auto tm_mon_full_name(int mon) -> const char* {\n static constexpr const char* full_name_list[] = {\n \"January\", \"February\", \"March\", \"April\", \"May\", \"June\",\n \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"};\n return mon >= 0 && mon <= 11 ? full_name_list[mon] : \"?\";\n}\ninline auto tm_mon_short_name(int mon) -> const char* {\n static constexpr const char* short_name_list[] = {\n \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\",\n \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\",\n };\n return mon >= 0 && mon <= 11 ? short_name_list[mon] : \"???\";\n}\n\ntemplate \nstruct has_tm_gmtoff : std::false_type {};\ntemplate \nstruct has_tm_gmtoff> : std::true_type {};\n\ntemplate struct has_tm_zone : std::false_type {};\ntemplate \nstruct has_tm_zone> : std::true_type {};\n\ntemplate ::value)>\nauto set_tm_zone(T& time, char* tz) -> bool {\n time.tm_zone = tz;\n return true;\n}\ntemplate ::value)>\nauto set_tm_zone(T&, char*) -> bool {\n return false;\n}\n\ninline auto utc() -> char* {\n static char tz[] = \"UTC\";\n return tz;\n}\n\n// Converts value to Int and checks that it's in the range [0, upper).\ntemplate ::value)>\ninline auto to_nonnegative_int(T value, Int upper) -> Int {\n if (!std::is_unsigned::value &&\n (value < 0 || to_unsigned(value) > to_unsigned(upper))) {\n FMT_THROW(format_error(\"chrono value is out of range\"));\n }\n return static_cast(value);\n}\ntemplate ::value)>\ninline auto to_nonnegative_int(T value, Int upper) -> Int {\n auto int_value = static_cast(value);\n if (int_value < 0 || value > static_cast(upper))\n FMT_THROW(format_error(\"invalid value\"));\n return int_value;\n}\n\nconstexpr auto pow10(std::uint32_t n) -> long long {\n return n == 0 ? 1 : 10 * pow10(n - 1);\n}\n\n// Counts the number of fractional digits in the range [0, 18] according to the\n// C++20 spec. If more than 18 fractional digits are required then returns 6 for\n// microseconds precision.\ntemplate () / 10)>\nstruct count_fractional_digits {\n static constexpr int value =\n Num % Den == 0 ? N : count_fractional_digits::value;\n};\n\n// Base case that doesn't instantiate any more templates\n// in order to avoid overflow.\ntemplate \nstruct count_fractional_digits {\n static constexpr int value = (Num % Den == 0) ? N : 6;\n};\n\n// Format subseconds which are given as an integer type with an appropriate\n// number of digits.\ntemplate \nvoid write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {\n constexpr auto num_fractional_digits =\n count_fractional_digits::value;\n\n using subsecond_precision = std::chrono::duration<\n typename std::common_type::type,\n std::ratio<1, pow10(num_fractional_digits)>>;\n\n const auto fractional = d - detail::duration_cast(d);\n const auto subseconds =\n std::chrono::treat_as_floating_point<\n typename subsecond_precision::rep>::value\n ? fractional.count()\n : detail::duration_cast(fractional).count();\n auto n = static_cast>(subseconds);\n const int num_digits = count_digits(n);\n\n int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits);\n if (precision < 0) {\n FMT_ASSERT(!std::is_floating_point::value, \"\");\n if (std::ratio_less::value) {\n *out++ = '.';\n out = detail::fill_n(out, leading_zeroes, '0');\n out = format_decimal(out, n, num_digits);\n }\n } else if (precision > 0) {\n *out++ = '.';\n leading_zeroes = min_of(leading_zeroes, precision);\n int remaining = precision - leading_zeroes;\n out = detail::fill_n(out, leading_zeroes, '0');\n if (remaining < num_digits) {\n int num_truncated_digits = num_digits - remaining;\n n /= to_unsigned(pow10(to_unsigned(num_truncated_digits)));\n if (n != 0) out = format_decimal(out, n, remaining);\n return;\n }\n if (n != 0) {\n out = format_decimal(out, n, num_digits);\n remaining -= num_digits;\n }\n out = detail::fill_n(out, remaining, '0');\n }\n}\n\n// Format subseconds which are given as a floating point type with an\n// appropriate number of digits. We cannot pass the Duration here, as we\n// explicitly need to pass the Rep value in the duration_formatter.\ntemplate \nvoid write_floating_seconds(memory_buffer& buf, Duration duration,\n int num_fractional_digits = -1) {\n using rep = typename Duration::rep;\n FMT_ASSERT(std::is_floating_point::value, \"\");\n\n auto val = duration.count();\n\n if (num_fractional_digits < 0) {\n // For `std::round` with fallback to `round`:\n // On some toolchains `std::round` is not available (e.g. GCC 6).\n using namespace std;\n num_fractional_digits =\n count_fractional_digits::value;\n if (num_fractional_digits < 6 && static_cast(round(val)) != val)\n num_fractional_digits = 6;\n }\n\n fmt::format_to(std::back_inserter(buf), FMT_STRING(\"{:.{}f}\"),\n std::fmod(val * static_cast(Duration::period::num) /\n static_cast(Duration::period::den),\n static_cast(60)),\n num_fractional_digits);\n}\n\ntemplate \nclass tm_writer {\n private:\n static constexpr int days_per_week = 7;\n\n const std::locale& loc_;\n bool is_classic_;\n OutputIt out_;\n const Duration* subsecs_;\n const std::tm& tm_;\n\n auto tm_sec() const noexcept -> int {\n FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, \"\");\n return tm_.tm_sec;\n }\n auto tm_min() const noexcept -> int {\n FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, \"\");\n return tm_.tm_min;\n }\n auto tm_hour() const noexcept -> int {\n FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, \"\");\n return tm_.tm_hour;\n }\n auto tm_mday() const noexcept -> int {\n FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, \"\");\n return tm_.tm_mday;\n }\n auto tm_mon() const noexcept -> int {\n FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, \"\");\n return tm_.tm_mon;\n }\n auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; }\n auto tm_wday() const noexcept -> int {\n FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, \"\");\n return tm_.tm_wday;\n }\n auto tm_yday() const noexcept -> int {\n FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, \"\");\n return tm_.tm_yday;\n }\n\n auto tm_hour12() const noexcept -> int {\n auto h = tm_hour();\n auto z = h < 12 ? h : h - 12;\n return z == 0 ? 12 : z;\n }\n\n // POSIX and the C Standard are unclear or inconsistent about what %C and %y\n // do if the year is negative or exceeds 9999. Use the convention that %C\n // concatenated with %y yields the same output as %Y, and that %Y contains at\n // least 4 characters, with more only if necessary.\n auto split_year_lower(long long year) const noexcept -> int {\n auto l = year % 100;\n if (l < 0) l = -l; // l in [0, 99]\n return static_cast(l);\n }\n\n // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.\n auto iso_year_weeks(long long curr_year) const noexcept -> int {\n auto prev_year = curr_year - 1;\n auto curr_p =\n (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) %\n days_per_week;\n auto prev_p =\n (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) %\n days_per_week;\n return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0);\n }\n auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int {\n return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) /\n days_per_week;\n }\n auto tm_iso_week_year() const noexcept -> long long {\n auto year = tm_year();\n auto w = iso_week_num(tm_yday(), tm_wday());\n if (w < 1) return year - 1;\n if (w > iso_year_weeks(year)) return year + 1;\n return year;\n }\n auto tm_iso_week_of_year() const noexcept -> int {\n auto year = tm_year();\n auto w = iso_week_num(tm_yday(), tm_wday());\n if (w < 1) return iso_year_weeks(year - 1);\n if (w > iso_year_weeks(year)) return 1;\n return w;\n }\n\n void write1(int value) {\n *out_++ = static_cast('0' + to_unsigned(value) % 10);\n }\n void write2(int value) {\n const char* d = digits2(to_unsigned(value) % 100);\n *out_++ = *d++;\n *out_++ = *d;\n }\n void write2(int value, pad_type pad) {\n unsigned int v = to_unsigned(value) % 100;\n if (v >= 10) {\n const char* d = digits2(v);\n *out_++ = *d++;\n *out_++ = *d;\n } else {\n out_ = detail::write_padding(out_, pad);\n *out_++ = static_cast('0' + v);\n }\n }\n\n void write_year_extended(long long year, pad_type pad) {\n // At least 4 characters.\n int width = 4;\n bool negative = year < 0;\n if (negative) {\n year = 0 - year;\n --width;\n }\n uint32_or_64_or_128_t n = to_unsigned(year);\n const int num_digits = count_digits(n);\n if (negative && pad == pad_type::zero) *out_++ = '-';\n if (width > num_digits)\n out_ = detail::write_padding(out_, pad, width - num_digits);\n if (negative && pad != pad_type::zero) *out_++ = '-';\n out_ = format_decimal(out_, n, num_digits);\n }\n void write_year(long long year, pad_type pad) {\n write_year_extended(year, pad);\n }\n\n void write_utc_offset(long long offset, numeric_system ns) {\n if (offset < 0) {\n *out_++ = '-';\n offset = -offset;\n } else {\n *out_++ = '+';\n }\n offset /= 60;\n write2(static_cast(offset / 60));\n if (ns != numeric_system::standard) *out_++ = ':';\n write2(static_cast(offset % 60));\n }\n\n template ::value)>\n void format_utc_offset(const T& tm, numeric_system ns) {\n write_utc_offset(tm.tm_gmtoff, ns);\n }\n template ::value)>\n void format_utc_offset(const T&, numeric_system ns) {\n write_utc_offset(0, ns);\n }\n\n template ::value)>\n void format_tz_name(const T& tm) {\n out_ = write_tm_str(out_, tm.tm_zone, loc_);\n }\n template ::value)>\n void format_tz_name(const T&) {\n out_ = std::copy_n(utc(), 3, out_);\n }\n\n void format_localized(char format, char modifier = 0) {\n out_ = write(out_, tm_, loc_, format, modifier);\n }\n\n public:\n tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm,\n const Duration* subsecs = nullptr)\n : loc_(loc),\n is_classic_(loc_ == get_classic_locale()),\n out_(out),\n subsecs_(subsecs),\n tm_(tm) {}\n\n auto out() const -> OutputIt { return out_; }\n\n FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {\n out_ = copy(begin, end, out_);\n }\n\n void on_abbr_weekday() {\n if (is_classic_)\n out_ = write(out_, tm_wday_short_name(tm_wday()));\n else\n format_localized('a');\n }\n void on_full_weekday() {\n if (is_classic_)\n out_ = write(out_, tm_wday_full_name(tm_wday()));\n else\n format_localized('A');\n }\n void on_dec0_weekday(numeric_system ns) {\n if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday());\n format_localized('w', 'O');\n }\n void on_dec1_weekday(numeric_system ns) {\n if (is_classic_ || ns == numeric_system::standard) {\n auto wday = tm_wday();\n write1(wday == 0 ? days_per_week : wday);\n } else {\n format_localized('u', 'O');\n }\n }\n\n void on_abbr_month() {\n if (is_classic_)\n out_ = write(out_, tm_mon_short_name(tm_mon()));\n else\n format_localized('b');\n }\n void on_full_month() {\n if (is_classic_)\n out_ = write(out_, tm_mon_full_name(tm_mon()));\n else\n format_localized('B');\n }\n\n void on_datetime(numeric_system ns) {\n if (is_classic_) {\n on_abbr_weekday();\n *out_++ = ' ';\n on_abbr_month();\n *out_++ = ' ';\n on_day_of_month(numeric_system::standard, pad_type::space);\n *out_++ = ' ';\n on_iso_time();\n *out_++ = ' ';\n on_year(numeric_system::standard, pad_type::space);\n } else {\n format_localized('c', ns == numeric_system::standard ? '\\0' : 'E');\n }\n }\n void on_loc_date(numeric_system ns) {\n if (is_classic_)\n on_us_date();\n else\n format_localized('x', ns == numeric_system::standard ? '\\0' : 'E');\n }\n void on_loc_time(numeric_system ns) {\n if (is_classic_)\n on_iso_time();\n else\n format_localized('X', ns == numeric_system::standard ? '\\0' : 'E');\n }\n void on_us_date() {\n char buf[8];\n write_digit2_separated(buf, to_unsigned(tm_mon() + 1),\n to_unsigned(tm_mday()),\n to_unsigned(split_year_lower(tm_year())), '/');\n out_ = copy(std::begin(buf), std::end(buf), out_);\n }\n void on_iso_date() {\n auto year = tm_year();\n char buf[10];\n size_t offset = 0;\n if (year >= 0 && year < 10000) {\n write2digits(buf, static_cast(year / 100));\n } else {\n offset = 4;\n write_year_extended(year, pad_type::zero);\n year = 0;\n }\n write_digit2_separated(buf + 2, static_cast(year % 100),\n to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()),\n '-');\n out_ = copy(std::begin(buf) + offset, std::end(buf), out_);\n }\n\n void on_utc_offset(numeric_system ns) { format_utc_offset(tm_, ns); }\n void on_tz_name() { format_tz_name(tm_); }\n\n void on_year(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write_year(tm_year(), pad);\n format_localized('Y', 'E');\n }\n void on_short_year(numeric_system ns) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(split_year_lower(tm_year()));\n format_localized('y', 'O');\n }\n void on_offset_year() {\n if (is_classic_) return write2(split_year_lower(tm_year()));\n format_localized('y', 'E');\n }\n\n void on_century(numeric_system ns) {\n if (is_classic_ || ns == numeric_system::standard) {\n auto year = tm_year();\n auto upper = year / 100;\n if (year >= -99 && year < 0) {\n // Zero upper on negative year.\n *out_++ = '-';\n *out_++ = '0';\n } else if (upper >= 0 && upper < 100) {\n write2(static_cast(upper));\n } else {\n out_ = write(out_, upper);\n }\n } else {\n format_localized('C', 'E');\n }\n }\n\n void on_dec_month(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_mon() + 1, pad);\n format_localized('m', 'O');\n }\n\n void on_dec0_week_of_year(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week,\n pad);\n format_localized('U', 'O');\n }\n void on_dec1_week_of_year(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard) {\n auto wday = tm_wday();\n write2((tm_yday() + days_per_week -\n (wday == 0 ? (days_per_week - 1) : (wday - 1))) /\n days_per_week,\n pad);\n } else {\n format_localized('W', 'O');\n }\n }\n void on_iso_week_of_year(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_iso_week_of_year(), pad);\n format_localized('V', 'O');\n }\n\n void on_iso_week_based_year() {\n write_year(tm_iso_week_year(), pad_type::zero);\n }\n void on_iso_week_based_short_year() {\n write2(split_year_lower(tm_iso_week_year()));\n }\n\n void on_day_of_year(pad_type pad) {\n auto yday = tm_yday() + 1;\n auto digit1 = yday / 100;\n if (digit1 != 0)\n write1(digit1);\n else\n out_ = detail::write_padding(out_, pad);\n write2(yday % 100, pad);\n }\n\n void on_day_of_month(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_mday(), pad);\n format_localized('d', 'O');\n }\n\n void on_24_hour(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_hour(), pad);\n format_localized('H', 'O');\n }\n void on_12_hour(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_hour12(), pad);\n format_localized('I', 'O');\n }\n void on_minute(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard)\n return write2(tm_min(), pad);\n format_localized('M', 'O');\n }\n\n void on_second(numeric_system ns, pad_type pad) {\n if (is_classic_ || ns == numeric_system::standard) {\n write2(tm_sec(), pad);\n if (subsecs_) {\n if (std::is_floating_point::value) {\n auto buf = memory_buffer();\n write_floating_seconds(buf, *subsecs_);\n if (buf.size() > 1) {\n // Remove the leading \"0\", write something like \".123\".\n out_ = copy(buf.begin() + 1, buf.end(), out_);\n }\n } else {\n write_fractional_seconds(out_, *subsecs_);\n }\n }\n } else {\n // Currently no formatting of subseconds when a locale is set.\n format_localized('S', 'O');\n }\n }\n\n void on_12_hour_time() {\n if (is_classic_) {\n char buf[8];\n write_digit2_separated(buf, to_unsigned(tm_hour12()),\n to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');\n out_ = copy(std::begin(buf), std::end(buf), out_);\n *out_++ = ' ';\n on_am_pm();\n } else {\n format_localized('r');\n }\n }\n void on_24_hour_time() {\n write2(tm_hour());\n *out_++ = ':';\n write2(tm_min());\n }\n void on_iso_time() {\n on_24_hour_time();\n *out_++ = ':';\n on_second(numeric_system::standard, pad_type::zero);\n }\n\n void on_am_pm() {\n if (is_classic_) {\n *out_++ = tm_hour() < 12 ? 'A' : 'P';\n *out_++ = 'M';\n } else {\n format_localized('p');\n }\n }\n\n // These apply to chrono durations but not tm.\n void on_duration_value() {}\n void on_duration_unit() {}\n};\n\nstruct chrono_format_checker : null_chrono_spec_handler {\n bool has_precision_integral = false;\n\n FMT_NORETURN inline void unsupported() { FMT_THROW(format_error(\"no date\")); }\n\n template \n FMT_CONSTEXPR void on_text(const Char*, const Char*) {}\n FMT_CONSTEXPR void on_day_of_year(pad_type) {}\n FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}\n FMT_CONSTEXPR void on_12_hour_time() {}\n FMT_CONSTEXPR void on_24_hour_time() {}\n FMT_CONSTEXPR void on_iso_time() {}\n FMT_CONSTEXPR void on_am_pm() {}\n FMT_CONSTEXPR void on_duration_value() const {\n if (has_precision_integral)\n FMT_THROW(format_error(\"precision not allowed for this argument type\"));\n }\n FMT_CONSTEXPR void on_duration_unit() {}\n};\n\ntemplate ::value&& has_isfinite::value)>\ninline auto isfinite(T) -> bool {\n return true;\n}\n\ntemplate ::value)>\ninline auto mod(T x, int y) -> T {\n return x % static_cast(y);\n}\ntemplate ::value)>\ninline auto mod(T x, int y) -> T {\n return std::fmod(x, static_cast(y));\n}\n\n// If T is an integral type, maps T to its unsigned counterpart, otherwise\n// leaves it unchanged (unlike std::make_unsigned).\ntemplate ::value>\nstruct make_unsigned_or_unchanged {\n using type = T;\n};\n\ntemplate struct make_unsigned_or_unchanged {\n using type = typename std::make_unsigned::type;\n};\n\ntemplate ::value)>\ninline auto get_milliseconds(std::chrono::duration d)\n -> std::chrono::duration {\n // This may overflow and/or the result may not fit in the target type.\n#if FMT_SAFE_DURATION_CAST\n using common_seconds_type =\n typename std::common_type::type;\n auto d_as_common = detail::duration_cast(d);\n auto d_as_whole_seconds =\n detail::duration_cast(d_as_common);\n // This conversion should be nonproblematic.\n auto diff = d_as_common - d_as_whole_seconds;\n auto ms = detail::duration_cast>(diff);\n return ms;\n#else\n auto s = detail::duration_cast(d);\n return detail::duration_cast(d - s);\n#endif\n}\n\ntemplate ::value)>\nauto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {\n return write(out, val);\n}\n\ntemplate ::value)>\nauto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {\n auto specs = format_specs();\n specs.precision = precision;\n specs.set_type(precision >= 0 ? presentation_type::fixed\n : presentation_type::general);\n return write(out, val, specs);\n}\n\ntemplate \nauto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {\n return copy(unit.begin(), unit.end(), out);\n}\n\ntemplate \nauto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {\n // This works when wchar_t is UTF-32 because units only contain characters\n // that have the same representation in UTF-16 and UTF-32.\n utf8_to_utf16 u(unit);\n return copy(u.c_str(), u.c_str() + u.size(), out);\n}\n\ntemplate \nauto format_duration_unit(OutputIt out) -> OutputIt {\n if (const char* unit = get_units())\n return copy_unit(string_view(unit), out, Char());\n *out++ = '[';\n out = write(out, Period::num);\n if (const_check(Period::den != 1)) {\n *out++ = '/';\n out = write(out, Period::den);\n }\n *out++ = ']';\n *out++ = 's';\n return out;\n}\n\nclass get_locale {\n private:\n union {\n std::locale locale_;\n };\n bool has_locale_ = false;\n\n public:\n inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) {\n if (!localized) return;\n ignore_unused(loc);\n ::new (&locale_) std::locale(\n#if FMT_USE_LOCALE\n loc.template get()\n#endif\n );\n }\n inline ~get_locale() {\n if (has_locale_) locale_.~locale();\n }\n inline operator const std::locale&() const {\n return has_locale_ ? locale_ : get_classic_locale();\n }\n};\n\ntemplate \nstruct duration_formatter {\n using iterator = basic_appender;\n iterator out;\n // rep is unsigned to avoid overflow.\n using rep =\n conditional_t::value && sizeof(Rep) < sizeof(int),\n unsigned, typename make_unsigned_or_unchanged::type>;\n rep val;\n int precision;\n locale_ref locale;\n bool localized = false;\n using seconds = std::chrono::duration;\n seconds s;\n using milliseconds = std::chrono::duration;\n bool negative;\n\n using tm_writer_type = tm_writer;\n\n duration_formatter(iterator o, std::chrono::duration d,\n locale_ref loc)\n : out(o), val(static_cast(d.count())), locale(loc), negative(false) {\n if (d.count() < 0) {\n val = 0 - val;\n negative = true;\n }\n\n // this may overflow and/or the result may not fit in the\n // target type.\n // might need checked conversion (rep!=Rep)\n s = detail::duration_cast(std::chrono::duration(val));\n }\n\n // returns true if nan or inf, writes to out.\n auto handle_nan_inf() -> bool {\n if (isfinite(val)) return false;\n if (isnan(val)) {\n write_nan();\n return true;\n }\n // must be +-inf\n if (val > 0)\n std::copy_n(\"inf\", 3, out);\n else\n std::copy_n(\"-inf\", 4, out);\n return true;\n }\n\n auto days() const -> Rep { return static_cast(s.count() / 86400); }\n auto hour() const -> Rep {\n return static_cast(mod((s.count() / 3600), 24));\n }\n\n auto hour12() const -> Rep {\n Rep hour = static_cast(mod((s.count() / 3600), 12));\n return hour <= 0 ? 12 : hour;\n }\n\n auto minute() const -> Rep {\n return static_cast(mod((s.count() / 60), 60));\n }\n auto second() const -> Rep { return static_cast(mod(s.count(), 60)); }\n\n auto time() const -> std::tm {\n auto time = std::tm();\n time.tm_hour = to_nonnegative_int(hour(), 24);\n time.tm_min = to_nonnegative_int(minute(), 60);\n time.tm_sec = to_nonnegative_int(second(), 60);\n return time;\n }\n\n void write_sign() {\n if (!negative) return;\n *out++ = '-';\n negative = false;\n }\n\n void write(Rep value, int width, pad_type pad = pad_type::zero) {\n write_sign();\n if (isnan(value)) return write_nan();\n uint32_or_64_or_128_t n =\n to_unsigned(to_nonnegative_int(value, max_value()));\n int num_digits = detail::count_digits(n);\n if (width > num_digits) {\n out = detail::write_padding(out, pad, width - num_digits);\n }\n out = format_decimal(out, n, num_digits);\n }\n\n void write_nan() { std::copy_n(\"nan\", 3, out); }\n\n template \n void format_tm(const tm& time, Callback cb, Args... args) {\n if (isnan(val)) return write_nan();\n get_locale loc(localized, locale);\n auto w = tm_writer_type(loc, out, time);\n (w.*cb)(args...);\n out = w.out();\n }\n\n void on_text(const Char* begin, const Char* end) {\n copy(begin, end, out);\n }\n\n // These are not implemented because durations don't have date information.\n void on_abbr_weekday() {}\n void on_full_weekday() {}\n void on_dec0_weekday(numeric_system) {}\n void on_dec1_weekday(numeric_system) {}\n void on_abbr_month() {}\n void on_full_month() {}\n void on_datetime(numeric_system) {}\n void on_loc_date(numeric_system) {}\n void on_loc_time(numeric_system) {}\n void on_us_date() {}\n void on_iso_date() {}\n void on_utc_offset(numeric_system) {}\n void on_tz_name() {}\n void on_year(numeric_system, pad_type) {}\n void on_short_year(numeric_system) {}\n void on_offset_year() {}\n void on_century(numeric_system) {}\n void on_iso_week_based_year() {}\n void on_iso_week_based_short_year() {}\n void on_dec_month(numeric_system, pad_type) {}\n void on_dec0_week_of_year(numeric_system, pad_type) {}\n void on_dec1_week_of_year(numeric_system, pad_type) {}\n void on_iso_week_of_year(numeric_system, pad_type) {}\n void on_day_of_month(numeric_system, pad_type) {}\n\n void on_day_of_year(pad_type) {\n if (handle_nan_inf()) return;\n write(days(), 0);\n }\n\n void on_24_hour(numeric_system ns, pad_type pad) {\n if (handle_nan_inf()) return;\n\n if (ns == numeric_system::standard) return write(hour(), 2, pad);\n auto time = tm();\n time.tm_hour = to_nonnegative_int(hour(), 24);\n format_tm(time, &tm_writer_type::on_24_hour, ns, pad);\n }\n\n void on_12_hour(numeric_system ns, pad_type pad) {\n if (handle_nan_inf()) return;\n\n if (ns == numeric_system::standard) return write(hour12(), 2, pad);\n auto time = tm();\n time.tm_hour = to_nonnegative_int(hour12(), 12);\n format_tm(time, &tm_writer_type::on_12_hour, ns, pad);\n }\n\n void on_minute(numeric_system ns, pad_type pad) {\n if (handle_nan_inf()) return;\n\n if (ns == numeric_system::standard) return write(minute(), 2, pad);\n auto time = tm();\n time.tm_min = to_nonnegative_int(minute(), 60);\n format_tm(time, &tm_writer_type::on_minute, ns, pad);\n }\n\n void on_second(numeric_system ns, pad_type pad) {\n if (handle_nan_inf()) return;\n\n if (ns == numeric_system::standard) {\n if (std::is_floating_point::value) {\n auto buf = memory_buffer();\n write_floating_seconds(buf, std::chrono::duration(val),\n precision);\n if (negative) *out++ = '-';\n if (buf.size() < 2 || buf[1] == '.')\n out = detail::write_padding(out, pad);\n out = copy(buf.begin(), buf.end(), out);\n } else {\n write(second(), 2, pad);\n write_fractional_seconds(\n out, std::chrono::duration(val), precision);\n }\n return;\n }\n auto time = tm();\n time.tm_sec = to_nonnegative_int(second(), 60);\n format_tm(time, &tm_writer_type::on_second, ns, pad);\n }\n\n void on_12_hour_time() {\n if (handle_nan_inf()) return;\n format_tm(time(), &tm_writer_type::on_12_hour_time);\n }\n\n void on_24_hour_time() {\n if (handle_nan_inf()) {\n *out++ = ':';\n handle_nan_inf();\n return;\n }\n\n write(hour(), 2);\n *out++ = ':';\n write(minute(), 2);\n }\n\n void on_iso_time() {\n on_24_hour_time();\n *out++ = ':';\n if (handle_nan_inf()) return;\n on_second(numeric_system::standard, pad_type::zero);\n }\n\n void on_am_pm() {\n if (handle_nan_inf()) return;\n format_tm(time(), &tm_writer_type::on_am_pm);\n }\n\n void on_duration_value() {\n if (handle_nan_inf()) return;\n write_sign();\n out = format_duration_value(out, val, precision);\n }\n\n void on_duration_unit() { out = format_duration_unit(out); }\n};\n\n} // namespace detail\n\n#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907\nusing weekday = std::chrono::weekday;\nusing day = std::chrono::day;\nusing month = std::chrono::month;\nusing year = std::chrono::year;\nusing year_month_day = std::chrono::year_month_day;\n#else\n// A fallback version of weekday.\nclass weekday {\n private:\n unsigned char value_;\n\n public:\n weekday() = default;\n constexpr explicit weekday(unsigned wd) noexcept\n : value_(static_cast(wd != 7 ? wd : 0)) {}\n constexpr auto c_encoding() const noexcept -> unsigned { return value_; }\n};\n\nclass day {\n private:\n unsigned char value_;\n\n public:\n day() = default;\n constexpr explicit day(unsigned d) noexcept\n : value_(static_cast(d)) {}\n constexpr explicit operator unsigned() const noexcept { return value_; }\n};\n\nclass month {\n private:\n unsigned char value_;\n\n public:\n month() = default;\n constexpr explicit month(unsigned m) noexcept\n : value_(static_cast(m)) {}\n constexpr explicit operator unsigned() const noexcept { return value_; }\n};\n\nclass year {\n private:\n int value_;\n\n public:\n year() = default;\n constexpr explicit year(int y) noexcept : value_(y) {}\n constexpr explicit operator int() const noexcept { return value_; }\n};\n\nclass year_month_day {\n private:\n fmt::year year_;\n fmt::month month_;\n fmt::day day_;\n\n public:\n year_month_day() = default;\n constexpr year_month_day(const year& y, const month& m, const day& d) noexcept\n : year_(y), month_(m), day_(d) {}\n constexpr auto year() const noexcept -> fmt::year { return year_; }\n constexpr auto month() const noexcept -> fmt::month { return month_; }\n constexpr auto day() const noexcept -> fmt::day { return day_; }\n};\n#endif // __cpp_lib_chrono >= 201907\n\ntemplate \nstruct formatter : private formatter {\n private:\n bool use_tm_formatter_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it != end && *it == 'L') {\n ++it;\n this->set_localized();\n }\n use_tm_formatter_ = it != end && *it != '}';\n return use_tm_formatter_ ? formatter::parse(ctx) : it;\n }\n\n template \n auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto time = std::tm();\n time.tm_wday = static_cast(wd.c_encoding());\n if (use_tm_formatter_) return formatter::format(time, ctx);\n detail::get_locale loc(this->localized(), ctx.locale());\n auto w = detail::tm_writer(loc, ctx.out(), time);\n w.on_abbr_weekday();\n return w.out();\n }\n};\n\ntemplate \nstruct formatter : private formatter {\n private:\n bool use_tm_formatter_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n use_tm_formatter_ = it != end && *it != '}';\n return use_tm_formatter_ ? formatter::parse(ctx) : it;\n }\n\n template \n auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto time = std::tm();\n time.tm_mday = static_cast(static_cast(d));\n if (use_tm_formatter_) return formatter::format(time, ctx);\n detail::get_locale loc(false, ctx.locale());\n auto w = detail::tm_writer(loc, ctx.out(), time);\n w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero);\n return w.out();\n }\n};\n\ntemplate \nstruct formatter : private formatter {\n private:\n bool use_tm_formatter_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it != end && *it == 'L') {\n ++it;\n this->set_localized();\n }\n use_tm_formatter_ = it != end && *it != '}';\n return use_tm_formatter_ ? formatter::parse(ctx) : it;\n }\n\n template \n auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto time = std::tm();\n time.tm_mon = static_cast(static_cast(m)) - 1;\n if (use_tm_formatter_) return formatter::format(time, ctx);\n detail::get_locale loc(this->localized(), ctx.locale());\n auto w = detail::tm_writer(loc, ctx.out(), time);\n w.on_abbr_month();\n return w.out();\n }\n};\n\ntemplate \nstruct formatter : private formatter {\n private:\n bool use_tm_formatter_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n use_tm_formatter_ = it != end && *it != '}';\n return use_tm_formatter_ ? formatter::parse(ctx) : it;\n }\n\n template \n auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto time = std::tm();\n time.tm_year = static_cast(y) - 1900;\n if (use_tm_formatter_) return formatter::format(time, ctx);\n detail::get_locale loc(false, ctx.locale());\n auto w = detail::tm_writer(loc, ctx.out(), time);\n w.on_year(detail::numeric_system::standard, detail::pad_type::zero);\n return w.out();\n }\n};\n\ntemplate \nstruct formatter : private formatter {\n private:\n bool use_tm_formatter_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n use_tm_formatter_ = it != end && *it != '}';\n return use_tm_formatter_ ? formatter::parse(ctx) : it;\n }\n\n template \n auto format(year_month_day val, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto time = std::tm();\n time.tm_year = static_cast(val.year()) - 1900;\n time.tm_mon = static_cast(static_cast(val.month())) - 1;\n time.tm_mday = static_cast(static_cast(val.day()));\n if (use_tm_formatter_) return formatter::format(time, ctx);\n detail::get_locale loc(true, ctx.locale());\n auto w = detail::tm_writer(loc, ctx.out(), time);\n w.on_iso_date();\n return w.out();\n }\n};\n\ntemplate \nstruct formatter, Char> {\n private:\n format_specs specs_;\n detail::arg_ref width_ref_;\n detail::arg_ref precision_ref_;\n basic_string_view fmt_;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it == end || *it == '}') return it;\n\n it = detail::parse_align(it, end, specs_);\n if (it == end) return it;\n\n Char c = *it;\n if ((c >= '0' && c <= '9') || c == '{') {\n it = detail::parse_width(it, end, specs_, width_ref_, ctx);\n if (it == end) return it;\n }\n\n auto checker = detail::chrono_format_checker();\n if (*it == '.') {\n checker.has_precision_integral = !std::is_floating_point::value;\n it = detail::parse_precision(it, end, specs_, precision_ref_, ctx);\n }\n if (it != end && *it == 'L') {\n specs_.set_localized();\n ++it;\n }\n end = detail::parse_chrono_format(it, end, checker);\n fmt_ = {it, detail::to_unsigned(end - it)};\n return end;\n }\n\n template \n auto format(std::chrono::duration d, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto specs = specs_;\n auto precision = specs.precision;\n specs.precision = -1;\n auto begin = fmt_.begin(), end = fmt_.end();\n // As a possible future optimization, we could avoid extra copying if width\n // is not specified.\n auto buf = basic_memory_buffer();\n auto out = basic_appender(buf);\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,\n ctx);\n detail::handle_dynamic_spec(specs.dynamic_precision(), precision,\n precision_ref_, ctx);\n if (begin == end || *begin == '}') {\n out = detail::format_duration_value(out, d.count(), precision);\n detail::format_duration_unit(out);\n } else {\n auto f =\n detail::duration_formatter(out, d, ctx.locale());\n f.precision = precision;\n f.localized = specs_.localized();\n detail::parse_chrono_format(begin, end, f);\n }\n return detail::write(\n ctx.out(), basic_string_view(buf.data(), buf.size()), specs);\n }\n};\n\ntemplate struct formatter {\n private:\n format_specs specs_;\n detail::arg_ref width_ref_;\n basic_string_view fmt_ =\n detail::string_literal();\n\n protected:\n auto localized() const -> bool { return specs_.localized(); }\n FMT_CONSTEXPR void set_localized() { specs_.set_localized(); }\n\n FMT_CONSTEXPR auto do_parse(parse_context& ctx, bool has_timezone)\n -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it == end || *it == '}') return it;\n\n it = detail::parse_align(it, end, specs_);\n if (it == end) return it;\n\n Char c = *it;\n if ((c >= '0' && c <= '9') || c == '{') {\n it = detail::parse_width(it, end, specs_, width_ref_, ctx);\n if (it == end) return it;\n }\n\n if (*it == 'L') {\n specs_.set_localized();\n ++it;\n }\n\n end = detail::parse_chrono_format(it, end,\n detail::tm_format_checker(has_timezone));\n // Replace the default format string only if the new spec is not empty.\n if (end != it) fmt_ = {it, detail::to_unsigned(end - it)};\n return end;\n }\n\n template \n auto do_format(const std::tm& tm, FormatContext& ctx,\n const Duration* subsecs) const -> decltype(ctx.out()) {\n auto specs = specs_;\n auto buf = basic_memory_buffer();\n auto out = basic_appender(buf);\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,\n ctx);\n\n auto loc_ref = specs.localized() ? ctx.locale() : locale_ref();\n detail::get_locale loc(static_cast(loc_ref), loc_ref);\n auto w = detail::tm_writer, Char, Duration>(\n loc, out, tm, subsecs);\n detail::parse_chrono_format(fmt_.begin(), fmt_.end(), w);\n return detail::write(\n ctx.out(), basic_string_view(buf.data(), buf.size()), specs);\n }\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return do_parse(ctx, detail::has_tm_gmtoff::value);\n }\n\n template \n auto format(const std::tm& tm, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return do_format(tm, ctx, nullptr);\n }\n};\n\n// DEPRECATED! Reversed order of template parameters.\ntemplate \nstruct formatter, Char> : private formatter {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return this->do_parse(ctx, true);\n }\n\n template \n auto format(sys_time val, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n std::tm tm = gmtime(val);\n using period = typename Duration::period;\n if (detail::const_check(\n period::num == 1 && period::den == 1 &&\n !std::is_floating_point::value)) {\n detail::set_tm_zone(tm, detail::utc());\n return formatter::format(tm, ctx);\n }\n Duration epoch = val.time_since_epoch();\n Duration subsecs = detail::duration_cast(\n epoch - detail::duration_cast(epoch));\n if (subsecs.count() < 0) {\n auto second = detail::duration_cast(std::chrono::seconds(1));\n if (tm.tm_sec != 0) {\n --tm.tm_sec;\n } else {\n tm = gmtime(val - second);\n detail::set_tm_zone(tm, detail::utc());\n }\n subsecs += second;\n }\n return formatter::do_format(tm, ctx, &subsecs);\n }\n};\n\ntemplate \nstruct formatter, Char>\n : formatter, Char> {\n template \n auto format(utc_time val, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return formatter, Char>::format(\n detail::utc_clock::to_sys(val), ctx);\n }\n};\n\ntemplate \nstruct formatter, Char>\n : private formatter {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return this->do_parse(ctx, false);\n }\n\n template \n auto format(local_time val, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto time_since_epoch = val.time_since_epoch();\n auto seconds_since_epoch =\n detail::duration_cast(time_since_epoch);\n // Use gmtime to prevent time zone conversion since local_time has an\n // unspecified time zone.\n std::tm t = gmtime(seconds_since_epoch.count());\n using period = typename Duration::period;\n if (period::num == 1 && period::den == 1 &&\n !std::is_floating_point::value) {\n return formatter::format(t, ctx);\n }\n auto subsecs =\n detail::duration_cast(time_since_epoch - seconds_since_epoch);\n return formatter::do_format(t, ctx, &subsecs);\n }\n};\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_CHRONO_H_\n" }, { "path": "include/spdlog/fmt/bundled/color.h", "content": "// Formatting library for C++ - color support\n//\n// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_COLOR_H_\n#define FMT_COLOR_H_\n\n#include \"format.h\"\n\nFMT_BEGIN_NAMESPACE\nFMT_BEGIN_EXPORT\n\nenum class color : uint32_t {\n alice_blue = 0xF0F8FF, // rgb(240,248,255)\n antique_white = 0xFAEBD7, // rgb(250,235,215)\n aqua = 0x00FFFF, // rgb(0,255,255)\n aquamarine = 0x7FFFD4, // rgb(127,255,212)\n azure = 0xF0FFFF, // rgb(240,255,255)\n beige = 0xF5F5DC, // rgb(245,245,220)\n bisque = 0xFFE4C4, // rgb(255,228,196)\n black = 0x000000, // rgb(0,0,0)\n blanched_almond = 0xFFEBCD, // rgb(255,235,205)\n blue = 0x0000FF, // rgb(0,0,255)\n blue_violet = 0x8A2BE2, // rgb(138,43,226)\n brown = 0xA52A2A, // rgb(165,42,42)\n burly_wood = 0xDEB887, // rgb(222,184,135)\n cadet_blue = 0x5F9EA0, // rgb(95,158,160)\n chartreuse = 0x7FFF00, // rgb(127,255,0)\n chocolate = 0xD2691E, // rgb(210,105,30)\n coral = 0xFF7F50, // rgb(255,127,80)\n cornflower_blue = 0x6495ED, // rgb(100,149,237)\n cornsilk = 0xFFF8DC, // rgb(255,248,220)\n crimson = 0xDC143C, // rgb(220,20,60)\n cyan = 0x00FFFF, // rgb(0,255,255)\n dark_blue = 0x00008B, // rgb(0,0,139)\n dark_cyan = 0x008B8B, // rgb(0,139,139)\n dark_golden_rod = 0xB8860B, // rgb(184,134,11)\n dark_gray = 0xA9A9A9, // rgb(169,169,169)\n dark_green = 0x006400, // rgb(0,100,0)\n dark_khaki = 0xBDB76B, // rgb(189,183,107)\n dark_magenta = 0x8B008B, // rgb(139,0,139)\n dark_olive_green = 0x556B2F, // rgb(85,107,47)\n dark_orange = 0xFF8C00, // rgb(255,140,0)\n dark_orchid = 0x9932CC, // rgb(153,50,204)\n dark_red = 0x8B0000, // rgb(139,0,0)\n dark_salmon = 0xE9967A, // rgb(233,150,122)\n dark_sea_green = 0x8FBC8F, // rgb(143,188,143)\n dark_slate_blue = 0x483D8B, // rgb(72,61,139)\n dark_slate_gray = 0x2F4F4F, // rgb(47,79,79)\n dark_turquoise = 0x00CED1, // rgb(0,206,209)\n dark_violet = 0x9400D3, // rgb(148,0,211)\n deep_pink = 0xFF1493, // rgb(255,20,147)\n deep_sky_blue = 0x00BFFF, // rgb(0,191,255)\n dim_gray = 0x696969, // rgb(105,105,105)\n dodger_blue = 0x1E90FF, // rgb(30,144,255)\n fire_brick = 0xB22222, // rgb(178,34,34)\n floral_white = 0xFFFAF0, // rgb(255,250,240)\n forest_green = 0x228B22, // rgb(34,139,34)\n fuchsia = 0xFF00FF, // rgb(255,0,255)\n gainsboro = 0xDCDCDC, // rgb(220,220,220)\n ghost_white = 0xF8F8FF, // rgb(248,248,255)\n gold = 0xFFD700, // rgb(255,215,0)\n golden_rod = 0xDAA520, // rgb(218,165,32)\n gray = 0x808080, // rgb(128,128,128)\n green = 0x008000, // rgb(0,128,0)\n green_yellow = 0xADFF2F, // rgb(173,255,47)\n honey_dew = 0xF0FFF0, // rgb(240,255,240)\n hot_pink = 0xFF69B4, // rgb(255,105,180)\n indian_red = 0xCD5C5C, // rgb(205,92,92)\n indigo = 0x4B0082, // rgb(75,0,130)\n ivory = 0xFFFFF0, // rgb(255,255,240)\n khaki = 0xF0E68C, // rgb(240,230,140)\n lavender = 0xE6E6FA, // rgb(230,230,250)\n lavender_blush = 0xFFF0F5, // rgb(255,240,245)\n lawn_green = 0x7CFC00, // rgb(124,252,0)\n lemon_chiffon = 0xFFFACD, // rgb(255,250,205)\n light_blue = 0xADD8E6, // rgb(173,216,230)\n light_coral = 0xF08080, // rgb(240,128,128)\n light_cyan = 0xE0FFFF, // rgb(224,255,255)\n light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)\n light_gray = 0xD3D3D3, // rgb(211,211,211)\n light_green = 0x90EE90, // rgb(144,238,144)\n light_pink = 0xFFB6C1, // rgb(255,182,193)\n light_salmon = 0xFFA07A, // rgb(255,160,122)\n light_sea_green = 0x20B2AA, // rgb(32,178,170)\n light_sky_blue = 0x87CEFA, // rgb(135,206,250)\n light_slate_gray = 0x778899, // rgb(119,136,153)\n light_steel_blue = 0xB0C4DE, // rgb(176,196,222)\n light_yellow = 0xFFFFE0, // rgb(255,255,224)\n lime = 0x00FF00, // rgb(0,255,0)\n lime_green = 0x32CD32, // rgb(50,205,50)\n linen = 0xFAF0E6, // rgb(250,240,230)\n magenta = 0xFF00FF, // rgb(255,0,255)\n maroon = 0x800000, // rgb(128,0,0)\n medium_aquamarine = 0x66CDAA, // rgb(102,205,170)\n medium_blue = 0x0000CD, // rgb(0,0,205)\n medium_orchid = 0xBA55D3, // rgb(186,85,211)\n medium_purple = 0x9370DB, // rgb(147,112,219)\n medium_sea_green = 0x3CB371, // rgb(60,179,113)\n medium_slate_blue = 0x7B68EE, // rgb(123,104,238)\n medium_spring_green = 0x00FA9A, // rgb(0,250,154)\n medium_turquoise = 0x48D1CC, // rgb(72,209,204)\n medium_violet_red = 0xC71585, // rgb(199,21,133)\n midnight_blue = 0x191970, // rgb(25,25,112)\n mint_cream = 0xF5FFFA, // rgb(245,255,250)\n misty_rose = 0xFFE4E1, // rgb(255,228,225)\n moccasin = 0xFFE4B5, // rgb(255,228,181)\n navajo_white = 0xFFDEAD, // rgb(255,222,173)\n navy = 0x000080, // rgb(0,0,128)\n old_lace = 0xFDF5E6, // rgb(253,245,230)\n olive = 0x808000, // rgb(128,128,0)\n olive_drab = 0x6B8E23, // rgb(107,142,35)\n orange = 0xFFA500, // rgb(255,165,0)\n orange_red = 0xFF4500, // rgb(255,69,0)\n orchid = 0xDA70D6, // rgb(218,112,214)\n pale_golden_rod = 0xEEE8AA, // rgb(238,232,170)\n pale_green = 0x98FB98, // rgb(152,251,152)\n pale_turquoise = 0xAFEEEE, // rgb(175,238,238)\n pale_violet_red = 0xDB7093, // rgb(219,112,147)\n papaya_whip = 0xFFEFD5, // rgb(255,239,213)\n peach_puff = 0xFFDAB9, // rgb(255,218,185)\n peru = 0xCD853F, // rgb(205,133,63)\n pink = 0xFFC0CB, // rgb(255,192,203)\n plum = 0xDDA0DD, // rgb(221,160,221)\n powder_blue = 0xB0E0E6, // rgb(176,224,230)\n purple = 0x800080, // rgb(128,0,128)\n rebecca_purple = 0x663399, // rgb(102,51,153)\n red = 0xFF0000, // rgb(255,0,0)\n rosy_brown = 0xBC8F8F, // rgb(188,143,143)\n royal_blue = 0x4169E1, // rgb(65,105,225)\n saddle_brown = 0x8B4513, // rgb(139,69,19)\n salmon = 0xFA8072, // rgb(250,128,114)\n sandy_brown = 0xF4A460, // rgb(244,164,96)\n sea_green = 0x2E8B57, // rgb(46,139,87)\n sea_shell = 0xFFF5EE, // rgb(255,245,238)\n sienna = 0xA0522D, // rgb(160,82,45)\n silver = 0xC0C0C0, // rgb(192,192,192)\n sky_blue = 0x87CEEB, // rgb(135,206,235)\n slate_blue = 0x6A5ACD, // rgb(106,90,205)\n slate_gray = 0x708090, // rgb(112,128,144)\n snow = 0xFFFAFA, // rgb(255,250,250)\n spring_green = 0x00FF7F, // rgb(0,255,127)\n steel_blue = 0x4682B4, // rgb(70,130,180)\n tan = 0xD2B48C, // rgb(210,180,140)\n teal = 0x008080, // rgb(0,128,128)\n thistle = 0xD8BFD8, // rgb(216,191,216)\n tomato = 0xFF6347, // rgb(255,99,71)\n turquoise = 0x40E0D0, // rgb(64,224,208)\n violet = 0xEE82EE, // rgb(238,130,238)\n wheat = 0xF5DEB3, // rgb(245,222,179)\n white = 0xFFFFFF, // rgb(255,255,255)\n white_smoke = 0xF5F5F5, // rgb(245,245,245)\n yellow = 0xFFFF00, // rgb(255,255,0)\n yellow_green = 0x9ACD32 // rgb(154,205,50)\n}; // enum class color\n\nenum class terminal_color : uint8_t {\n black = 30,\n red,\n green,\n yellow,\n blue,\n magenta,\n cyan,\n white,\n bright_black = 90,\n bright_red,\n bright_green,\n bright_yellow,\n bright_blue,\n bright_magenta,\n bright_cyan,\n bright_white\n};\n\nenum class emphasis : uint8_t {\n bold = 1,\n faint = 1 << 1,\n italic = 1 << 2,\n underline = 1 << 3,\n blink = 1 << 4,\n reverse = 1 << 5,\n conceal = 1 << 6,\n strikethrough = 1 << 7,\n};\n\n// rgb is a struct for red, green and blue colors.\n// Using the name \"rgb\" makes some editors show the color in a tooltip.\nstruct rgb {\n constexpr rgb() : r(0), g(0), b(0) {}\n constexpr rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}\n constexpr rgb(uint32_t hex)\n : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}\n constexpr rgb(color hex)\n : r((uint32_t(hex) >> 16) & 0xFF),\n g((uint32_t(hex) >> 8) & 0xFF),\n b(uint32_t(hex) & 0xFF) {}\n uint8_t r;\n uint8_t g;\n uint8_t b;\n};\n\nnamespace detail {\n\n// A bit-packed variant of an RGB color, a terminal color, or unset color.\n// see text_style for the bit-packing scheme.\nstruct color_type {\n constexpr color_type() noexcept = default;\n constexpr color_type(color rgb_color) noexcept\n : value_(static_cast(rgb_color) | (1 << 24)) {}\n constexpr color_type(rgb rgb_color) noexcept\n : color_type(static_cast(\n (static_cast(rgb_color.r) << 16) |\n (static_cast(rgb_color.g) << 8) | rgb_color.b)) {}\n constexpr color_type(terminal_color term_color) noexcept\n : value_(static_cast(term_color) | (3 << 24)) {}\n\n constexpr auto is_terminal_color() const noexcept -> bool {\n return (value_ & (1 << 25)) != 0;\n }\n\n constexpr auto value() const noexcept -> uint32_t {\n return value_ & 0xFFFFFF;\n }\n\n constexpr color_type(uint32_t value) noexcept : value_(value) {}\n\n uint32_t value_ = 0;\n};\n} // namespace detail\n\n/// A text style consisting of foreground and background colors and emphasis.\nclass text_style {\n // The information is packed as follows:\n // ┌──┐\n // │ 0│─┐\n // │..│ ├── foreground color value\n // │23│─┘\n // ├──┤\n // │24│─┬── discriminator for the above value. 00 if unset, 01 if it's\n // │25│─┘ an RGB color, or 11 if it's a terminal color (10 is unused)\n // ├──┤\n // │26│──── overflow bit, always zero (see below)\n // ├──┤\n // │27│─┐\n // │..│ │\n // │50│ │\n // ├──┤ │\n // │51│ ├── background color (same format as the foreground color)\n // │52│ │\n // ├──┤ │\n // │53│─┘\n // ├──┤\n // │54│─┐\n // │..│ ├── emphases\n // │61│─┘\n // ├──┤\n // │62│─┬── unused\n // │63│─┘\n // └──┘\n // The overflow bits are there to make operator|= efficient.\n // When ORing, we must throw if, for either the foreground or background,\n // one style specifies a terminal color and the other specifies any color\n // (terminal or RGB); in other words, if one discriminator is 11 and the\n // other is 11 or 01.\n //\n // We do that check by adding the styles. Consider what adding does to each\n // possible pair of discriminators:\n // 00 + 00 = 000\n // 01 + 00 = 001\n // 11 + 00 = 011\n // 01 + 01 = 010\n // 11 + 01 = 100 (!!)\n // 11 + 11 = 110 (!!)\n // In the last two cases, the ones we want to catch, the third bit——the\n // overflow bit——is set. Bingo.\n //\n // We must take into account the possible carry bit from the bits\n // before the discriminator. The only potentially problematic case is\n // 11 + 00 = 011 (a carry bit would make it 100, not good!), but a carry\n // bit is impossible in that case, because 00 (unset color) means the\n // 24 bits that precede the discriminator are all zero.\n //\n // This test can be applied to both colors simultaneously.\n\n public:\n FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept\n : style_(static_cast(em) << 54) {}\n\n FMT_CONSTEXPR auto operator|=(text_style rhs) -> text_style& {\n if (((style_ + rhs.style_) & ((1ULL << 26) | (1ULL << 53))) != 0)\n report_error(\"can't OR a terminal color\");\n style_ |= rhs.style_;\n return *this;\n }\n\n friend FMT_CONSTEXPR auto operator|(text_style lhs, text_style rhs)\n -> text_style {\n return lhs |= rhs;\n }\n\n FMT_CONSTEXPR auto operator==(text_style rhs) const noexcept -> bool {\n return style_ == rhs.style_;\n }\n\n FMT_CONSTEXPR auto operator!=(text_style rhs) const noexcept -> bool {\n return !(*this == rhs);\n }\n\n FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {\n return (style_ & (1 << 24)) != 0;\n }\n FMT_CONSTEXPR auto has_background() const noexcept -> bool {\n return (style_ & (1ULL << 51)) != 0;\n }\n FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {\n return (style_ >> 54) != 0;\n }\n FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {\n FMT_ASSERT(has_foreground(), \"no foreground specified for this style\");\n return style_ & 0x3FFFFFF;\n }\n FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {\n FMT_ASSERT(has_background(), \"no background specified for this style\");\n return (style_ >> 27) & 0x3FFFFFF;\n }\n FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {\n FMT_ASSERT(has_emphasis(), \"no emphasis specified for this style\");\n return static_cast(style_ >> 54);\n }\n\n private:\n FMT_CONSTEXPR text_style(uint64_t style) noexcept : style_(style) {}\n\n friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept\n -> text_style;\n\n friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept\n -> text_style;\n\n uint64_t style_ = 0;\n};\n\n/// Creates a text style from the foreground (text) color.\nFMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept\n -> text_style {\n return foreground.value_;\n}\n\n/// Creates a text style from the background color.\nFMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept\n -> text_style {\n return static_cast(background.value_) << 27;\n}\n\nFMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept\n -> text_style {\n return text_style(lhs) | rhs;\n}\n\nnamespace detail {\n\ntemplate struct ansi_color_escape {\n FMT_CONSTEXPR ansi_color_escape(color_type text_color,\n const char* esc) noexcept {\n // If we have a terminal color, we need to output another escape code\n // sequence.\n if (text_color.is_terminal_color()) {\n bool is_background = esc == string_view(\"\\x1b[48;2;\");\n uint32_t value = text_color.value();\n // Background ASCII codes are the same as the foreground ones but with\n // 10 more.\n if (is_background) value += 10u;\n\n buffer[size++] = static_cast('\\x1b');\n buffer[size++] = static_cast('[');\n\n if (value >= 100u) {\n buffer[size++] = static_cast('1');\n value %= 100u;\n }\n buffer[size++] = static_cast('0' + value / 10u);\n buffer[size++] = static_cast('0' + value % 10u);\n\n buffer[size++] = static_cast('m');\n return;\n }\n\n for (int i = 0; i < 7; i++) {\n buffer[i] = static_cast(esc[i]);\n }\n rgb color(text_color.value());\n to_esc(color.r, buffer + 7, ';');\n to_esc(color.g, buffer + 11, ';');\n to_esc(color.b, buffer + 15, 'm');\n size = 19;\n }\n FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {\n uint8_t em_codes[num_emphases] = {};\n if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;\n if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;\n if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;\n if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;\n if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;\n if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;\n if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;\n if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;\n\n buffer[size++] = static_cast('\\x1b');\n buffer[size++] = static_cast('[');\n\n for (size_t i = 0; i < num_emphases; ++i) {\n if (!em_codes[i]) continue;\n buffer[size++] = static_cast('0' + em_codes[i]);\n buffer[size++] = static_cast(';');\n }\n\n buffer[size - 1] = static_cast('m');\n }\n FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }\n\n FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }\n FMT_CONSTEXPR auto end() const noexcept -> const Char* {\n return buffer + size;\n }\n\n private:\n static constexpr size_t num_emphases = 8;\n Char buffer[7u + 4u * num_emphases] = {};\n size_t size = 0;\n\n static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,\n char delimiter) noexcept {\n out[0] = static_cast('0' + c / 100);\n out[1] = static_cast('0' + c / 10 % 10);\n out[2] = static_cast('0' + c % 10);\n out[3] = static_cast(delimiter);\n }\n static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept\n -> bool {\n return static_cast(em) & static_cast(mask);\n }\n};\n\ntemplate \nFMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept\n -> ansi_color_escape {\n return ansi_color_escape(foreground, \"\\x1b[38;2;\");\n}\n\ntemplate \nFMT_CONSTEXPR auto make_background_color(color_type background) noexcept\n -> ansi_color_escape {\n return ansi_color_escape(background, \"\\x1b[48;2;\");\n}\n\ntemplate \nFMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept\n -> ansi_color_escape {\n return ansi_color_escape(em);\n}\n\ntemplate inline void reset_color(buffer& buffer) {\n auto reset_color = string_view(\"\\x1b[0m\");\n buffer.append(reset_color.begin(), reset_color.end());\n}\n\ntemplate struct styled_arg : view {\n const T& value;\n text_style style;\n styled_arg(const T& v, text_style s) : value(v), style(s) {}\n};\n\ntemplate \nvoid vformat_to(buffer& buf, text_style ts, basic_string_view fmt,\n basic_format_args> args) {\n if (ts.has_emphasis()) {\n auto emphasis = make_emphasis(ts.get_emphasis());\n buf.append(emphasis.begin(), emphasis.end());\n }\n if (ts.has_foreground()) {\n auto foreground = make_foreground_color(ts.get_foreground());\n buf.append(foreground.begin(), foreground.end());\n }\n if (ts.has_background()) {\n auto background = make_background_color(ts.get_background());\n buf.append(background.begin(), background.end());\n }\n vformat_to(buf, fmt, args);\n if (ts != text_style()) reset_color(buf);\n}\n} // namespace detail\n\ninline void vprint(FILE* f, text_style ts, string_view fmt, format_args args) {\n auto buf = memory_buffer();\n detail::vformat_to(buf, ts, fmt, args);\n print(f, FMT_STRING(\"{}\"), string_view(buf.begin(), buf.size()));\n}\n\n/**\n * Formats a string and prints it to the specified file stream using ANSI\n * escape sequences to specify text formatting.\n *\n * **Example**:\n *\n * fmt::print(fmt::emphasis::bold | fg(fmt::color::red),\n * \"Elapsed time: {0:.2f} seconds\", 1.23);\n */\ntemplate \nvoid print(FILE* f, text_style ts, format_string fmt, T&&... args) {\n vprint(f, ts, fmt.str, vargs{{args...}});\n}\n\n/**\n * Formats a string and prints it to stdout using ANSI escape sequences to\n * specify text formatting.\n *\n * **Example**:\n *\n * fmt::print(fmt::emphasis::bold | fg(fmt::color::red),\n * \"Elapsed time: {0:.2f} seconds\", 1.23);\n */\ntemplate \nvoid print(text_style ts, format_string fmt, T&&... args) {\n return print(stdout, ts, fmt, std::forward(args)...);\n}\n\ninline auto vformat(text_style ts, string_view fmt, format_args args)\n -> std::string {\n auto buf = memory_buffer();\n detail::vformat_to(buf, ts, fmt, args);\n return fmt::to_string(buf);\n}\n\n/**\n * Formats arguments and returns the result as a string using ANSI escape\n * sequences to specify text formatting.\n *\n * **Example**:\n *\n * ```\n * #include \n * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),\n * \"The answer is {}\", 42);\n * ```\n */\ntemplate \ninline auto format(text_style ts, format_string fmt, T&&... args)\n -> std::string {\n return fmt::vformat(ts, fmt.str, vargs{{args...}});\n}\n\n/// Formats a string with the given text_style and writes the output to `out`.\ntemplate ::value)>\nauto vformat_to(OutputIt out, text_style ts, string_view fmt, format_args args)\n -> OutputIt {\n auto&& buf = detail::get_buffer(out);\n detail::vformat_to(buf, ts, fmt, args);\n return detail::get_iterator(buf, out);\n}\n\n/**\n * Formats arguments with the given text style, writes the result to the output\n * iterator `out` and returns the iterator past the end of the output range.\n *\n * **Example**:\n *\n * std::vector out;\n * fmt::format_to(std::back_inserter(out),\n * fmt::emphasis::bold | fg(fmt::color::red), \"{}\", 42);\n */\ntemplate ::value)>\ninline auto format_to(OutputIt out, text_style ts, format_string fmt,\n T&&... args) -> OutputIt {\n return vformat_to(out, ts, fmt.str, vargs{{args...}});\n}\n\ntemplate \nstruct formatter, Char> : formatter {\n template \n auto format(const detail::styled_arg& arg, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n const auto& ts = arg.style;\n auto out = ctx.out();\n\n bool has_style = false;\n if (ts.has_emphasis()) {\n has_style = true;\n auto emphasis = detail::make_emphasis(ts.get_emphasis());\n out = detail::copy(emphasis.begin(), emphasis.end(), out);\n }\n if (ts.has_foreground()) {\n has_style = true;\n auto foreground =\n detail::make_foreground_color(ts.get_foreground());\n out = detail::copy(foreground.begin(), foreground.end(), out);\n }\n if (ts.has_background()) {\n has_style = true;\n auto background =\n detail::make_background_color(ts.get_background());\n out = detail::copy(background.begin(), background.end(), out);\n }\n out = formatter::format(arg.value, ctx);\n if (has_style) {\n auto reset_color = string_view(\"\\x1b[0m\");\n out = detail::copy(reset_color.begin(), reset_color.end(), out);\n }\n return out;\n }\n};\n\n/**\n * Returns an argument that will be formatted using ANSI escape sequences,\n * to be used in a formatting function.\n *\n * **Example**:\n *\n * fmt::print(\"Elapsed time: {0:.2f} seconds\",\n * fmt::styled(1.23, fmt::fg(fmt::color::green) |\n * fmt::bg(fmt::color::blue)));\n */\ntemplate \nFMT_CONSTEXPR auto styled(const T& value, text_style ts)\n -> detail::styled_arg> {\n return detail::styled_arg>{value, ts};\n}\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_COLOR_H_\n" }, { "path": "include/spdlog/fmt/bundled/compile.h", "content": "// Formatting library for C++ - experimental format string compilation\n//\n// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_COMPILE_H_\n#define FMT_COMPILE_H_\n\n#ifndef FMT_MODULE\n# include // std::back_inserter\n#endif\n\n#include \"format.h\"\n\nFMT_BEGIN_NAMESPACE\nFMT_BEGIN_EXPORT\n\n// A compile-time string which is compiled into fast formatting code.\nclass compiled_string {};\n\ntemplate \nstruct is_compiled_string : std::is_base_of {};\n\n/**\n * Converts a string literal `s` into a format string that will be parsed at\n * compile time and converted into efficient formatting code. Requires C++17\n * `constexpr if` compiler support.\n *\n * **Example**:\n *\n * // Converts 42 into std::string using the most efficient method and no\n * // runtime format string processing.\n * std::string s = fmt::format(FMT_COMPILE(\"{}\"), 42);\n */\n#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)\n# define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)\n#else\n# define FMT_COMPILE(s) FMT_STRING(s)\n#endif\n\n/**\n * Converts a string literal into a format string that will be parsed at\n * compile time and converted into efficient formatting code. Requires support\n * for class types in constant template parameters (a C++20 feature).\n *\n * **Example**:\n *\n * // Converts 42 into std::string using the most efficient method and no\n * // runtime format string processing.\n * using namespace fmt::literals;\n * std::string s = fmt::format(\"{}\"_cf, 42);\n */\n#if FMT_USE_NONTYPE_TEMPLATE_ARGS\ninline namespace literals {\ntemplate constexpr auto operator\"\"_cf() {\n return FMT_COMPILE(Str.data);\n}\n} // namespace literals\n#endif\n\nFMT_END_EXPORT\n\nnamespace detail {\n\ntemplate \nconstexpr auto first(const T& value, const Tail&...) -> const T& {\n return value;\n}\n\n#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)\ntemplate struct type_list {};\n\n// Returns a reference to the argument at index N from [first, rest...].\ntemplate \nconstexpr auto get([[maybe_unused]] const T& first,\n [[maybe_unused]] const Args&... rest) -> const auto& {\n static_assert(N < 1 + sizeof...(Args), \"index is out of bounds\");\n if constexpr (N == 0)\n return first;\n else\n return detail::get(rest...);\n}\n\n# if FMT_USE_NONTYPE_TEMPLATE_ARGS\ntemplate \nconstexpr auto get_arg_index_by_name(basic_string_view name) -> int {\n if constexpr (is_static_named_arg()) {\n if (name == T::name) return N;\n }\n if constexpr (sizeof...(Args) > 0)\n return get_arg_index_by_name(name);\n (void)name; // Workaround an MSVC bug about \"unused\" parameter.\n return -1;\n}\n# endif\n\ntemplate \nFMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int {\n# if FMT_USE_NONTYPE_TEMPLATE_ARGS\n if constexpr (sizeof...(Args) > 0)\n return get_arg_index_by_name<0, Args...>(name);\n# endif\n (void)name;\n return -1;\n}\n\ntemplate \nconstexpr auto get_arg_index_by_name(basic_string_view name,\n type_list) -> int {\n return get_arg_index_by_name(name);\n}\n\ntemplate struct get_type_impl;\n\ntemplate struct get_type_impl> {\n using type =\n remove_cvref_t(std::declval()...))>;\n};\n\ntemplate \nusing get_type = typename get_type_impl::type;\n\ntemplate struct is_compiled_format : std::false_type {};\n\ntemplate struct text {\n basic_string_view data;\n using char_type = Char;\n\n template \n constexpr auto format(OutputIt out, const T&...) const -> OutputIt {\n return write(out, data);\n }\n};\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\ntemplate \nconstexpr auto make_text(basic_string_view s, size_t pos, size_t size)\n -> text {\n return {{&s[pos], size}};\n}\n\ntemplate struct code_unit {\n Char value;\n using char_type = Char;\n\n template \n constexpr auto format(OutputIt out, const T&...) const -> OutputIt {\n *out++ = value;\n return out;\n }\n};\n\n// This ensures that the argument type is convertible to `const T&`.\ntemplate \nconstexpr auto get_arg_checked(const Args&... args) -> const T& {\n const auto& arg = detail::get(args...);\n if constexpr (detail::is_named_arg>()) {\n return arg.value;\n } else {\n return arg;\n }\n}\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\n// A replacement field that refers to argument N.\ntemplate struct field {\n using char_type = Char;\n\n template \n constexpr auto format(OutputIt out, const T&... args) const -> OutputIt {\n const V& arg = get_arg_checked(args...);\n if constexpr (std::is_convertible>::value) {\n auto s = basic_string_view(arg);\n return copy(s.begin(), s.end(), out);\n } else {\n return write(out, arg);\n }\n }\n};\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\n// A replacement field that refers to argument with name.\ntemplate struct runtime_named_field {\n using char_type = Char;\n basic_string_view name;\n\n template \n constexpr static auto try_format_argument(\n OutputIt& out,\n // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9\n [[maybe_unused]] basic_string_view arg_name, const T& arg) -> bool {\n if constexpr (is_named_arg::type>::value) {\n if (arg_name == arg.name) {\n out = write(out, arg.value);\n return true;\n }\n }\n return false;\n }\n\n template \n constexpr auto format(OutputIt out, const T&... args) const -> OutputIt {\n bool found = (try_format_argument(out, name, args) || ...);\n if (!found) {\n FMT_THROW(format_error(\"argument with specified name is not found\"));\n }\n return out;\n }\n};\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\n// A replacement field that refers to argument N and has format specifiers.\ntemplate struct spec_field {\n using char_type = Char;\n formatter fmt;\n\n template \n constexpr FMT_INLINE auto format(OutputIt out, const T&... args) const\n -> OutputIt {\n const auto& vargs =\n fmt::make_format_args>(args...);\n basic_format_context ctx(out, vargs);\n return fmt.format(get_arg_checked(args...), ctx);\n }\n};\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\ntemplate struct concat {\n L lhs;\n R rhs;\n using char_type = typename L::char_type;\n\n template \n constexpr auto format(OutputIt out, const T&... args) const -> OutputIt {\n out = lhs.format(out, args...);\n return rhs.format(out, args...);\n }\n};\n\ntemplate \nstruct is_compiled_format> : std::true_type {};\n\ntemplate \nconstexpr auto make_concat(L lhs, R rhs) -> concat {\n return {lhs, rhs};\n}\n\nstruct unknown_format {};\n\ntemplate \nconstexpr auto parse_text(basic_string_view str, size_t pos) -> size_t {\n for (size_t size = str.size(); pos != size; ++pos) {\n if (str[pos] == '{' || str[pos] == '}') break;\n }\n return pos;\n}\n\ntemplate \nconstexpr auto compile_format_string(S fmt);\n\ntemplate \nconstexpr auto parse_tail(T head, S fmt) {\n if constexpr (POS != basic_string_view(fmt).size()) {\n constexpr auto tail = compile_format_string(fmt);\n if constexpr (std::is_same,\n unknown_format>())\n return tail;\n else\n return make_concat(head, tail);\n } else {\n return head;\n }\n}\n\ntemplate struct parse_specs_result {\n formatter fmt;\n size_t end;\n int next_arg_id;\n};\n\nenum { manual_indexing_id = -1 };\n\ntemplate \nconstexpr auto parse_specs(basic_string_view str, size_t pos,\n int next_arg_id) -> parse_specs_result {\n str.remove_prefix(pos);\n auto ctx =\n compile_parse_context(str, max_value(), nullptr, next_arg_id);\n auto f = formatter();\n auto end = f.parse(ctx);\n return {f, pos + fmt::detail::to_unsigned(end - str.data()),\n next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};\n}\n\ntemplate struct arg_id_handler {\n arg_id_kind kind;\n arg_ref arg_id;\n\n constexpr auto on_auto() -> int {\n FMT_ASSERT(false, \"handler cannot be used with automatic indexing\");\n return 0;\n }\n constexpr auto on_index(int id) -> int {\n kind = arg_id_kind::index;\n arg_id = arg_ref(id);\n return 0;\n }\n constexpr auto on_name(basic_string_view id) -> int {\n kind = arg_id_kind::name;\n arg_id = arg_ref(id);\n return 0;\n }\n};\n\ntemplate struct parse_arg_id_result {\n arg_id_kind kind;\n arg_ref arg_id;\n const Char* arg_id_end;\n};\n\ntemplate \nconstexpr auto parse_arg_id(const Char* begin, const Char* end) {\n auto handler = arg_id_handler{arg_id_kind::none, arg_ref{}};\n auto arg_id_end = parse_arg_id(begin, end, handler);\n return parse_arg_id_result{handler.kind, handler.arg_id, arg_id_end};\n}\n\ntemplate struct field_type {\n using type = remove_cvref_t;\n};\n\ntemplate \nstruct field_type::value>> {\n using type = remove_cvref_t;\n};\n\ntemplate \nconstexpr auto parse_replacement_field_then_tail(S fmt) {\n using char_type = typename S::char_type;\n constexpr auto str = basic_string_view(fmt);\n constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();\n if constexpr (c == '}') {\n return parse_tail(\n field::type, ARG_INDEX>(), fmt);\n } else if constexpr (c != ':') {\n FMT_THROW(format_error(\"expected ':'\"));\n } else {\n constexpr auto result = parse_specs::type>(\n str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);\n if constexpr (result.end >= str.size() || str[result.end] != '}') {\n FMT_THROW(format_error(\"expected '}'\"));\n return 0;\n } else {\n return parse_tail(\n spec_field::type, ARG_INDEX>{\n result.fmt},\n fmt);\n }\n }\n}\n\n// Compiles a non-empty format string and returns the compiled representation\n// or unknown_format() on unrecognized input.\ntemplate \nconstexpr auto compile_format_string(S fmt) {\n using char_type = typename S::char_type;\n constexpr auto str = basic_string_view(fmt);\n if constexpr (str[POS] == '{') {\n if constexpr (POS + 1 == str.size())\n FMT_THROW(format_error(\"unmatched '{' in format string\"));\n if constexpr (str[POS + 1] == '{') {\n return parse_tail(make_text(str, POS, 1), fmt);\n } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {\n static_assert(ID != manual_indexing_id,\n \"cannot switch from manual to automatic argument indexing\");\n constexpr auto next_id =\n ID != manual_indexing_id ? ID + 1 : manual_indexing_id;\n return parse_replacement_field_then_tail, Args,\n POS + 1, ID, next_id>(fmt);\n } else {\n constexpr auto arg_id_result =\n parse_arg_id(str.data() + POS + 1, str.data() + str.size());\n constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();\n constexpr char_type c =\n arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();\n static_assert(c == '}' || c == ':', \"missing '}' in format string\");\n if constexpr (arg_id_result.kind == arg_id_kind::index) {\n static_assert(\n ID == manual_indexing_id || ID == 0,\n \"cannot switch from automatic to manual argument indexing\");\n constexpr auto arg_index = arg_id_result.arg_id.index;\n return parse_replacement_field_then_tail,\n Args, arg_id_end_pos,\n arg_index, manual_indexing_id>(\n fmt);\n } else if constexpr (arg_id_result.kind == arg_id_kind::name) {\n constexpr auto arg_index =\n get_arg_index_by_name(arg_id_result.arg_id.name, Args{});\n if constexpr (arg_index >= 0) {\n constexpr auto next_id =\n ID != manual_indexing_id ? ID + 1 : manual_indexing_id;\n return parse_replacement_field_then_tail<\n decltype(get_type::value), Args, arg_id_end_pos,\n arg_index, next_id>(fmt);\n } else if constexpr (c == '}') {\n return parse_tail(\n runtime_named_field{arg_id_result.arg_id.name}, fmt);\n } else if constexpr (c == ':') {\n return unknown_format(); // no type info for specs parsing\n }\n }\n }\n } else if constexpr (str[POS] == '}') {\n if constexpr (POS + 1 == str.size())\n FMT_THROW(format_error(\"unmatched '}' in format string\"));\n return parse_tail(make_text(str, POS, 1), fmt);\n } else {\n constexpr auto end = parse_text(str, POS + 1);\n if constexpr (end - POS > 1) {\n return parse_tail(make_text(str, POS, end - POS), fmt);\n } else {\n return parse_tail(code_unit{str[POS]}, fmt);\n }\n }\n}\n\ntemplate ::value)>\nconstexpr auto compile(S fmt) {\n constexpr auto str = basic_string_view(fmt);\n if constexpr (str.size() == 0) {\n return detail::make_text(str, 0, 0);\n } else {\n constexpr auto result =\n detail::compile_format_string, 0, 0>(fmt);\n return result;\n }\n}\n#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)\n} // namespace detail\n\nFMT_BEGIN_EXPORT\n\n#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)\n\ntemplate ::value)>\nFMT_INLINE FMT_CONSTEXPR_STRING auto format(const CompiledFormat& cf,\n const T&... args)\n -> std::basic_string {\n auto s = std::basic_string();\n cf.format(std::back_inserter(s), args...);\n return s;\n}\n\ntemplate ::value)>\nconstexpr FMT_INLINE auto format_to(OutputIt out, const CompiledFormat& cf,\n const T&... args) -> OutputIt {\n return cf.format(out, args...);\n}\n\ntemplate ::value)>\nFMT_INLINE FMT_CONSTEXPR_STRING auto format(const S&, T&&... args)\n -> std::basic_string {\n if constexpr (std::is_same::value) {\n constexpr auto str = basic_string_view(S());\n if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {\n const auto& first = detail::first(args...);\n if constexpr (detail::is_named_arg<\n remove_cvref_t>::value) {\n return fmt::to_string(first.value);\n } else {\n return fmt::to_string(first);\n }\n }\n }\n constexpr auto compiled = detail::compile(S());\n if constexpr (std::is_same,\n detail::unknown_format>()) {\n return fmt::format(\n static_cast>(S()),\n std::forward(args)...);\n } else {\n return fmt::format(compiled, std::forward(args)...);\n }\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR auto format_to(OutputIt out, const S&, T&&... args) -> OutputIt {\n constexpr auto compiled = detail::compile(S());\n if constexpr (std::is_same,\n detail::unknown_format>()) {\n return fmt::format_to(\n out, static_cast>(S()),\n std::forward(args)...);\n } else {\n return fmt::format_to(out, compiled, std::forward(args)...);\n }\n}\n#endif\n\ntemplate ::value)>\nauto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)\n -> format_to_n_result {\n using traits = detail::fixed_buffer_traits;\n auto buf = detail::iterator_buffer(out, n);\n fmt::format_to(std::back_inserter(buf), fmt, std::forward(args)...);\n return {buf.out(), buf.count()};\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR20 auto formatted_size(const S& fmt, T&&... args) -> size_t {\n auto buf = detail::counting_buffer<>();\n fmt::format_to(appender(buf), fmt, std::forward(args)...);\n return buf.count();\n}\n\ntemplate ::value)>\nvoid print(std::FILE* f, const S& fmt, T&&... args) {\n auto buf = memory_buffer();\n fmt::format_to(appender(buf), fmt, std::forward(args)...);\n detail::print(f, {buf.data(), buf.size()});\n}\n\ntemplate ::value)>\nvoid print(const S& fmt, T&&... args) {\n print(stdout, fmt, std::forward(args)...);\n}\n\ntemplate class static_format_result {\n private:\n char data[N];\n\n public:\n template ::value)>\n explicit FMT_CONSTEXPR static_format_result(const S& fmt, T&&... args) {\n *fmt::format_to(data, fmt, std::forward(args)...) = '\\0';\n }\n\n auto str() const -> fmt::string_view { return {data, N - 1}; }\n auto c_str() const -> const char* { return data; }\n};\n\n/**\n * Formats arguments according to the format string `fmt_str` and produces\n * a string of the exact required size at compile time. Both the format string\n * and the arguments must be compile-time expressions.\n *\n * The resulting string can be accessed as a C string via `c_str()` or as\n * a `fmt::string_view` via `str()`.\n *\n * **Example**:\n *\n * // Produces the static string \"42\" at compile time.\n * static constexpr auto result = FMT_STATIC_FORMAT(\"{}\", 42);\n * const char* s = result.c_str();\n */\n#define FMT_STATIC_FORMAT(fmt_str, ...) \\\n fmt::static_format_result< \\\n fmt::formatted_size(FMT_COMPILE(fmt_str), __VA_ARGS__) + 1>( \\\n FMT_COMPILE(fmt_str), __VA_ARGS__)\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_COMPILE_H_\n" }, { "path": "include/spdlog/fmt/bundled/core.h", "content": "// This file is only provided for compatibility and may be removed in future\n// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h\n// otherwise.\n\n#include \"format.h\"\n" }, { "path": "include/spdlog/fmt/bundled/fmt.license.rst", "content": "Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n--- Optional exception to the license ---\n\nAs an exception, if, as a result of your compiling your source code, portions\nof this Software are embedded into a machine-executable object form of such\nsource code, you may redistribute such embedded portions in such object form\nwithout including the above copyright and permission notices.\n" }, { "path": "include/spdlog/fmt/bundled/format-inl.h", "content": "// Formatting library for C++ - implementation\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_FORMAT_INL_H_\n#define FMT_FORMAT_INL_H_\n\n#ifndef FMT_MODULE\n# include \n# include // errno\n# include \n# include \n# include \n#endif\n\n#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)\n# include // _isatty\n#endif\n\n#include \"format.h\"\n\n#if FMT_USE_LOCALE && !defined(FMT_MODULE)\n# include \n#endif\n\n#ifndef FMT_FUNC\n# define FMT_FUNC\n#endif\n\nFMT_BEGIN_NAMESPACE\n\n#ifndef FMT_CUSTOM_ASSERT_FAIL\nFMT_FUNC void assert_fail(const char* file, int line, const char* message) {\n // Use unchecked std::fprintf to avoid triggering another assertion when\n // writing to stderr fails.\n std::fprintf(stderr, \"%s:%d: assertion failed: %s\", file, line, message);\n abort();\n}\n#endif\n\n#if FMT_USE_LOCALE\nnamespace detail {\nusing std::locale;\nusing std::numpunct;\nusing std::use_facet;\n} // namespace detail\n#else\nnamespace detail {\nstruct locale {};\ntemplate struct numpunct {\n auto grouping() const -> std::string { return \"\\03\"; }\n auto thousands_sep() const -> Char { return ','; }\n auto decimal_point() const -> Char { return '.'; }\n};\ntemplate Facet use_facet(locale) { return {}; }\n} // namespace detail\n#endif // FMT_USE_LOCALE\n\ntemplate auto locale_ref::get() const -> Locale {\n using namespace detail;\n static_assert(std::is_same::value, \"\");\n#if FMT_USE_LOCALE\n if (locale_) return *static_cast(locale_);\n#endif\n return locale();\n}\n\nnamespace detail {\n\nFMT_FUNC void format_error_code(detail::buffer& out, int error_code,\n string_view message) noexcept {\n // Report error code making sure that the output fits into\n // inline_buffer_size to avoid dynamic memory allocation and potential\n // bad_alloc.\n out.try_resize(0);\n static const char SEP[] = \": \";\n static const char ERROR_STR[] = \"error \";\n // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.\n size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;\n auto abs_value = static_cast>(error_code);\n if (detail::is_negative(error_code)) {\n abs_value = 0 - abs_value;\n ++error_code_size;\n }\n error_code_size += detail::to_unsigned(detail::count_digits(abs_value));\n auto it = appender(out);\n if (message.size() <= inline_buffer_size - error_code_size)\n fmt::format_to(it, FMT_STRING(\"{}{}\"), message, SEP);\n fmt::format_to(it, FMT_STRING(\"{}{}\"), ERROR_STR, error_code);\n FMT_ASSERT(out.size() <= inline_buffer_size, \"\");\n}\n\nFMT_FUNC void do_report_error(format_func func, int error_code,\n const char* message) noexcept {\n memory_buffer full_message;\n func(full_message, error_code, message);\n // Don't use fwrite_all because the latter may throw.\n if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)\n std::fputc('\\n', stderr);\n}\n\n// A wrapper around fwrite that throws on error.\ninline void fwrite_all(const void* ptr, size_t count, FILE* stream) {\n size_t written = std::fwrite(ptr, 1, count, stream);\n if (written < count)\n FMT_THROW(system_error(errno, FMT_STRING(\"cannot write to file\")));\n}\n\ntemplate \nFMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result {\n auto&& facet = use_facet>(loc.get());\n auto grouping = facet.grouping();\n auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();\n return {std::move(grouping), thousands_sep};\n}\ntemplate \nFMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {\n return use_facet>(loc.get()).decimal_point();\n}\n\n#if FMT_USE_LOCALE\nFMT_FUNC auto write_loc(appender out, loc_value value,\n const format_specs& specs, locale_ref loc) -> bool {\n auto locale = loc.get();\n // We cannot use the num_put facet because it may produce output in\n // a wrong encoding.\n using facet = format_facet;\n if (std::has_facet(locale))\n return use_facet(locale).put(out, value, specs);\n return facet(locale).put(out, value, specs);\n}\n#endif\n} // namespace detail\n\nFMT_FUNC void report_error(const char* message) {\n#if FMT_MSC_VERSION || defined(__NVCC__)\n // Silence unreachable code warnings in MSVC and NVCC because these\n // are nearly impossible to fix in a generic code.\n volatile bool b = true;\n if (!b) return;\n#endif\n FMT_THROW(format_error(message));\n}\n\ntemplate typename Locale::id format_facet::id;\n\ntemplate format_facet::format_facet(Locale& loc) {\n auto& np = detail::use_facet>(loc);\n grouping_ = np.grouping();\n if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep());\n}\n\n#if FMT_USE_LOCALE\ntemplate <>\nFMT_API FMT_FUNC auto format_facet::do_put(\n appender out, loc_value val, const format_specs& specs) const -> bool {\n return val.visit(\n detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});\n}\n#endif\n\nFMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)\n -> std::system_error {\n auto ec = std::error_code(error_code, std::generic_category());\n return std::system_error(ec, vformat(fmt, args));\n}\n\nnamespace detail {\n\ntemplate \ninline auto operator==(basic_fp x, basic_fp y) -> bool {\n return x.f == y.f && x.e == y.e;\n}\n\n// Compilers should be able to optimize this into the ror instruction.\nFMT_INLINE auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {\n r &= 31;\n return (n >> r) | (n << (32 - r));\n}\nFMT_INLINE auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {\n r &= 63;\n return (n >> r) | (n << (64 - r));\n}\n\n// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.\nnamespace dragonbox {\n// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a\n// 64-bit unsigned integer.\ninline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {\n return umul128_upper64(static_cast(x) << 32, y);\n}\n\n// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a\n// 128-bit unsigned integer.\ninline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept\n -> uint128_fallback {\n uint64_t high = x * y.high();\n uint128_fallback high_low = umul128(x, y.low());\n return {high + high_low.high(), high_low.low()};\n}\n\n// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a\n// 64-bit unsigned integer.\ninline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {\n return x * y;\n}\n\n// Various fast log computations.\ninline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {\n FMT_ASSERT(e <= 2936 && e >= -2985, \"too large exponent\");\n return (e * 631305 - 261663) >> 21;\n}\n\nFMT_INLINE_VARIABLE constexpr struct div_small_pow10_infos_struct {\n uint32_t divisor;\n int shift_amount;\n} div_small_pow10_infos[] = {{10, 16}, {100, 16}};\n\n// Replaces n by floor(n / pow(10, N)) returning true if and only if n is\n// divisible by pow(10, N).\n// Precondition: n <= pow(10, N + 1).\ntemplate \nauto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {\n // The numbers below are chosen such that:\n // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,\n // 2. nm mod 2^k < m if and only if n is divisible by d,\n // where m is magic_number, k is shift_amount\n // and d is divisor.\n //\n // Item 1 is a common technique of replacing division by a constant with\n // multiplication, see e.g. \"Division by Invariant Integers Using\n // Multiplication\" by Granlund and Montgomery (1994). magic_number (m) is set\n // to ceil(2^k/d) for large enough k.\n // The idea for item 2 originates from Schubfach.\n constexpr auto info = div_small_pow10_infos[N - 1];\n FMT_ASSERT(n <= info.divisor * 10, \"n is too large\");\n constexpr uint32_t magic_number =\n (1u << info.shift_amount) / info.divisor + 1;\n n *= magic_number;\n const uint32_t comparison_mask = (1u << info.shift_amount) - 1;\n bool result = (n & comparison_mask) < magic_number;\n n >>= info.shift_amount;\n return result;\n}\n\n// Computes floor(n / pow(10, N)) for small n and N.\n// Precondition: n <= pow(10, N + 1).\ntemplate auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {\n constexpr auto info = div_small_pow10_infos[N - 1];\n FMT_ASSERT(n <= info.divisor * 10, \"n is too large\");\n constexpr uint32_t magic_number =\n (1u << info.shift_amount) / info.divisor + 1;\n return (n * magic_number) >> info.shift_amount;\n}\n\n// Computes floor(n / 10^(kappa + 1)) (float)\ninline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {\n // 1374389535 = ceil(2^37/100)\n return static_cast((static_cast(n) * 1374389535) >> 37);\n}\n// Computes floor(n / 10^(kappa + 1)) (double)\ninline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {\n // 2361183241434822607 = ceil(2^(64+7)/1000)\n return umul128_upper64(n, 2361183241434822607ull) >> 7;\n}\n\n// Various subroutines using pow10 cache\ntemplate struct cache_accessor;\n\ntemplate <> struct cache_accessor {\n using carrier_uint = float_info::carrier_uint;\n using cache_entry_type = uint64_t;\n\n static auto get_cached_power(int k) noexcept -> uint64_t {\n FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k,\n \"k is out of range\");\n static constexpr uint64_t pow10_significands[] = {\n 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,\n 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,\n 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,\n 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,\n 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,\n 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,\n 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,\n 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,\n 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,\n 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,\n 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,\n 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,\n 0xc350000000000000, 0xf424000000000000, 0x9896800000000000,\n 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,\n 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,\n 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,\n 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,\n 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,\n 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,\n 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985,\n 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,\n 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7,\n 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,\n 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe,\n 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,\n 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};\n return pow10_significands[k - float_info::min_k];\n }\n\n struct compute_mul_result {\n carrier_uint result;\n bool is_integer;\n };\n struct compute_mul_parity_result {\n bool parity;\n bool is_integer;\n };\n\n static auto compute_mul(carrier_uint u,\n const cache_entry_type& cache) noexcept\n -> compute_mul_result {\n auto r = umul96_upper64(u, cache);\n return {static_cast(r >> 32),\n static_cast(r) == 0};\n }\n\n static auto compute_delta(const cache_entry_type& cache, int beta) noexcept\n -> uint32_t {\n return static_cast(cache >> (64 - 1 - beta));\n }\n\n static auto compute_mul_parity(carrier_uint two_f,\n const cache_entry_type& cache,\n int beta) noexcept\n -> compute_mul_parity_result {\n FMT_ASSERT(beta >= 1, \"\");\n FMT_ASSERT(beta < 64, \"\");\n\n auto r = umul96_lower64(two_f, cache);\n return {((r >> (64 - beta)) & 1) != 0,\n static_cast(r >> (32 - beta)) == 0};\n }\n\n static auto compute_left_endpoint_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return static_cast(\n (cache - (cache >> (num_significand_bits() + 2))) >>\n (64 - num_significand_bits() - 1 - beta));\n }\n\n static auto compute_right_endpoint_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return static_cast(\n (cache + (cache >> (num_significand_bits() + 1))) >>\n (64 - num_significand_bits() - 1 - beta));\n }\n\n static auto compute_round_up_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return (static_cast(\n cache >> (64 - num_significand_bits() - 2 - beta)) +\n 1) /\n 2;\n }\n};\n\ntemplate <> struct cache_accessor {\n using carrier_uint = float_info::carrier_uint;\n using cache_entry_type = uint128_fallback;\n\n static auto get_cached_power(int k) noexcept -> uint128_fallback {\n FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k,\n \"k is out of range\");\n\n static constexpr uint128_fallback pow10_significands[] = {\n#if FMT_USE_FULL_CACHE_DRAGONBOX\n {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},\n {0x9faacf3df73609b1, 0x77b191618c54e9ad},\n {0xc795830d75038c1d, 0xd59df5b9ef6a2418},\n {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},\n {0x9becce62836ac577, 0x4ee367f9430aec33},\n {0xc2e801fb244576d5, 0x229c41f793cda740},\n {0xf3a20279ed56d48a, 0x6b43527578c11110},\n {0x9845418c345644d6, 0x830a13896b78aaaa},\n {0xbe5691ef416bd60c, 0x23cc986bc656d554},\n {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},\n {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},\n {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},\n {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},\n {0x91376c36d99995be, 0x23100809b9c21fa2},\n {0xb58547448ffffb2d, 0xabd40a0c2832a78b},\n {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},\n {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},\n {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},\n {0xdd95317f31c7fa1d, 0x40405643d711d584},\n {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},\n {0xad1c8eab5ee43b66, 0xda3243650005eed0},\n {0xd863b256369d4a40, 0x90bed43e40076a83},\n {0x873e4f75e2224e68, 0x5a7744a6e804a292},\n {0xa90de3535aaae202, 0x711515d0a205cb37},\n {0xd3515c2831559a83, 0x0d5a5b44ca873e04},\n {0x8412d9991ed58091, 0xe858790afe9486c3},\n {0xa5178fff668ae0b6, 0x626e974dbe39a873},\n {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},\n {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},\n {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},\n {0xc987434744ac874e, 0xa327ffb266b56221},\n {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},\n {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},\n {0xc4ce17b399107c22, 0xcb550fb4384d21d4},\n {0xf6019da07f549b2b, 0x7e2a53a146606a49},\n {0x99c102844f94e0fb, 0x2eda7444cbfc426e},\n {0xc0314325637a1939, 0xfa911155fefb5309},\n {0xf03d93eebc589f88, 0x793555ab7eba27cb},\n {0x96267c7535b763b5, 0x4bc1558b2f3458df},\n {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},\n {0xea9c227723ee8bcb, 0x465e15a979c1cadd},\n {0x92a1958a7675175f, 0x0bfacd89ec191eca},\n {0xb749faed14125d36, 0xcef980ec671f667c},\n {0xe51c79a85916f484, 0x82b7e12780e7401b},\n {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},\n {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},\n {0xdfbdcece67006ac9, 0x67a791e093e1d49b},\n {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},\n {0xaecc49914078536d, 0x58fae9f773886e19},\n {0xda7f5bf590966848, 0xaf39a475506a899f},\n {0x888f99797a5e012d, 0x6d8406c952429604},\n {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},\n {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},\n {0x855c3be0a17fcd26, 0x5cf2eea09a550680},\n {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},\n {0xd0601d8efc57b08b, 0xf13b94daf124da27},\n {0x823c12795db6ce57, 0x76c53d08d6b70859},\n {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},\n {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},\n {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},\n {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},\n {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},\n {0xf867241c8cc6d4c0, 0xc30163d203c94b63},\n {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},\n {0xc21094364dfb5636, 0x985915fc12f542e5},\n {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},\n {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},\n {0xbd8430bd08277231, 0x50c6ff782a838354},\n {0xece53cec4a314ebd, 0xa4f8bf5635246429},\n {0x940f4613ae5ed136, 0x871b7795e136be9a},\n {0xb913179899f68584, 0x28e2557b59846e40},\n {0xe757dd7ec07426e5, 0x331aeada2fe589d0},\n {0x9096ea6f3848984f, 0x3ff0d2c85def7622},\n {0xb4bca50b065abe63, 0x0fed077a756b53aa},\n {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},\n {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},\n {0xb080392cc4349dec, 0xbd8d794d96aacfb4},\n {0xdca04777f541c567, 0xecf0d7a0fc5583a1},\n {0x89e42caaf9491b60, 0xf41686c49db57245},\n {0xac5d37d5b79b6239, 0x311c2875c522ced6},\n {0xd77485cb25823ac7, 0x7d633293366b828c},\n {0x86a8d39ef77164bc, 0xae5dff9c02033198},\n {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},\n {0xd267caa862a12d66, 0xd072df63c324fd7c},\n {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},\n {0xa46116538d0deb78, 0x52d9be85f074e609},\n {0xcd795be870516656, 0x67902e276c921f8c},\n {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},\n {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},\n {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},\n {0xfad2a4b13d1b5d6c, 0x796b805720085f82},\n {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},\n {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},\n {0xf4f1b4d515acb93b, 0xee92fb5515482d45},\n {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},\n {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},\n {0xef340a98172aace4, 0x86fb897116c87c35},\n {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},\n {0xbae0a846d2195712, 0x8974836059cca10a},\n {0xe998d258869facd7, 0x2bd1a438703fc94c},\n {0x91ff83775423cc06, 0x7b6306a34627ddd0},\n {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},\n {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},\n {0x8e938662882af53e, 0x547eb47b7282ee9d},\n {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},\n {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},\n {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},\n {0xae0b158b4738705e, 0x9624ab50b148d446},\n {0xd98ddaee19068c76, 0x3badd624dd9b0958},\n {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},\n {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},\n {0xd47487cc8470652b, 0x7647c32000696720},\n {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},\n {0xa5fb0a17c777cf09, 0xf468107100525891},\n {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},\n {0x81ac1fe293d599bf, 0xc6f14cd848405531},\n {0xa21727db38cb002f, 0xb8ada00e5a506a7d},\n {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},\n {0xfd442e4688bd304a, 0x908f4a166d1da664},\n {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},\n {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},\n {0xf7549530e188c128, 0xd12bee59e68ef47d},\n {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},\n {0xc13a148e3032d6e7, 0xe36a52363c1faf02},\n {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},\n {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},\n {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},\n {0xebdf661791d60f56, 0x111b495b3464ad22},\n {0x936b9fcebb25c995, 0xcab10dd900beec35},\n {0xb84687c269ef3bfb, 0x3d5d514f40eea743},\n {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},\n {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},\n {0xb3f4e093db73a093, 0x59ed216765690f57},\n {0xe0f218b8d25088b8, 0x306869c13ec3532d},\n {0x8c974f7383725573, 0x1e414218c73a13fc},\n {0xafbd2350644eeacf, 0xe5d1929ef90898fb},\n {0xdbac6c247d62a583, 0xdf45f746b74abf3a},\n {0x894bc396ce5da772, 0x6b8bba8c328eb784},\n {0xab9eb47c81f5114f, 0x066ea92f3f326565},\n {0xd686619ba27255a2, 0xc80a537b0efefebe},\n {0x8613fd0145877585, 0xbd06742ce95f5f37},\n {0xa798fc4196e952e7, 0x2c48113823b73705},\n {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},\n {0x82ef85133de648c4, 0x9a984d73dbe722fc},\n {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},\n {0xcc963fee10b7d1b3, 0x318df905079926a9},\n {0xffbbcfe994e5c61f, 0xfdf17746497f7053},\n {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},\n {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},\n {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},\n {0x9c1661a651213e2d, 0x06bea10ca65c084f},\n {0xc31bfa0fe5698db8, 0x486e494fcff30a63},\n {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},\n {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},\n {0xbe89523386091465, 0xf6bbb397f1135824},\n {0xee2ba6c0678b597f, 0x746aa07ded582e2d},\n {0x94db483840b717ef, 0xa8c2a44eb4571cdd},\n {0xba121a4650e4ddeb, 0x92f34d62616ce414},\n {0xe896a0d7e51e1566, 0x77b020baf9c81d18},\n {0x915e2486ef32cd60, 0x0ace1474dc1d122f},\n {0xb5b5ada8aaff80b8, 0x0d819992132456bb},\n {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},\n {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},\n {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},\n {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},\n {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},\n {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},\n {0xd89d64d57a607744, 0xe871c7bf077ba8b8},\n {0x87625f056c7c4a8b, 0x11471cd764ad4973},\n {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},\n {0xd389b47879823479, 0x4aff1d108d4ec2c4},\n {0x843610cb4bf160cb, 0xcedf722a585139bb},\n {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},\n {0xce947a3da6a9273e, 0x733d226229feea33},\n {0x811ccc668829b887, 0x0806357d5a3f5260},\n {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},\n {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},\n {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},\n {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},\n {0xc5029163f384a931, 0x0a9e795e65d4df12},\n {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},\n {0x99ea0196163fa42e, 0x504bced1bf8e4e46},\n {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},\n {0xf07da27a82c37088, 0x5d767327bb4e5a4d},\n {0x964e858c91ba2655, 0x3a6a07f8d510f870},\n {0xbbe226efb628afea, 0x890489f70a55368c},\n {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},\n {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},\n {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},\n {0xe55990879ddcaabd, 0xcc420a6a101d0516},\n {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},\n {0xb32df8e9f3546564, 0x47939822dc96abfa},\n {0xdff9772470297ebd, 0x59787e2b93bc56f8},\n {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},\n {0xaefae51477a06b03, 0xede622920b6b23f2},\n {0xdab99e59958885c4, 0xe95fab368e45ecee},\n {0x88b402f7fd75539b, 0x11dbcb0218ebb415},\n {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},\n {0xd59944a37c0752a2, 0x4be76d3346f04960},\n {0x857fcae62d8493a5, 0x6f70a4400c562ddc},\n {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},\n {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},\n {0x825ecc24c873782f, 0x8ed400668c0c28c9},\n {0xa2f67f2dfa90563b, 0x728900802f0f32fb},\n {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},\n {0xfea126b7d78186bc, 0xe2f610c84987bfa9},\n {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},\n {0xc6ede63fa05d3143, 0x91503d1c79720dbc},\n {0xf8a95fcf88747d94, 0x75a44c6397ce912b},\n {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},\n {0xc24452da229b021b, 0xfbe85badce996169},\n {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},\n {0x97c560ba6b0919a5, 0xdccd879fc967d41b},\n {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},\n {0xed246723473e3813, 0x290123e9aab23b69},\n {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},\n {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},\n {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},\n {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},\n {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},\n {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},\n {0x8d590723948a535f, 0x579c487e5a38ad0f},\n {0xb0af48ec79ace837, 0x2d835a9df0c6d852},\n {0xdcdb1b2798182244, 0xf8e431456cf88e66},\n {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},\n {0xac8b2d36eed2dac5, 0xe272467e3d222f40},\n {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},\n {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},\n {0xa87fea27a539e9a5, 0x3f2398d747b36225},\n {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},\n {0x83a3eeeef9153e89, 0x1953cf68300424ad},\n {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},\n {0xcdb02555653131b6, 0x3792f412cb06794e},\n {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},\n {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},\n {0xc8de047564d20a8b, 0xf245825a5a445276},\n {0xfb158592be068d2e, 0xeed6e2f0f0d56713},\n {0x9ced737bb6c4183d, 0x55464dd69685606c},\n {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},\n {0xf53304714d9265df, 0xd53dd99f4b3066a9},\n {0x993fe2c6d07b7fab, 0xe546a8038efe402a},\n {0xbf8fdb78849a5f96, 0xde98520472bdd034},\n {0xef73d256a5c0f77c, 0x963e66858f6d4441},\n {0x95a8637627989aad, 0xdde7001379a44aa9},\n {0xbb127c53b17ec159, 0x5560c018580d5d53},\n {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},\n {0x9226712162ab070d, 0xcab3961304ca70e9},\n {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},\n {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},\n {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},\n {0xb267ed1940f1c61c, 0x55f038b237591ed4},\n {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},\n {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},\n {0xae397d8aa96c1b77, 0xabec975e0a0d081b},\n {0xd9c7dced53c72255, 0x96e7bd358c904a22},\n {0x881cea14545c7575, 0x7e50d64177da2e55},\n {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},\n {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},\n {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},\n {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},\n {0xcfb11ead453994ba, 0x67de18eda5814af3},\n {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},\n {0xa2425ff75e14fc31, 0xa1258379a94d028e},\n {0xcad2f7f5359a3b3e, 0x096ee45813a04331},\n {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},\n {0x9e74d1b791e07e48, 0x775ea264cf55347e},\n {0xc612062576589dda, 0x95364afe032a819e},\n {0xf79687aed3eec551, 0x3a83ddbd83f52205},\n {0x9abe14cd44753b52, 0xc4926a9672793543},\n {0xc16d9a0095928a27, 0x75b7053c0f178294},\n {0xf1c90080baf72cb1, 0x5324c68b12dd6339},\n {0x971da05074da7bee, 0xd3f6fc16ebca5e04},\n {0xbce5086492111aea, 0x88f4bb1ca6bcf585},\n {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},\n {0x9392ee8e921d5d07, 0x3aff322e62439fd0},\n {0xb877aa3236a4b449, 0x09befeb9fad487c3},\n {0xe69594bec44de15b, 0x4c2ebe687989a9b4},\n {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},\n {0xb424dc35095cd80f, 0x538484c19ef38c95},\n {0xe12e13424bb40e13, 0x2865a5f206b06fba},\n {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},\n {0xafebff0bcb24aafe, 0xf78f69a51539d749},\n {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},\n {0x89705f4136b4a597, 0x31680a88f8953031},\n {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},\n {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},\n {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},\n {0xa7c5ac471b478423, 0x0fcf80dc33721d54},\n {0xd1b71758e219652b, 0xd3c36113404ea4a9},\n {0x83126e978d4fdf3b, 0x645a1cac083126ea},\n {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},\n {0xcccccccccccccccc, 0xcccccccccccccccd},\n {0x8000000000000000, 0x0000000000000000},\n {0xa000000000000000, 0x0000000000000000},\n {0xc800000000000000, 0x0000000000000000},\n {0xfa00000000000000, 0x0000000000000000},\n {0x9c40000000000000, 0x0000000000000000},\n {0xc350000000000000, 0x0000000000000000},\n {0xf424000000000000, 0x0000000000000000},\n {0x9896800000000000, 0x0000000000000000},\n {0xbebc200000000000, 0x0000000000000000},\n {0xee6b280000000000, 0x0000000000000000},\n {0x9502f90000000000, 0x0000000000000000},\n {0xba43b74000000000, 0x0000000000000000},\n {0xe8d4a51000000000, 0x0000000000000000},\n {0x9184e72a00000000, 0x0000000000000000},\n {0xb5e620f480000000, 0x0000000000000000},\n {0xe35fa931a0000000, 0x0000000000000000},\n {0x8e1bc9bf04000000, 0x0000000000000000},\n {0xb1a2bc2ec5000000, 0x0000000000000000},\n {0xde0b6b3a76400000, 0x0000000000000000},\n {0x8ac7230489e80000, 0x0000000000000000},\n {0xad78ebc5ac620000, 0x0000000000000000},\n {0xd8d726b7177a8000, 0x0000000000000000},\n {0x878678326eac9000, 0x0000000000000000},\n {0xa968163f0a57b400, 0x0000000000000000},\n {0xd3c21bcecceda100, 0x0000000000000000},\n {0x84595161401484a0, 0x0000000000000000},\n {0xa56fa5b99019a5c8, 0x0000000000000000},\n {0xcecb8f27f4200f3a, 0x0000000000000000},\n {0x813f3978f8940984, 0x4000000000000000},\n {0xa18f07d736b90be5, 0x5000000000000000},\n {0xc9f2c9cd04674ede, 0xa400000000000000},\n {0xfc6f7c4045812296, 0x4d00000000000000},\n {0x9dc5ada82b70b59d, 0xf020000000000000},\n {0xc5371912364ce305, 0x6c28000000000000},\n {0xf684df56c3e01bc6, 0xc732000000000000},\n {0x9a130b963a6c115c, 0x3c7f400000000000},\n {0xc097ce7bc90715b3, 0x4b9f100000000000},\n {0xf0bdc21abb48db20, 0x1e86d40000000000},\n {0x96769950b50d88f4, 0x1314448000000000},\n {0xbc143fa4e250eb31, 0x17d955a000000000},\n {0xeb194f8e1ae525fd, 0x5dcfab0800000000},\n {0x92efd1b8d0cf37be, 0x5aa1cae500000000},\n {0xb7abc627050305ad, 0xf14a3d9e40000000},\n {0xe596b7b0c643c719, 0x6d9ccd05d0000000},\n {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},\n {0xb35dbf821ae4f38b, 0xdda2802c8a800000},\n {0xe0352f62a19e306e, 0xd50b2037ad200000},\n {0x8c213d9da502de45, 0x4526f422cc340000},\n {0xaf298d050e4395d6, 0x9670b12b7f410000},\n {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},\n {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},\n {0xab0e93b6efee0053, 0x8eea0d047a457a00},\n {0xd5d238a4abe98068, 0x72a4904598d6d880},\n {0x85a36366eb71f041, 0x47a6da2b7f864750},\n {0xa70c3c40a64e6c51, 0x999090b65f67d924},\n {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},\n {0x82818f1281ed449f, 0xbff8f10e7a8921a5},\n {0xa321f2d7226895c7, 0xaff72d52192b6a0e},\n {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},\n {0xfee50b7025c36a08, 0x02f236d04753d5b5},\n {0x9f4f2726179a2245, 0x01d762422c946591},\n {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},\n {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},\n {0x9b934c3b330c8577, 0x63cc55f49f88eb30},\n {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},\n {0xf316271c7fc3908a, 0x8bef464e3945ef7b},\n {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},\n {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},\n {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},\n {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},\n {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},\n {0xe7d34c64a9c85d44, 0x60dbbca87196b617},\n {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},\n {0xb51d13aea4a488dd, 0x6babab6398bdbe42},\n {0xe264589a4dcdab14, 0xc696963c7eed2dd2},\n {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},\n {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},\n {0xdd15fe86affad912, 0x49ef0eb713f39ebf},\n {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},\n {0xacb92ed9397bf996, 0x49c2c37f07965405},\n {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},\n {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},\n {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},\n {0xd2d80db02aabd62b, 0xf50a3fa490c30191},\n {0x83c7088e1aab65db, 0x792667c6da79e0fb},\n {0xa4b8cab1a1563f52, 0x577001b891185939},\n {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},\n {0x80b05e5ac60b6178, 0x544f8158315b05b5},\n {0xa0dc75f1778e39d6, 0x696361ae3db1c722},\n {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},\n {0xfb5878494ace3a5f, 0x04ab48a04065c724},\n {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},\n {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},\n {0xf5746577930d6500, 0xca8f44ec7ee3647a},\n {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},\n {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},\n {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},\n {0x95d04aee3b80ece5, 0xbba1f1d158724a13},\n {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},\n {0xea1575143cf97226, 0xf52d09d71a3293be},\n {0x924d692ca61be758, 0x593c2626705f9c57},\n {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},\n {0xe498f455c38b997a, 0x0b6dfb9c0f956448},\n {0x8edf98b59a373fec, 0x4724bd4189bd5ead},\n {0xb2977ee300c50fe7, 0x58edec91ec2cb658},\n {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},\n {0x8b865b215899f46c, 0xbd79e0d20082ee75},\n {0xae67f1e9aec07187, 0xecd8590680a3aa12},\n {0xda01ee641a708de9, 0xe80e6f4820cc9496},\n {0x884134fe908658b2, 0x3109058d147fdcde},\n {0xaa51823e34a7eede, 0xbd4b46f0599fd416},\n {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},\n {0x850fadc09923329e, 0x03e2cf6bc604ddb1},\n {0xa6539930bf6bff45, 0x84db8346b786151d},\n {0xcfe87f7cef46ff16, 0xe612641865679a64},\n {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},\n {0xa26da3999aef7749, 0xe3be5e330f38f09e},\n {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},\n {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},\n {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},\n {0xc646d63501a1511d, 0xb281e1fd541501b9},\n {0xf7d88bc24209a565, 0x1f225a7ca91a4227},\n {0x9ae757596946075f, 0x3375788de9b06959},\n {0xc1a12d2fc3978937, 0x0052d6b1641c83af},\n {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},\n {0x9745eb4d50ce6332, 0xf840b7ba963646e1},\n {0xbd176620a501fbff, 0xb650e5a93bc3d899},\n {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},\n {0x93ba47c980e98cdf, 0xc66f336c36b10138},\n {0xb8a8d9bbe123f017, 0xb80b0047445d4185},\n {0xe6d3102ad96cec1d, 0xa60dc059157491e6},\n {0x9043ea1ac7e41392, 0x87c89837ad68db30},\n {0xb454e4a179dd1877, 0x29babe4598c311fc},\n {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},\n {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},\n {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},\n {0xdc21a1171d42645d, 0x76707543f4fa1f74},\n {0x899504ae72497eba, 0x6a06494a791c53a9},\n {0xabfa45da0edbde69, 0x0487db9d17636893},\n {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},\n {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},\n {0xa7f26836f282b732, 0x8e6cac7768d7141f},\n {0xd1ef0244af2364ff, 0x3207d795430cd927},\n {0x8335616aed761f1f, 0x7f44e6bd49e807b9},\n {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},\n {0xcd036837130890a1, 0x36dba887c37a8c10},\n {0x802221226be55a64, 0xc2494954da2c978a},\n {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},\n {0xc83553c5c8965d3d, 0x6f92829494e5acc8},\n {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},\n {0x9c69a97284b578d7, 0xff2a760414536efc},\n {0xc38413cf25e2d70d, 0xfef5138519684abb},\n {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},\n {0x98bf2f79d5993802, 0xef2f773ffbd97a62},\n {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},\n {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},\n {0x952ab45cfa97a0b2, 0xdd945a747bf26184},\n {0xba756174393d88df, 0x94f971119aeef9e5},\n {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},\n {0x91abb422ccb812ee, 0xac62e055c10ab33b},\n {0xb616a12b7fe617aa, 0x577b986b314d600a},\n {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},\n {0x8e41ade9fbebc27d, 0x14588f13be847308},\n {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},\n {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},\n {0x8aec23d680043bee, 0x25de7bb9480d5855},\n {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},\n {0xd910f7ff28069da4, 0x1b2ba1518094da05},\n {0x87aa9aff79042286, 0x90fb44d2f05d0843},\n {0xa99541bf57452b28, 0x353a1607ac744a54},\n {0xd3fa922f2d1675f2, 0x42889b8997915ce9},\n {0x847c9b5d7c2e09b7, 0x69956135febada12},\n {0xa59bc234db398c25, 0x43fab9837e699096},\n {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},\n {0x8161afb94b44f57d, 0x1d1be0eebac278f6},\n {0xa1ba1ba79e1632dc, 0x6462d92a69731733},\n {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},\n {0xfcb2cb35e702af78, 0x5cda735244c3d43f},\n {0x9defbf01b061adab, 0x3a0888136afa64a8},\n {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},\n {0xf6c69a72a3989f5b, 0x8aad549e57273d46},\n {0x9a3c2087a63f6399, 0x36ac54e2f678864c},\n {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},\n {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},\n {0x969eb7c47859e743, 0x9f644ae5a4b1b326},\n {0xbc4665b596706114, 0x873d5d9f0dde1fef},\n {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},\n {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},\n {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},\n {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},\n {0x8fa475791a569d10, 0xf96e017d694487bd},\n {0xb38d92d760ec4455, 0x37c981dcc395a9ad},\n {0xe070f78d3927556a, 0x85bbe253f47b1418},\n {0x8c469ab843b89562, 0x93956d7478ccec8f},\n {0xaf58416654a6babb, 0x387ac8d1970027b3},\n {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},\n {0x88fcf317f22241e2, 0x441fece3bdf81f04},\n {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},\n {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},\n {0x85c7056562757456, 0xf6872d5667844e4a},\n {0xa738c6bebb12d16c, 0xb428f8ac016561dc},\n {0xd106f86e69d785c7, 0xe13336d701beba53},\n {0x82a45b450226b39c, 0xecc0024661173474},\n {0xa34d721642b06084, 0x27f002d7f95d0191},\n {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},\n {0xff290242c83396ce, 0x7e67047175a15272},\n {0x9f79a169bd203e41, 0x0f0062c6e984d387},\n {0xc75809c42c684dd1, 0x52c07b78a3e60869},\n {0xf92e0c3537826145, 0xa7709a56ccdf8a83},\n {0x9bbcc7a142b17ccb, 0x88a66076400bb692},\n {0xc2abf989935ddbfe, 0x6acff893d00ea436},\n {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},\n {0x98165af37b2153de, 0xc3727a337a8b704b},\n {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},\n {0xeda2ee1c7064130c, 0x1162def06f79df74},\n {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},\n {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},\n {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},\n {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},\n {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},\n {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},\n {0x8da471a9de737e24, 0x5ceaecfed289e5d3},\n {0xb10d8e1456105dad, 0x7425a83e872c5f48},\n {0xdd50f1996b947518, 0xd12f124e28f7771a},\n {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},\n {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},\n {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},\n {0x8714a775e3e95c78, 0x65acfaec34810a72},\n {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},\n {0xd31045a8341ca07c, 0x1ede48111209a051},\n {0x83ea2b892091e44d, 0x934aed0aab460433},\n {0xa4e4b66b68b65d60, 0xf81da84d56178540},\n {0xce1de40642e3f4b9, 0x36251260ab9d668f},\n {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},\n {0xa1075a24e4421730, 0xb24cf65b8612f820},\n {0xc94930ae1d529cfc, 0xdee033f26797b628},\n {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},\n {0x9d412e0806e88aa5, 0x8e1f289560ee864f},\n {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},\n {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},\n {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},\n {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},\n {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},\n {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},\n {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},\n {0xea53df5fd18d5513, 0x84c86189216dc5ee},\n {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},\n {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},\n {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},\n {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},\n {0xb2c71d5bca9023f8, 0x743e20e9ef511013},\n {0xdf78e4b2bd342cf6, 0x914da9246b255417},\n {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},\n {0xae9672aba3d0c320, 0xa184ac2473b529b2},\n {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},\n {0x8865899617fb1871, 0x7e2fa67c7a658893},\n {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},\n {0xd51ea6fa85785631, 0x552a74227f3ea566},\n {0x8533285c936b35de, 0xd53a88958f872760},\n {0xa67ff273b8460356, 0x8a892abaf368f138},\n {0xd01fef10a657842c, 0x2d2b7569b0432d86},\n {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},\n {0xa298f2c501f45f42, 0x8349f3ba91b47b90},\n {0xcb3f2f7642717713, 0x241c70a936219a74},\n {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},\n {0x9ec95d1463e8a506, 0xf4363804324a40ab},\n {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},\n {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},\n {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},\n {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},\n {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},\n {0x976e41088617ca01, 0xd5be0503e085d814},\n {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},\n {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},\n {0x93e1ab8252f33b45, 0xcabb90e5c942b504},\n {0xb8da1662e7b00a17, 0x3d6a751f3b936244},\n {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},\n {0x906a617d450187e2, 0x27fb2b80668b24c6},\n {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},\n {0xe1a63853bbd26451, 0x5e7873f8a0396974},\n {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},\n {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},\n {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},\n {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},\n {0xac2820d9623bf429, 0x546345fa9fbdcd45},\n {0xd732290fbacaf133, 0xa97c177947ad4096},\n {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},\n {0xa81f301449ee8c70, 0x5c68f256bfff5a75},\n {0xd226fc195c6a2f8c, 0x73832eec6fff3112},\n {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},\n {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},\n {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},\n {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},\n {0xa0555e361951c366, 0xd7e105bcc3326220},\n {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},\n {0xfa856334878fc150, 0xb14f98f6f0feb952},\n {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},\n {0xc3b8358109e84f07, 0x0a862f80ec4700c9},\n {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},\n {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},\n {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},\n {0xeeea5d5004981478, 0x1858ccfce06cac75},\n {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},\n {0xbaa718e68396cffd, 0xd30560258f54e6bb},\n {0xe950df20247c83fd, 0x47c6b82ef32a206a},\n {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},\n {0xb6472e511c81471d, 0xe0133fe4adf8e953},\n {0xe3d8f9e563a198e5, 0x58180fddd97723a7},\n {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},\n {0xb201833b35d63f73, 0x2cd2cc6551e513db},\n {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},\n {0x8b112e86420f6191, 0xfb04afaf27faf783},\n {0xadd57a27d29339f6, 0x79c5db9af1f9b564},\n {0xd94ad8b1c7380874, 0x18375281ae7822bd},\n {0x87cec76f1c830548, 0x8f2293910d0b15b6},\n {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},\n {0xd433179d9c8cb841, 0x5fa60692a46151ec},\n {0x849feec281d7f328, 0xdbc7c41ba6bcd334},\n {0xa5c7ea73224deff3, 0x12b9b522906c0801},\n {0xcf39e50feae16bef, 0xd768226b34870a01},\n {0x81842f29f2cce375, 0xe6a1158300d46641},\n {0xa1e53af46f801c53, 0x60495ae3c1097fd1},\n {0xca5e89b18b602368, 0x385bb19cb14bdfc5},\n {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},\n {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},\n {0xc5a05277621be293, 0xc7098b7305241886},\n {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},\n {0x9a65406d44a5c903, 0x737f74f1dc043329},\n {0xc0fe908895cf3b44, 0x505f522e53053ff3},\n {0xf13e34aabb430a15, 0x647726b9e7c68ff0},\n {0x96c6e0eab509e64d, 0x5eca783430dc19f6},\n {0xbc789925624c5fe0, 0xb67d16413d132073},\n {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},\n {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},\n {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},\n {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},\n {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},\n {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},\n {0xe0accfa875af45a7, 0x93eb1b80a33b8606},\n {0x8c6c01c9498d8b88, 0xbc72f130660533c4},\n {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},\n {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},\n#else\n {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},\n {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},\n {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},\n {0x86a8d39ef77164bc, 0xae5dff9c02033198},\n {0xd98ddaee19068c76, 0x3badd624dd9b0958},\n {0xafbd2350644eeacf, 0xe5d1929ef90898fb},\n {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},\n {0xe55990879ddcaabd, 0xcc420a6a101d0516},\n {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},\n {0x95a8637627989aad, 0xdde7001379a44aa9},\n {0xf1c90080baf72cb1, 0x5324c68b12dd6339},\n {0xc350000000000000, 0x0000000000000000},\n {0x9dc5ada82b70b59d, 0xf020000000000000},\n {0xfee50b7025c36a08, 0x02f236d04753d5b5},\n {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},\n {0xa6539930bf6bff45, 0x84db8346b786151d},\n {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},\n {0xd910f7ff28069da4, 0x1b2ba1518094da05},\n {0xaf58416654a6babb, 0x387ac8d1970027b3},\n {0x8da471a9de737e24, 0x5ceaecfed289e5d3},\n {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},\n {0xb8da1662e7b00a17, 0x3d6a751f3b936244},\n {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},\n {0xf13e34aabb430a15, 0x647726b9e7c68ff0}\n#endif\n };\n\n#if FMT_USE_FULL_CACHE_DRAGONBOX\n return pow10_significands[k - float_info::min_k];\n#else\n static constexpr uint64_t powers_of_5_64[] = {\n 0x0000000000000001, 0x0000000000000005, 0x0000000000000019,\n 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,\n 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,\n 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,\n 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,\n 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,\n 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,\n 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,\n 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};\n\n static const int compression_ratio = 27;\n\n // Compute base index.\n int cache_index = (k - float_info::min_k) / compression_ratio;\n int kb = cache_index * compression_ratio + float_info::min_k;\n int offset = k - kb;\n\n // Get base cache.\n uint128_fallback base_cache = pow10_significands[cache_index];\n if (offset == 0) return base_cache;\n\n // Compute the required amount of bit-shift.\n int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;\n FMT_ASSERT(alpha > 0 && alpha < 64, \"shifting error detected\");\n\n // Try to recover the real cache.\n uint64_t pow5 = powers_of_5_64[offset];\n uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);\n uint128_fallback middle_low = umul128(base_cache.low(), pow5);\n\n recovered_cache += middle_low.high();\n\n uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);\n uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);\n\n recovered_cache =\n uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,\n ((middle_low.low() >> alpha) | middle_to_low)};\n FMT_ASSERT(recovered_cache.low() + 1 != 0, \"\");\n return {recovered_cache.high(), recovered_cache.low() + 1};\n#endif\n }\n\n struct compute_mul_result {\n carrier_uint result;\n bool is_integer;\n };\n struct compute_mul_parity_result {\n bool parity;\n bool is_integer;\n };\n\n static auto compute_mul(carrier_uint u,\n const cache_entry_type& cache) noexcept\n -> compute_mul_result {\n auto r = umul192_upper128(u, cache);\n return {r.high(), r.low() == 0};\n }\n\n static auto compute_delta(const cache_entry_type& cache, int beta) noexcept\n -> uint32_t {\n return static_cast(cache.high() >> (64 - 1 - beta));\n }\n\n static auto compute_mul_parity(carrier_uint two_f,\n const cache_entry_type& cache,\n int beta) noexcept\n -> compute_mul_parity_result {\n FMT_ASSERT(beta >= 1, \"\");\n FMT_ASSERT(beta < 64, \"\");\n\n auto r = umul192_lower128(two_f, cache);\n return {((r.high() >> (64 - beta)) & 1) != 0,\n ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};\n }\n\n static auto compute_left_endpoint_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return (cache.high() -\n (cache.high() >> (num_significand_bits() + 2))) >>\n (64 - num_significand_bits() - 1 - beta);\n }\n\n static auto compute_right_endpoint_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return (cache.high() +\n (cache.high() >> (num_significand_bits() + 1))) >>\n (64 - num_significand_bits() - 1 - beta);\n }\n\n static auto compute_round_up_for_shorter_interval_case(\n const cache_entry_type& cache, int beta) noexcept -> carrier_uint {\n return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) +\n 1) /\n 2;\n }\n};\n\nFMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {\n return cache_accessor::get_cached_power(k);\n}\n\n// Various integer checks\ntemplate \nauto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {\n const int case_shorter_interval_left_endpoint_lower_threshold = 2;\n const int case_shorter_interval_left_endpoint_upper_threshold = 3;\n return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&\n exponent <= case_shorter_interval_left_endpoint_upper_threshold;\n}\n\n// Remove trailing zeros from n and return the number of zeros removed (float).\nFMT_INLINE auto remove_trailing_zeros(uint32_t& n, int s = 0) noexcept -> int {\n FMT_ASSERT(n != 0, \"\");\n // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.\n constexpr uint32_t mod_inv_5 = 0xcccccccd;\n constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5\n\n while (true) {\n auto q = rotr(n * mod_inv_25, 2);\n if (q > max_value() / 100) break;\n n = q;\n s += 2;\n }\n auto q = rotr(n * mod_inv_5, 1);\n if (q <= max_value() / 10) {\n n = q;\n s |= 1;\n }\n return s;\n}\n\n// Removes trailing zeros and returns the number of zeros removed (double).\nFMT_INLINE auto remove_trailing_zeros(uint64_t& n) noexcept -> int {\n FMT_ASSERT(n != 0, \"\");\n\n // Is n is divisible by 10^8?\n constexpr uint32_t ten_pow_8 = 100000000u;\n if ((n % ten_pow_8) == 0) {\n // If yes, work with the quotient...\n auto n32 = static_cast(n / ten_pow_8);\n // ... and use the 32 bit variant of the function\n int num_zeros = remove_trailing_zeros(n32, 8);\n n = n32;\n return num_zeros;\n }\n\n // If n is not divisible by 10^8, work with n itself.\n constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;\n constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5\n\n int s = 0;\n while (true) {\n auto q = rotr(n * mod_inv_25, 2);\n if (q > max_value() / 100) break;\n n = q;\n s += 2;\n }\n auto q = rotr(n * mod_inv_5, 1);\n if (q <= max_value() / 10) {\n n = q;\n s |= 1;\n }\n\n return s;\n}\n\n// The main algorithm for shorter interval case\ntemplate \nFMT_INLINE auto shorter_interval_case(int exponent) noexcept -> decimal_fp {\n decimal_fp ret_value;\n // Compute k and beta\n const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);\n const int beta = exponent + floor_log2_pow10(-minus_k);\n\n // Compute xi and zi\n using cache_entry_type = typename cache_accessor::cache_entry_type;\n const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k);\n\n auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case(\n cache, beta);\n auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case(\n cache, beta);\n\n // If the left endpoint is not an integer, increase it\n if (!is_left_endpoint_integer_shorter_interval(exponent)) ++xi;\n\n // Try bigger divisor\n ret_value.significand = zi / 10;\n\n // If succeed, remove trailing zeros if necessary and return\n if (ret_value.significand * 10 >= xi) {\n ret_value.exponent = minus_k + 1;\n ret_value.exponent += remove_trailing_zeros(ret_value.significand);\n return ret_value;\n }\n\n // Otherwise, compute the round-up of y\n ret_value.significand =\n cache_accessor::compute_round_up_for_shorter_interval_case(cache,\n beta);\n ret_value.exponent = minus_k;\n\n // When tie occurs, choose one of them according to the rule\n if (exponent >= float_info::shorter_interval_tie_lower_threshold &&\n exponent <= float_info::shorter_interval_tie_upper_threshold) {\n ret_value.significand = ret_value.significand % 2 == 0\n ? ret_value.significand\n : ret_value.significand - 1;\n } else if (ret_value.significand < xi) {\n ++ret_value.significand;\n }\n return ret_value;\n}\n\ntemplate auto to_decimal(T x) noexcept -> decimal_fp {\n // Step 1: integer promotion & Schubfach multiplier calculation.\n\n using carrier_uint = typename float_info::carrier_uint;\n using cache_entry_type = typename cache_accessor::cache_entry_type;\n auto br = bit_cast(x);\n\n // Extract significand bits and exponent bits.\n const carrier_uint significand_mask =\n (static_cast(1) << num_significand_bits()) - 1;\n carrier_uint significand = (br & significand_mask);\n int exponent =\n static_cast((br & exponent_mask()) >> num_significand_bits());\n\n if (exponent != 0) { // Check if normal.\n exponent -= exponent_bias() + num_significand_bits();\n\n // Shorter interval case; proceed like Schubfach.\n // In fact, when exponent == 1 and significand == 0, the interval is\n // regular. However, it can be shown that the end-results are anyway same.\n if (significand == 0) return shorter_interval_case(exponent);\n\n significand |= (static_cast(1) << num_significand_bits());\n } else {\n // Subnormal case; the interval is always regular.\n if (significand == 0) return {0, 0};\n exponent =\n std::numeric_limits::min_exponent - num_significand_bits() - 1;\n }\n\n const bool include_left_endpoint = (significand % 2 == 0);\n const bool include_right_endpoint = include_left_endpoint;\n\n // Compute k and beta.\n const int minus_k = floor_log10_pow2(exponent) - float_info::kappa;\n const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k);\n const int beta = exponent + floor_log2_pow10(-minus_k);\n\n // Compute zi and deltai.\n // 10^kappa <= deltai < 10^(kappa + 1)\n const uint32_t deltai = cache_accessor::compute_delta(cache, beta);\n const carrier_uint two_fc = significand << 1;\n\n // For the case of binary32, the result of integer check is not correct for\n // 29711844 * 2^-82\n // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18\n // and 29711844 * 2^-81\n // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,\n // and they are the unique counterexamples. However, since 29711844 is even,\n // this does not cause any problem for the endpoints calculations; it can only\n // cause a problem when we need to perform integer check for the center.\n // Fortunately, with these inputs, that branch is never executed, so we are\n // fine.\n const typename cache_accessor::compute_mul_result z_mul =\n cache_accessor::compute_mul((two_fc | 1) << beta, cache);\n\n // Step 2: Try larger divisor; remove trailing zeros if necessary.\n\n // Using an upper bound on zi, we might be able to optimize the division\n // better than the compiler; we are computing zi / big_divisor here.\n decimal_fp ret_value;\n ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);\n uint32_t r = static_cast(z_mul.result - float_info::big_divisor *\n ret_value.significand);\n\n if (r < deltai) {\n // Exclude the right endpoint if necessary.\n if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {\n --ret_value.significand;\n r = float_info::big_divisor;\n goto small_divisor_case_label;\n }\n } else if (r > deltai) {\n goto small_divisor_case_label;\n } else {\n // r == deltai; compare fractional parts.\n const typename cache_accessor::compute_mul_parity_result x_mul =\n cache_accessor::compute_mul_parity(two_fc - 1, cache, beta);\n\n if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))\n goto small_divisor_case_label;\n }\n ret_value.exponent = minus_k + float_info::kappa + 1;\n\n // We may need to remove trailing zeros.\n ret_value.exponent += remove_trailing_zeros(ret_value.significand);\n return ret_value;\n\n // Step 3: Find the significand with the smaller divisor.\n\nsmall_divisor_case_label:\n ret_value.significand *= 10;\n ret_value.exponent = minus_k + float_info::kappa;\n\n uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2);\n const bool approx_y_parity =\n ((dist ^ (float_info::small_divisor / 2)) & 1) != 0;\n\n // Is dist divisible by 10^kappa?\n const bool divisible_by_small_divisor =\n check_divisibility_and_divide_by_pow10::kappa>(dist);\n\n // Add dist / 10^kappa to the significand.\n ret_value.significand += dist;\n\n if (!divisible_by_small_divisor) return ret_value;\n\n // Check z^(f) >= epsilon^(f).\n // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,\n // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).\n // Since there are only 2 possibilities, we only need to care about the\n // parity. Also, zi and r should have the same parity since the divisor\n // is an even number.\n const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta);\n\n // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),\n // or equivalently, when y is an integer.\n if (y_mul.parity != approx_y_parity)\n --ret_value.significand;\n else if (y_mul.is_integer & (ret_value.significand % 2 != 0))\n --ret_value.significand;\n return ret_value;\n}\n} // namespace dragonbox\n} // namespace detail\n\ntemplate <> struct formatter {\n FMT_CONSTEXPR auto parse(format_parse_context& ctx)\n -> format_parse_context::iterator {\n return ctx.begin();\n }\n\n auto format(const detail::bigint& n, format_context& ctx) const\n -> format_context::iterator {\n auto out = ctx.out();\n bool first = true;\n for (auto i = n.bigits_.size(); i > 0; --i) {\n auto value = n.bigits_[i - 1u];\n if (first) {\n out = fmt::format_to(out, FMT_STRING(\"{:x}\"), value);\n first = false;\n continue;\n }\n out = fmt::format_to(out, FMT_STRING(\"{:08x}\"), value);\n }\n if (n.exp_ > 0)\n out = fmt::format_to(out, FMT_STRING(\"p{}\"),\n n.exp_ * detail::bigint::bigit_bits);\n return out;\n }\n};\n\nFMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {\n for_each_codepoint(s, [this](uint32_t cp, string_view) {\n if (cp == invalid_code_point) FMT_THROW(std::runtime_error(\"invalid utf8\"));\n if (cp <= 0xFFFF) {\n buffer_.push_back(static_cast(cp));\n } else {\n cp -= 0x10000;\n buffer_.push_back(static_cast(0xD800 + (cp >> 10)));\n buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF)));\n }\n return true;\n });\n buffer_.push_back(0);\n}\n\nFMT_FUNC void format_system_error(detail::buffer& out, int error_code,\n const char* message) noexcept {\n FMT_TRY {\n auto ec = std::error_code(error_code, std::generic_category());\n detail::write(appender(out), std::system_error(ec, message).what());\n return;\n }\n FMT_CATCH(...) {}\n format_error_code(out, error_code, message);\n}\n\nFMT_FUNC void report_system_error(int error_code,\n const char* message) noexcept {\n do_report_error(format_system_error, error_code, message);\n}\n\nFMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {\n // Don't optimize the \"{}\" case to keep the binary size small and because it\n // can be better optimized in fmt::format anyway.\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n return to_string(buffer);\n}\n\nnamespace detail {\n\nFMT_FUNC void vformat_to(buffer& buf, string_view fmt, format_args args,\n locale_ref loc) {\n auto out = appender(buf);\n if (fmt.size() == 2 && equal2(fmt.data(), \"{}\"))\n return args.get(0).visit(default_arg_formatter{out});\n parse_format_string(fmt,\n format_handler<>{parse_context<>(fmt), {out, args, loc}});\n}\n\ntemplate struct span {\n T* data;\n size_t size;\n};\n\ntemplate auto flockfile(F* f) -> decltype(_lock_file(f)) {\n _lock_file(f);\n}\ntemplate auto funlockfile(F* f) -> decltype(_unlock_file(f)) {\n _unlock_file(f);\n}\n\n#ifndef getc_unlocked\ntemplate auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) {\n return _fgetc_nolock(f);\n}\n#endif\n\ntemplate \nstruct has_flockfile : std::false_type {};\n\ntemplate \nstruct has_flockfile()))>>\n : std::true_type {};\n\n// A FILE wrapper. F is FILE defined as a template parameter to make system API\n// detection work.\ntemplate class file_base {\n public:\n F* file_;\n\n public:\n file_base(F* file) : file_(file) {}\n operator F*() const { return file_; }\n\n // Reads a code unit from the stream.\n auto get() -> int {\n int result = getc_unlocked(file_);\n if (result == EOF && ferror(file_) != 0)\n FMT_THROW(system_error(errno, FMT_STRING(\"getc failed\")));\n return result;\n }\n\n // Puts the code unit back into the stream buffer.\n void unget(char c) {\n if (ungetc(c, file_) == EOF)\n FMT_THROW(system_error(errno, FMT_STRING(\"ungetc failed\")));\n }\n\n void flush() { fflush(this->file_); }\n};\n\n// A FILE wrapper for glibc.\ntemplate class glibc_file : public file_base {\n private:\n enum {\n line_buffered = 0x200, // _IO_LINE_BUF\n unbuffered = 2 // _IO_UNBUFFERED\n };\n\n public:\n using file_base::file_base;\n\n auto is_buffered() const -> bool {\n return (this->file_->_flags & unbuffered) == 0;\n }\n\n void init_buffer() {\n if (this->file_->_IO_write_ptr < this->file_->_IO_write_end) return;\n // Force buffer initialization by placing and removing a char in a buffer.\n putc_unlocked(0, this->file_);\n --this->file_->_IO_write_ptr;\n }\n\n // Returns the file's read buffer.\n auto get_read_buffer() const -> span {\n auto ptr = this->file_->_IO_read_ptr;\n return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)};\n }\n\n // Returns the file's write buffer.\n auto get_write_buffer() const -> span {\n auto ptr = this->file_->_IO_write_ptr;\n return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)};\n }\n\n void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; }\n\n auto needs_flush() const -> bool {\n if ((this->file_->_flags & line_buffered) == 0) return false;\n char* end = this->file_->_IO_write_end;\n auto size = max_of(this->file_->_IO_write_ptr - end, 0);\n return memchr(end, '\\n', static_cast(size));\n }\n\n void flush() { fflush_unlocked(this->file_); }\n};\n\n// A FILE wrapper for Apple's libc.\ntemplate class apple_file : public file_base {\n private:\n enum {\n line_buffered = 1, // __SNBF\n unbuffered = 2 // __SLBF\n };\n\n public:\n using file_base::file_base;\n\n auto is_buffered() const -> bool {\n return (this->file_->_flags & unbuffered) == 0;\n }\n\n void init_buffer() {\n if (this->file_->_p) return;\n // Force buffer initialization by placing and removing a char in a buffer.\n if (!FMT_CLANG_ANALYZER) putc_unlocked(0, this->file_);\n --this->file_->_p;\n ++this->file_->_w;\n }\n\n auto get_read_buffer() const -> span {\n return {reinterpret_cast(this->file_->_p),\n to_unsigned(this->file_->_r)};\n }\n\n auto get_write_buffer() const -> span {\n return {reinterpret_cast(this->file_->_p),\n to_unsigned(this->file_->_bf._base + this->file_->_bf._size -\n this->file_->_p)};\n }\n\n void advance_write_buffer(size_t size) {\n this->file_->_p += size;\n this->file_->_w -= size;\n }\n\n auto needs_flush() const -> bool {\n if ((this->file_->_flags & line_buffered) == 0) return false;\n return memchr(this->file_->_p + this->file_->_w, '\\n',\n to_unsigned(-this->file_->_w));\n }\n};\n\n// A fallback FILE wrapper.\ntemplate class fallback_file : public file_base {\n private:\n char next_; // The next unconsumed character in the buffer.\n bool has_next_ = false;\n\n public:\n using file_base::file_base;\n\n auto is_buffered() const -> bool { return false; }\n auto needs_flush() const -> bool { return false; }\n void init_buffer() {}\n\n auto get_read_buffer() const -> span {\n return {&next_, has_next_ ? 1u : 0u};\n }\n\n auto get_write_buffer() const -> span { return {nullptr, 0}; }\n\n void advance_write_buffer(size_t) {}\n\n auto get() -> int {\n has_next_ = false;\n return file_base::get();\n }\n\n void unget(char c) {\n file_base::unget(c);\n next_ = c;\n has_next_ = true;\n }\n};\n\n#ifndef FMT_USE_FALLBACK_FILE\n# define FMT_USE_FALLBACK_FILE 0\n#endif\n\ntemplate \nauto get_file(F* f, int) -> apple_file {\n return f;\n}\ntemplate \ninline auto get_file(F* f, int) -> glibc_file {\n return f;\n}\n\ninline auto get_file(FILE* f, ...) -> fallback_file { return f; }\n\nusing file_ref = decltype(get_file(static_cast(nullptr), 0));\n\ntemplate \nclass file_print_buffer : public buffer {\n public:\n explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {}\n};\n\ntemplate \nclass file_print_buffer::value>>\n : public buffer {\n private:\n file_ref file_;\n\n static void grow(buffer& base, size_t) {\n auto& self = static_cast(base);\n self.file_.advance_write_buffer(self.size());\n if (self.file_.get_write_buffer().size == 0) self.file_.flush();\n auto buf = self.file_.get_write_buffer();\n FMT_ASSERT(buf.size > 0, \"\");\n self.set(buf.data, buf.size);\n self.clear();\n }\n\n public:\n explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) {\n flockfile(f);\n file_.init_buffer();\n auto buf = file_.get_write_buffer();\n set(buf.data, buf.size);\n }\n ~file_print_buffer() {\n file_.advance_write_buffer(size());\n bool flush = file_.needs_flush();\n F* f = file_; // Make funlockfile depend on the template parameter F\n funlockfile(f); // for the system API detection to work.\n if (flush) fflush(file_);\n }\n};\n\n#if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE)\nFMT_FUNC auto write_console(int, string_view) -> bool { return false; }\n#else\nusing dword = conditional_t;\nextern \"C\" __declspec(dllimport) int __stdcall WriteConsoleW( //\n void*, const void*, dword, dword*, void*);\n\nFMT_FUNC bool write_console(int fd, string_view text) {\n auto u16 = utf8_to_utf16(text);\n return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(),\n static_cast(u16.size()), nullptr, nullptr) != 0;\n}\n#endif\n\n#ifdef _WIN32\n// Print assuming legacy (non-Unicode) encoding.\nFMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args,\n bool newline) {\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n if (newline) buffer.push_back('\\n');\n fwrite_all(buffer.data(), buffer.size(), f);\n}\n#endif\n\nFMT_FUNC void print(std::FILE* f, string_view text) {\n#if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)\n int fd = _fileno(f);\n if (_isatty(fd)) {\n std::fflush(f);\n if (write_console(fd, text)) return;\n }\n#endif\n fwrite_all(text.data(), text.size(), f);\n}\n} // namespace detail\n\nFMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) {\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n detail::print(f, {buffer.data(), buffer.size()});\n}\n\nFMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {\n if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>())\n return vprint_buffered(f, fmt, args);\n auto&& buffer = detail::file_print_buffer<>(f);\n return detail::vformat_to(buffer, fmt, args);\n}\n\nFMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) {\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n buffer.push_back('\\n');\n detail::print(f, {buffer.data(), buffer.size()});\n}\n\nFMT_FUNC void vprint(string_view fmt, format_args args) {\n vprint(stdout, fmt, args);\n}\n\nnamespace detail {\n\nstruct singleton {\n unsigned char upper;\n unsigned char lower_count;\n};\n\ninline auto is_printable(uint16_t x, const singleton* singletons,\n size_t singletons_size,\n const unsigned char* singleton_lowers,\n const unsigned char* normal, size_t normal_size)\n -> bool {\n auto upper = x >> 8;\n auto lower_start = 0;\n for (size_t i = 0; i < singletons_size; ++i) {\n auto s = singletons[i];\n auto lower_end = lower_start + s.lower_count;\n if (upper < s.upper) break;\n if (upper == s.upper) {\n for (auto j = lower_start; j < lower_end; ++j) {\n if (singleton_lowers[j] == (x & 0xff)) return false;\n }\n }\n lower_start = lower_end;\n }\n\n auto xsigned = static_cast(x);\n auto current = true;\n for (size_t i = 0; i < normal_size; ++i) {\n auto v = static_cast(normal[i]);\n auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;\n xsigned -= len;\n if (xsigned < 0) break;\n current = !current;\n }\n return current;\n}\n\n// This code is generated by support/printable.py.\nFMT_FUNC auto is_printable(uint32_t cp) -> bool {\n static constexpr singleton singletons0[] = {\n {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8},\n {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},\n {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5},\n {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22},\n {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3},\n {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8},\n {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9},\n };\n static constexpr unsigned char singletons0_lower[] = {\n 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,\n 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,\n 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,\n 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,\n 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,\n 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,\n 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,\n 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,\n 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,\n 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,\n 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,\n 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,\n 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,\n 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,\n 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,\n 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,\n 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,\n 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,\n 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,\n 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,\n 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,\n 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,\n 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,\n 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,\n 0xfe, 0xff,\n };\n static constexpr singleton singletons1[] = {\n {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2},\n {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5},\n {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5},\n {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2},\n {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5},\n {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2},\n {0xfa, 2}, {0xfb, 1},\n };\n static constexpr unsigned char singletons1_lower[] = {\n 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,\n 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,\n 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,\n 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,\n 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,\n 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,\n 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,\n 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,\n 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,\n 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,\n 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,\n 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,\n 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,\n 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,\n 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,\n };\n static constexpr unsigned char normal0[] = {\n 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,\n 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,\n 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,\n 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,\n 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,\n 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,\n 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,\n 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,\n 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,\n 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,\n 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,\n 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,\n 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,\n 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,\n 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,\n 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,\n 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,\n 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,\n 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,\n 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,\n 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,\n 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,\n 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,\n 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,\n 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,\n 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,\n };\n static constexpr unsigned char normal1[] = {\n 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,\n 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,\n 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,\n 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,\n 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,\n 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,\n 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,\n 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,\n 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,\n 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,\n 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,\n 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,\n 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,\n 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,\n 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,\n 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,\n 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,\n 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,\n 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,\n 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,\n 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,\n 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,\n 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,\n 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,\n 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,\n 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,\n 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,\n 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,\n 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,\n 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,\n 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,\n 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,\n 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,\n 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,\n 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,\n };\n auto lower = static_cast(cp);\n if (cp < 0x10000) {\n return is_printable(lower, singletons0,\n sizeof(singletons0) / sizeof(*singletons0),\n singletons0_lower, normal0, sizeof(normal0));\n }\n if (cp < 0x20000) {\n return is_printable(lower, singletons1,\n sizeof(singletons1) / sizeof(*singletons1),\n singletons1_lower, normal1, sizeof(normal1));\n }\n if (0x2a6de <= cp && cp < 0x2a700) return false;\n if (0x2b735 <= cp && cp < 0x2b740) return false;\n if (0x2b81e <= cp && cp < 0x2b820) return false;\n if (0x2cea2 <= cp && cp < 0x2ceb0) return false;\n if (0x2ebe1 <= cp && cp < 0x2f800) return false;\n if (0x2fa1e <= cp && cp < 0x30000) return false;\n if (0x3134b <= cp && cp < 0xe0100) return false;\n if (0xe01f0 <= cp && cp < 0x110000) return false;\n return cp < 0x110000;\n}\n\n} // namespace detail\n\nFMT_END_NAMESPACE\n\n#endif // FMT_FORMAT_INL_H_\n" }, { "path": "include/spdlog/fmt/bundled/format.h", "content": "/*\n Formatting library for C++\n\n Copyright (c) 2012 - present, Victor Zverovich\n\n Permission is hereby granted, free of charge, to any person obtaining\n a copy of this software and associated documentation files (the\n \"Software\"), to deal in the Software without restriction, including\n without limitation the rights to use, copy, modify, merge, publish,\n distribute, sublicense, and/or sell copies of the Software, and to\n permit persons to whom the Software is furnished to do so, subject to\n the following conditions:\n\n The above copyright notice and this permission notice shall be\n included in all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n --- Optional exception to the license ---\n\n As an exception, if, as a result of your compiling your source code, portions\n of this Software are embedded into a machine-executable object form of such\n source code, you may redistribute such embedded portions in such object form\n without including the above copyright and permission notices.\n */\n\n#ifndef FMT_FORMAT_H_\n#define FMT_FORMAT_H_\n\n#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES\n# define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES\n# define FMT_REMOVE_TRANSITIVE_INCLUDES\n#endif\n\n#include \"base.h\"\n\n// libc++ supports string_view in pre-c++17.\n#if FMT_HAS_INCLUDE() && \\\n (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))\n# define FMT_USE_STRING_VIEW\n#endif\n\n#ifndef FMT_MODULE\n# include // malloc, free\n\n# include // std::signbit\n# include // std::byte\n# include // uint32_t\n# include // std::memcpy\n# include // std::numeric_limits\n# include // std::bad_alloc\n# if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)\n// Workaround for pre gcc 5 libstdc++.\n# include // std::allocator_traits\n# endif\n# include // std::runtime_error\n# include // std::string\n# include // std::system_error\n\n// Check FMT_CPLUSPLUS to avoid a warning in MSVC.\n# if FMT_HAS_INCLUDE() && FMT_CPLUSPLUS > 201703L\n# include // std::bit_cast\n# endif\n\n# if defined(FMT_USE_STRING_VIEW)\n# include \n# endif\n\n# if FMT_MSC_VERSION\n# include // _BitScanReverse[64], _umul128\n# endif\n#endif // FMT_MODULE\n\n#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS)\n// Use the provided definition.\n#elif defined(__NVCOMPILER)\n# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0\n#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L\n# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1\n#elif defined(__cpp_nontype_template_args) && \\\n __cpp_nontype_template_args >= 201911L\n# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1\n#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L\n# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1\n#else\n# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0\n#endif\n\n#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L\n# define FMT_INLINE_VARIABLE inline\n#else\n# define FMT_INLINE_VARIABLE\n#endif\n\n// Check if RTTI is disabled.\n#ifdef FMT_USE_RTTI\n// Use the provided definition.\n#elif defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \\\n defined(__INTEL_RTTI__) || defined(__RTTI)\n// __RTTI is for EDG compilers. _CPPRTTI is for MSVC.\n# define FMT_USE_RTTI 1\n#else\n# define FMT_USE_RTTI 0\n#endif\n\n// Visibility when compiled as a shared library/object.\n#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)\n# define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)\n#else\n# define FMT_SO_VISIBILITY(value)\n#endif\n\n#if FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_NOINLINE __attribute__((noinline))\n#else\n# define FMT_NOINLINE\n#endif\n\n#ifdef FMT_DEPRECATED\n// Use the provided definition.\n#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated)\n# define FMT_DEPRECATED [[deprecated]]\n#else\n# define FMT_DEPRECATED /* deprecated */\n#endif\n\n// Detect constexpr std::string.\n#if !FMT_USE_CONSTEVAL\n# define FMT_USE_CONSTEXPR_STRING 0\n#elif defined(__cpp_lib_constexpr_string) && \\\n __cpp_lib_constexpr_string >= 201907L\n# if FMT_CLANG_VERSION && FMT_GLIBCXX_RELEASE\n// clang + libstdc++ are able to work only starting with gcc13.3\n// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113294\n# if FMT_GLIBCXX_RELEASE < 13\n# define FMT_USE_CONSTEXPR_STRING 0\n# elif FMT_GLIBCXX_RELEASE == 13 && __GLIBCXX__ < 20240521\n# define FMT_USE_CONSTEXPR_STRING 0\n# else\n# define FMT_USE_CONSTEXPR_STRING 1\n# endif\n# else\n# define FMT_USE_CONSTEXPR_STRING 1\n# endif\n#else\n# define FMT_USE_CONSTEXPR_STRING 0\n#endif\n#if FMT_USE_CONSTEXPR_STRING\n# define FMT_CONSTEXPR_STRING constexpr\n#else\n# define FMT_CONSTEXPR_STRING\n#endif\n\n// GCC 4.9 doesn't support qualified names in specializations.\nnamespace std {\ntemplate struct iterator_traits> {\n using iterator_category = output_iterator_tag;\n using value_type = T;\n using difference_type =\n decltype(static_cast(nullptr) - static_cast(nullptr));\n using pointer = void;\n using reference = void;\n};\n} // namespace std\n\n#ifdef FMT_THROW\n// Use the provided definition.\n#elif FMT_USE_EXCEPTIONS\n# define FMT_THROW(x) throw x\n#else\n# define FMT_THROW(x) ::fmt::assert_fail(__FILE__, __LINE__, (x).what())\n#endif\n\n#ifdef __clang_analyzer__\n# define FMT_CLANG_ANALYZER 1\n#else\n# define FMT_CLANG_ANALYZER 0\n#endif\n\n// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of\n// integer formatter template instantiations to just one by only using the\n// largest integer type. This results in a reduction in binary size but will\n// cause a decrease in integer formatting performance.\n#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)\n# define FMT_REDUCE_INT_INSTANTIATIONS 0\n#endif\n\nFMT_BEGIN_NAMESPACE\n\ntemplate \nstruct is_contiguous>\n : std::true_type {};\n\nnamespace detail {\n\n// __builtin_clz is broken in clang with Microsoft codegen:\n// https://github.com/fmtlib/fmt/issues/519.\n#if !FMT_MSC_VERSION\n# if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION\n# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)\n# endif\n# if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION\n# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)\n# endif\n#endif\n\n// Some compilers masquerade as both MSVC and GCC but otherwise support\n// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the\n// MSVC intrinsics if the clz and clzll builtins are not available.\n#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL)\n// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.\n# ifndef __clang__\n# pragma intrinsic(_BitScanReverse)\n# ifdef _WIN64\n# pragma intrinsic(_BitScanReverse64)\n# endif\n# endif\n\ninline auto clz(uint32_t x) -> int {\n FMT_ASSERT(x != 0, \"\");\n FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.\n unsigned long r = 0;\n _BitScanReverse(&r, x);\n return 31 ^ static_cast(r);\n}\n# define FMT_BUILTIN_CLZ(n) detail::clz(n)\n\ninline auto clzll(uint64_t x) -> int {\n FMT_ASSERT(x != 0, \"\");\n FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.\n unsigned long r = 0;\n# ifdef _WIN64\n _BitScanReverse64(&r, x);\n# else\n // Scan the high 32 bits.\n if (_BitScanReverse(&r, static_cast(x >> 32)))\n return 63 ^ static_cast(r + 32);\n // Scan the low 32 bits.\n _BitScanReverse(&r, static_cast(x));\n# endif\n return 63 ^ static_cast(r);\n}\n# define FMT_BUILTIN_CLZLL(n) detail::clzll(n)\n#endif // FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL)\n\nFMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {\n ignore_unused(condition);\n#ifdef FMT_FUZZ\n if (condition) throw std::runtime_error(\"fuzzing limit reached\");\n#endif\n}\n\n#if defined(FMT_USE_STRING_VIEW)\ntemplate using std_string_view = std::basic_string_view;\n#else\ntemplate struct std_string_view {\n operator basic_string_view() const;\n};\n#endif\n\ntemplate struct string_literal {\n static constexpr Char value[sizeof...(C)] = {C...};\n constexpr operator basic_string_view() const {\n return {value, sizeof...(C)};\n }\n};\n#if FMT_CPLUSPLUS < 201703L\ntemplate \nconstexpr Char string_literal::value[sizeof...(C)];\n#endif\n\n// Implementation of std::bit_cast for pre-C++20.\ntemplate \nFMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {\n#ifdef __cpp_lib_bit_cast\n if (is_constant_evaluated()) return std::bit_cast(from);\n#endif\n auto to = To();\n // The cast suppresses a bogus -Wclass-memaccess on GCC.\n std::memcpy(static_cast(&to), &from, sizeof(to));\n return to;\n}\n\ninline auto is_big_endian() -> bool {\n#ifdef _WIN32\n return false;\n#elif defined(__BIG_ENDIAN__)\n return true;\n#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)\n return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;\n#else\n struct bytes {\n char data[sizeof(int)];\n };\n return bit_cast(1).data[0] == 0;\n#endif\n}\n\nclass uint128_fallback {\n private:\n uint64_t lo_, hi_;\n\n public:\n constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}\n constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}\n\n constexpr auto high() const noexcept -> uint64_t { return hi_; }\n constexpr auto low() const noexcept -> uint64_t { return lo_; }\n\n template ::value)>\n constexpr explicit operator T() const {\n return static_cast(lo_);\n }\n\n friend constexpr auto operator==(const uint128_fallback& lhs,\n const uint128_fallback& rhs) -> bool {\n return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;\n }\n friend constexpr auto operator!=(const uint128_fallback& lhs,\n const uint128_fallback& rhs) -> bool {\n return !(lhs == rhs);\n }\n friend constexpr auto operator>(const uint128_fallback& lhs,\n const uint128_fallback& rhs) -> bool {\n return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;\n }\n friend constexpr auto operator|(const uint128_fallback& lhs,\n const uint128_fallback& rhs)\n -> uint128_fallback {\n return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};\n }\n friend constexpr auto operator&(const uint128_fallback& lhs,\n const uint128_fallback& rhs)\n -> uint128_fallback {\n return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};\n }\n friend constexpr auto operator~(const uint128_fallback& n)\n -> uint128_fallback {\n return {~n.hi_, ~n.lo_};\n }\n friend FMT_CONSTEXPR auto operator+(const uint128_fallback& lhs,\n const uint128_fallback& rhs)\n -> uint128_fallback {\n auto result = uint128_fallback(lhs);\n result += rhs;\n return result;\n }\n friend FMT_CONSTEXPR auto operator*(const uint128_fallback& lhs, uint32_t rhs)\n -> uint128_fallback {\n FMT_ASSERT(lhs.hi_ == 0, \"\");\n uint64_t hi = (lhs.lo_ >> 32) * rhs;\n uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;\n uint64_t new_lo = (hi << 32) + lo;\n return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};\n }\n friend constexpr auto operator-(const uint128_fallback& lhs, uint64_t rhs)\n -> uint128_fallback {\n return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};\n }\n FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback {\n if (shift == 64) return {0, hi_};\n if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);\n return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};\n }\n FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback {\n if (shift == 64) return {lo_, 0};\n if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);\n return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};\n }\n FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& {\n return *this = *this >> shift;\n }\n FMT_CONSTEXPR void operator+=(uint128_fallback n) {\n uint64_t new_lo = lo_ + n.lo_;\n uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);\n FMT_ASSERT(new_hi >= hi_, \"\");\n lo_ = new_lo;\n hi_ = new_hi;\n }\n FMT_CONSTEXPR void operator&=(uint128_fallback n) {\n lo_ &= n.lo_;\n hi_ &= n.hi_;\n }\n\n FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {\n if (is_constant_evaluated()) {\n lo_ += n;\n hi_ += (lo_ < n ? 1 : 0);\n return *this;\n }\n#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)\n unsigned long long carry;\n lo_ = __builtin_addcll(lo_, n, 0, &carry);\n hi_ += carry;\n#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)\n unsigned long long result;\n auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);\n lo_ = result;\n hi_ += carry;\n#elif defined(_MSC_VER) && defined(_M_X64)\n auto carry = _addcarry_u64(0, lo_, n, &lo_);\n _addcarry_u64(carry, hi_, 0, &hi_);\n#else\n lo_ += n;\n hi_ += (lo_ < n ? 1 : 0);\n#endif\n return *this;\n }\n};\n\nusing uint128_t = conditional_t;\n\n#ifdef UINTPTR_MAX\nusing uintptr_t = ::uintptr_t;\n#else\nusing uintptr_t = uint128_t;\n#endif\n\n// Returns the largest possible value for type T. Same as\n// std::numeric_limits::max() but shorter and not affected by the max macro.\ntemplate constexpr auto max_value() -> T {\n return (std::numeric_limits::max)();\n}\ntemplate constexpr auto num_bits() -> int {\n return std::numeric_limits::digits;\n}\n// std::numeric_limits::digits may return 0 for 128-bit ints.\ntemplate <> constexpr auto num_bits() -> int { return 128; }\ntemplate <> constexpr auto num_bits() -> int { return 128; }\ntemplate <> constexpr auto num_bits() -> int { return 128; }\n\n// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t\n// and 128-bit pointers to uint128_fallback.\ntemplate sizeof(From))>\ninline auto bit_cast(const From& from) -> To {\n constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned short));\n struct data_t {\n unsigned short value[static_cast(size)];\n } data = bit_cast(from);\n auto result = To();\n if (const_check(is_big_endian())) {\n for (int i = 0; i < size; ++i)\n result = (result << num_bits()) | data.value[i];\n } else {\n for (int i = size - 1; i >= 0; --i)\n result = (result << num_bits()) | data.value[i];\n }\n return result;\n}\n\ntemplate \nFMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int {\n int lz = 0;\n constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1);\n for (; (n & msb_mask) == 0; n <<= 1) lz++;\n return lz;\n}\n\nFMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {\n#ifdef FMT_BUILTIN_CLZ\n if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);\n#endif\n return countl_zero_fallback(n);\n}\n\nFMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {\n#ifdef FMT_BUILTIN_CLZLL\n if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);\n#endif\n return countl_zero_fallback(n);\n}\n\nFMT_INLINE void assume(bool condition) {\n (void)condition;\n#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION\n __builtin_assume(condition);\n#elif FMT_GCC_VERSION\n if (!condition) __builtin_unreachable();\n#endif\n}\n\n// Attempts to reserve space for n extra characters in the output range.\n// Returns a pointer to the reserved range or a reference to it.\ntemplate ::value&&\n is_contiguous::value)>\n#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION\n__attribute__((no_sanitize(\"undefined\")))\n#endif\nFMT_CONSTEXPR20 inline auto\nreserve(OutputIt it, size_t n) -> typename OutputIt::value_type* {\n auto& c = get_container(it);\n size_t size = c.size();\n c.resize(size + n);\n return &c[size];\n}\n\ntemplate \nFMT_CONSTEXPR20 inline auto reserve(basic_appender it, size_t n)\n -> basic_appender {\n buffer& buf = get_container(it);\n buf.try_reserve(buf.size() + n);\n return it;\n}\n\ntemplate \nconstexpr auto reserve(Iterator& it, size_t) -> Iterator& {\n return it;\n}\n\ntemplate \nusing reserve_iterator =\n remove_reference_t(), 0))>;\n\ntemplate \nconstexpr auto to_pointer(OutputIt, size_t) -> T* {\n return nullptr;\n}\ntemplate FMT_CONSTEXPR auto to_pointer(T*& ptr, size_t n) -> T* {\n T* begin = ptr;\n ptr += n;\n return begin;\n}\ntemplate \nFMT_CONSTEXPR20 auto to_pointer(basic_appender it, size_t n) -> T* {\n buffer& buf = get_container(it);\n buf.try_reserve(buf.size() + n);\n auto size = buf.size();\n if (buf.capacity() < size + n) return nullptr;\n buf.try_resize(size + n);\n return buf.data() + size;\n}\n\ntemplate ::value&&\n is_contiguous::value)>\ninline auto base_iterator(OutputIt it,\n typename OutputIt::container_type::value_type*)\n -> OutputIt {\n return it;\n}\n\ntemplate \nconstexpr auto base_iterator(Iterator, Iterator it) -> Iterator {\n return it;\n}\n\n// is spectacularly slow to compile in C++20 so use a simple fill_n\n// instead (#1998).\ntemplate \nFMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)\n -> OutputIt {\n for (Size i = 0; i < count; ++i) *out++ = value;\n return out;\n}\ntemplate \nFMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {\n if (is_constant_evaluated()) return fill_n(out, count, value);\n static_assert(sizeof(T) == 1,\n \"sizeof(T) must be 1 to use char for initialization\");\n std::memset(out, value, to_unsigned(count));\n return out + count;\n}\n\ntemplate \nFMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end,\n OutputIt out) -> OutputIt {\n return copy(begin, end, out);\n}\n\n// A public domain branchless UTF-8 decoder by Christopher Wellons:\n// https://github.com/skeeto/branchless-utf8\n/* Decode the next character, c, from s, reporting errors in e.\n *\n * Since this is a branchless decoder, four bytes will be read from the\n * buffer regardless of the actual length of the next character. This\n * means the buffer _must_ have at least three bytes of zero padding\n * following the end of the data stream.\n *\n * Errors are reported in e, which will be non-zero if the parsed\n * character was somehow invalid: invalid byte sequence, non-canonical\n * encoding, or a surrogate half.\n *\n * The function returns a pointer to the next character. When an error\n * occurs, this pointer will be a guess that depends on the particular\n * error, but it will always advance at least one byte.\n */\nFMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)\n -> const char* {\n constexpr int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};\n constexpr uint32_t mins[] = {4194304, 0, 128, 2048, 65536};\n constexpr int shiftc[] = {0, 18, 12, 6, 0};\n constexpr int shifte[] = {0, 6, 4, 2, 0};\n\n int len = \"\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\1\\0\\0\\0\\0\\0\\0\\0\\0\\2\\2\\2\\2\\3\\3\\4\"\n [static_cast(*s) >> 3];\n // Compute the pointer to the next character early so that the next\n // iteration can start working on the next character. Neither Clang\n // nor GCC figure out this reordering on their own.\n const char* next = s + len + !len;\n\n using uchar = unsigned char;\n\n // Assume a four-byte character and load four bytes. Unused bits are\n // shifted out.\n *c = uint32_t(uchar(s[0]) & masks[len]) << 18;\n *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;\n *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;\n *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;\n *c >>= shiftc[len];\n\n // Accumulate the various error conditions.\n *e = (*c < mins[len]) << 6; // non-canonical encoding\n *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half?\n *e |= (*c > 0x10FFFF) << 8; // out of range?\n *e |= (uchar(s[1]) & 0xc0) >> 2;\n *e |= (uchar(s[2]) & 0xc0) >> 4;\n *e |= uchar(s[3]) >> 6;\n *e ^= 0x2a; // top two bits of each tail byte correct?\n *e >>= shifte[len];\n\n return next;\n}\n\nconstexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t();\n\n// Invokes f(cp, sv) for every code point cp in s with sv being the string view\n// corresponding to the code point. cp is invalid_code_point on error.\ntemplate \nFMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {\n auto decode = [f](const char* buf_ptr, const char* ptr) {\n auto cp = uint32_t();\n auto error = 0;\n auto end = utf8_decode(buf_ptr, &cp, &error);\n bool result = f(error ? invalid_code_point : cp,\n string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));\n return result ? (error ? buf_ptr + 1 : end) : nullptr;\n };\n\n auto p = s.data();\n const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.\n if (s.size() >= block_size) {\n for (auto end = p + s.size() - block_size + 1; p < end;) {\n p = decode(p, p);\n if (!p) return;\n }\n }\n auto num_chars_left = to_unsigned(s.data() + s.size() - p);\n if (num_chars_left == 0) return;\n\n // Suppress bogus -Wstringop-overflow.\n if (FMT_GCC_VERSION) num_chars_left &= 3;\n char buf[2 * block_size - 1] = {};\n copy(p, p + num_chars_left, buf);\n const char* buf_ptr = buf;\n do {\n auto end = decode(buf_ptr, p);\n if (!end) return;\n p += end - buf_ptr;\n buf_ptr = end;\n } while (buf_ptr < buf + num_chars_left);\n}\n\nFMT_CONSTEXPR inline auto display_width_of(uint32_t cp) noexcept -> size_t {\n return to_unsigned(\n 1 + (cp >= 0x1100 &&\n (cp <= 0x115f || // Hangul Jamo init. consonants\n cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET\n cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET\n // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:\n (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||\n (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables\n (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs\n (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms\n (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms\n (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms\n (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms\n (cp >= 0x20000 && cp <= 0x2fffd) || // CJK\n (cp >= 0x30000 && cp <= 0x3fffd) ||\n // Miscellaneous Symbols and Pictographs + Emoticons:\n (cp >= 0x1f300 && cp <= 0x1f64f) ||\n // Supplemental Symbols and Pictographs:\n (cp >= 0x1f900 && cp <= 0x1f9ff))));\n}\n\ntemplate struct is_integral : std::is_integral {};\ntemplate <> struct is_integral : std::true_type {};\ntemplate <> struct is_integral : std::true_type {};\n\ntemplate \nusing is_signed =\n std::integral_constant::is_signed ||\n std::is_same::value>;\n\ntemplate \nusing is_integer =\n bool_constant::value && !std::is_same::value &&\n !std::is_same::value &&\n !std::is_same::value>;\n\n#if defined(FMT_USE_FLOAT128)\n// Use the provided definition.\n#elif FMT_CLANG_VERSION >= 309 && FMT_HAS_INCLUDE()\n# define FMT_USE_FLOAT128 1\n#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \\\n !defined(__STRICT_ANSI__)\n# define FMT_USE_FLOAT128 1\n#else\n# define FMT_USE_FLOAT128 0\n#endif\n#if FMT_USE_FLOAT128\nusing float128 = __float128;\n#else\nstruct float128 {};\n#endif\n\ntemplate using is_float128 = std::is_same;\n\ntemplate struct is_floating_point : std::is_floating_point {};\ntemplate <> struct is_floating_point : std::true_type {};\n\ntemplate ::value>\nstruct is_fast_float : bool_constant::is_iec559 &&\n sizeof(T) <= sizeof(double)> {};\ntemplate struct is_fast_float : std::false_type {};\n\ntemplate \nusing fast_float_t = conditional_t;\n\ntemplate \nusing is_double_double = bool_constant::digits == 106>;\n\n#ifndef FMT_USE_FULL_CACHE_DRAGONBOX\n# define FMT_USE_FULL_CACHE_DRAGONBOX 0\n#endif\n\n// An allocator that uses malloc/free to allow removing dependency on the C++\n// standard libary runtime. std::decay is used for back_inserter to be found by\n// ADL when applied to memory_buffer.\ntemplate struct allocator : private std::decay {\n using value_type = T;\n\n auto allocate(size_t n) -> T* {\n FMT_ASSERT(n <= max_value() / sizeof(T), \"\");\n T* p = static_cast(malloc(n * sizeof(T)));\n if (!p) FMT_THROW(std::bad_alloc());\n return p;\n }\n\n void deallocate(T* p, size_t) { free(p); }\n\n constexpr friend auto operator==(allocator, allocator) noexcept -> bool {\n return true; // All instances of this allocator are equivalent.\n }\n constexpr friend auto operator!=(allocator, allocator) noexcept -> bool {\n return false;\n }\n};\n\ntemplate \nFMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)\n -> decltype(f.set_debug_format(set)) {\n f.set_debug_format(set);\n}\ntemplate \nFMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}\n\n} // namespace detail\n\nFMT_BEGIN_EXPORT\n\n// The number of characters to store in the basic_memory_buffer object itself\n// to avoid dynamic memory allocation.\nenum { inline_buffer_size = 500 };\n\n/**\n * A dynamically growing memory buffer for trivially copyable/constructible\n * types with the first `SIZE` elements stored in the object itself. Most\n * commonly used via the `memory_buffer` alias for `char`.\n *\n * **Example**:\n *\n * auto out = fmt::memory_buffer();\n * fmt::format_to(std::back_inserter(out), \"The answer is {}.\", 42);\n *\n * This will append \"The answer is 42.\" to `out`. The buffer content can be\n * converted to `std::string` with `to_string(out)`.\n */\ntemplate >\nclass basic_memory_buffer : public detail::buffer {\n private:\n T store_[SIZE];\n\n // Don't inherit from Allocator to avoid generating type_info for it.\n FMT_NO_UNIQUE_ADDRESS Allocator alloc_;\n\n // Deallocate memory allocated by the buffer.\n FMT_CONSTEXPR20 void deallocate() {\n T* data = this->data();\n if (data != store_) alloc_.deallocate(data, this->capacity());\n }\n\n static FMT_CONSTEXPR20 void grow(detail::buffer& buf, size_t size) {\n detail::abort_fuzzing_if(size > 5000);\n auto& self = static_cast(buf);\n const size_t max_size =\n std::allocator_traits::max_size(self.alloc_);\n size_t old_capacity = buf.capacity();\n size_t new_capacity = old_capacity + old_capacity / 2;\n if (size > new_capacity)\n new_capacity = size;\n else if (new_capacity > max_size)\n new_capacity = max_of(size, max_size);\n T* old_data = buf.data();\n T* new_data = self.alloc_.allocate(new_capacity);\n // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).\n detail::assume(buf.size() <= new_capacity);\n // The following code doesn't throw, so the raw pointer above doesn't leak.\n memcpy(new_data, old_data, buf.size() * sizeof(T));\n self.set(new_data, new_capacity);\n // deallocate must not throw according to the standard, but even if it does,\n // the buffer already uses the new storage and will deallocate it in\n // destructor.\n if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity);\n }\n\n public:\n using value_type = T;\n using const_reference = const T&;\n\n FMT_CONSTEXPR explicit basic_memory_buffer(\n const Allocator& alloc = Allocator())\n : detail::buffer(grow), alloc_(alloc) {\n this->set(store_, SIZE);\n if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());\n }\n FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }\n\n private:\n template ::\n propagate_on_container_move_assignment::value)>\n FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool {\n alloc_ = std::move(other.alloc_);\n return true;\n }\n // If the allocator does not propagate then copy the data from other.\n template ::\n propagate_on_container_move_assignment::value)>\n FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool {\n T* data = other.data();\n if (alloc_ == other.alloc_ || data == other.store_) return true;\n size_t size = other.size();\n // Perform copy operation, allocators are different.\n this->resize(size);\n detail::copy(data, data + size, this->data());\n return false;\n }\n\n // Move data from other to this buffer.\n FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {\n T* data = other.data();\n size_t size = other.size(), capacity = other.capacity();\n if (!move_alloc(other)) return;\n if (data == other.store_) {\n this->set(store_, capacity);\n detail::copy(other.store_, other.store_ + size, store_);\n } else {\n this->set(data, capacity);\n // Set pointer to the inline array so that delete is not called\n // when deallocating.\n other.set(other.store_, 0);\n other.clear();\n }\n this->resize(size);\n }\n\n public:\n /// Constructs a `basic_memory_buffer` object moving the content of the other\n /// object to it.\n FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept\n : detail::buffer(grow) {\n move(other);\n }\n\n /// Moves the content of the other `basic_memory_buffer` object to this one.\n auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {\n FMT_ASSERT(this != &other, \"\");\n deallocate();\n move(other);\n return *this;\n }\n\n // Returns a copy of the allocator associated with this buffer.\n auto get_allocator() const -> Allocator { return alloc_; }\n\n /// Resizes the buffer to contain `count` elements. If T is a POD type new\n /// elements may not be initialized.\n FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); }\n\n /// Increases the buffer capacity to `new_capacity`.\n void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }\n\n using detail::buffer::append;\n template \n FMT_CONSTEXPR20 void append(const ContiguousRange& range) {\n append(range.data(), range.data() + range.size());\n }\n};\n\nusing memory_buffer = basic_memory_buffer;\n\ntemplate \nFMT_NODISCARD auto to_string(const basic_memory_buffer& buf)\n -> std::string {\n auto size = buf.size();\n detail::assume(size < std::string().max_size());\n return {buf.data(), size};\n}\n\n// A writer to a buffered stream. It doesn't own the underlying stream.\nclass writer {\n private:\n detail::buffer* buf_;\n\n // We cannot create a file buffer in advance because any write to a FILE may\n // invalidate it.\n FILE* file_;\n\n public:\n inline writer(FILE* f) : buf_(nullptr), file_(f) {}\n inline writer(detail::buffer& buf) : buf_(&buf) {}\n\n /// Formats `args` according to specifications in `fmt` and writes the\n /// output to the file.\n template void print(format_string fmt, T&&... args) {\n if (buf_)\n fmt::format_to(appender(*buf_), fmt, std::forward(args)...);\n else\n fmt::print(file_, fmt, std::forward(args)...);\n }\n};\n\nclass string_buffer {\n private:\n std::string str_;\n detail::container_buffer buf_;\n\n public:\n inline string_buffer() : buf_(str_) {}\n\n inline operator writer() { return buf_; }\n inline auto str() -> std::string& { return str_; }\n};\n\ntemplate \nstruct is_contiguous> : std::true_type {\n};\n\n// Suppress a misleading warning in older versions of clang.\nFMT_PRAGMA_CLANG(diagnostic ignored \"-Wweak-vtables\")\n\n/// An error reported from a formatting function.\nclass FMT_SO_VISIBILITY(\"default\") format_error : public std::runtime_error {\n public:\n using std::runtime_error::runtime_error;\n};\n\nclass loc_value;\n\nFMT_END_EXPORT\nnamespace detail {\nFMT_API auto write_console(int fd, string_view text) -> bool;\nFMT_API void print(FILE*, string_view);\n} // namespace detail\n\nnamespace detail {\ntemplate struct fixed_string {\n FMT_CONSTEXPR20 fixed_string(const Char (&s)[N]) {\n detail::copy(static_cast(s), s + N,\n data);\n }\n Char data[N] = {};\n};\n\n// Converts a compile-time string to basic_string_view.\nFMT_EXPORT template \nconstexpr auto compile_string_to_view(const Char (&s)[N])\n -> basic_string_view {\n // Remove trailing NUL character if needed. Won't be present if this is used\n // with a raw character array (i.e. not defined as a string).\n return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)};\n}\nFMT_EXPORT template \nconstexpr auto compile_string_to_view(basic_string_view s)\n -> basic_string_view {\n return s;\n}\n\n// Returns true if value is negative, false otherwise.\n// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.\ntemplate ::value)>\nconstexpr auto is_negative(T value) -> bool {\n return value < 0;\n}\ntemplate ::value)>\nconstexpr auto is_negative(T) -> bool {\n return false;\n}\n\n// Smallest of uint32_t, uint64_t, uint128_t that is large enough to\n// represent all values of an integral type T.\ntemplate \nusing uint32_or_64_or_128_t =\n conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,\n uint32_t,\n conditional_t() <= 64, uint64_t, uint128_t>>;\ntemplate \nusing uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>;\n\n#define FMT_POWERS_OF_10(factor) \\\n factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \\\n (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \\\n (factor) * 100000000, (factor) * 1000000000\n\n// Converts value in the range [0, 100) to a string.\n// GCC generates slightly better code when value is pointer-size.\ninline auto digits2(size_t value) -> const char* {\n // Align data since unaligned access may be slower when crossing a\n // hardware-specific boundary.\n alignas(2) static const char data[] =\n \"0001020304050607080910111213141516171819\"\n \"2021222324252627282930313233343536373839\"\n \"4041424344454647484950515253545556575859\"\n \"6061626364656667686970717273747576777879\"\n \"8081828384858687888990919293949596979899\";\n return &data[value * 2];\n}\n\ntemplate constexpr auto getsign(sign s) -> Char {\n return static_cast(((' ' << 24) | ('+' << 16) | ('-' << 8)) >>\n (static_cast(s) * 8));\n}\n\ntemplate FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {\n int count = 1;\n for (;;) {\n // Integer division is slow so do it for a group of four digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n if (n < 10) return count;\n if (n < 100) return count + 1;\n if (n < 1000) return count + 2;\n if (n < 10000) return count + 3;\n n /= 10000u;\n count += 4;\n }\n}\n#if FMT_USE_INT128\nFMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int {\n return count_digits_fallback(n);\n}\n#endif\n\n#ifdef FMT_BUILTIN_CLZLL\n// It is a separate function rather than a part of count_digits to workaround\n// the lack of static constexpr in constexpr functions.\ninline auto do_count_digits(uint64_t n) -> int {\n // This has comparable performance to the version by Kendall Willets\n // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)\n // but uses smaller tables.\n // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).\n static constexpr uint8_t bsr2log10[] = {\n 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,\n 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10,\n 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,\n 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};\n auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];\n static constexpr uint64_t zero_or_powers_of_10[] = {\n 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),\n 10000000000000000000ULL};\n return t - (n < zero_or_powers_of_10[t]);\n}\n#endif\n\n// Returns the number of decimal digits in n. Leading zeros are not counted\n// except for n == 0 in which case count_digits returns 1.\nFMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {\n#ifdef FMT_BUILTIN_CLZLL\n if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);\n#endif\n return count_digits_fallback(n);\n}\n\n// Counts the number of digits in n. BITS = log2(radix).\ntemplate \nFMT_CONSTEXPR auto count_digits(UInt n) -> int {\n#ifdef FMT_BUILTIN_CLZ\n if (!is_constant_evaluated() && num_bits() == 32)\n return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1;\n#endif\n // Lambda avoids unreachable code warnings from NVHPC.\n return [](UInt m) {\n int num_digits = 0;\n do {\n ++num_digits;\n } while ((m >>= BITS) != 0);\n return num_digits;\n }(n);\n}\n\n#ifdef FMT_BUILTIN_CLZ\n// It is a separate function rather than a part of count_digits to workaround\n// the lack of static constexpr in constexpr functions.\nFMT_INLINE auto do_count_digits(uint32_t n) -> int {\n// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.\n// This increments the upper 32 bits (log10(T) - 1) when >= T is added.\n# define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)\n static constexpr uint64_t table[] = {\n FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8\n FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64\n FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512\n FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096\n FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k\n FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k\n FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k\n FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M\n FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M\n FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M\n FMT_INC(1000000000), FMT_INC(1000000000) // 4B\n };\n auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];\n return static_cast((n + inc) >> 32);\n}\n#endif\n\n// Optional version of count_digits for better performance on 32-bit platforms.\nFMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {\n#ifdef FMT_BUILTIN_CLZ\n if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);\n#endif\n return count_digits_fallback(n);\n}\n\ntemplate constexpr auto digits10() noexcept -> int {\n return std::numeric_limits::digits10;\n}\ntemplate <> constexpr auto digits10() noexcept -> int { return 38; }\ntemplate <> constexpr auto digits10() noexcept -> int { return 38; }\n\ntemplate struct thousands_sep_result {\n std::string grouping;\n Char thousands_sep;\n};\n\ntemplate \nFMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result;\ntemplate \ninline auto thousands_sep(locale_ref loc) -> thousands_sep_result {\n auto result = thousands_sep_impl(loc);\n return {result.grouping, Char(result.thousands_sep)};\n}\ntemplate <>\ninline auto thousands_sep(locale_ref loc) -> thousands_sep_result {\n return thousands_sep_impl(loc);\n}\n\ntemplate \nFMT_API auto decimal_point_impl(locale_ref loc) -> Char;\ntemplate inline auto decimal_point(locale_ref loc) -> Char {\n return Char(decimal_point_impl(loc));\n}\ntemplate <> inline auto decimal_point(locale_ref loc) -> wchar_t {\n return decimal_point_impl(loc);\n}\n\n#ifndef FMT_HEADER_ONLY\nFMT_BEGIN_EXPORT\nextern template FMT_API auto thousands_sep_impl(locale_ref)\n -> thousands_sep_result;\nextern template FMT_API auto thousands_sep_impl(locale_ref)\n -> thousands_sep_result;\nextern template FMT_API auto decimal_point_impl(locale_ref) -> char;\nextern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;\nFMT_END_EXPORT\n#endif // FMT_HEADER_ONLY\n\n// Compares two characters for equality.\ntemplate auto equal2(const Char* lhs, const char* rhs) -> bool {\n return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);\n}\ninline auto equal2(const char* lhs, const char* rhs) -> bool {\n return memcmp(lhs, rhs, 2) == 0;\n}\n\n// Writes a two-digit value to out.\ntemplate \nFMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {\n if (!is_constant_evaluated() && std::is_same::value &&\n !FMT_OPTIMIZE_SIZE) {\n memcpy(out, digits2(value), 2);\n return;\n }\n *out++ = static_cast('0' + value / 10);\n *out = static_cast('0' + value % 10);\n}\n\n// Formats a decimal unsigned integer value writing to out pointing to a buffer\n// of specified size. The caller must ensure that the buffer is large enough.\ntemplate \nFMT_CONSTEXPR20 auto do_format_decimal(Char* out, UInt value, int size)\n -> Char* {\n FMT_ASSERT(size >= count_digits(value), \"invalid digit count\");\n unsigned n = to_unsigned(size);\n while (value >= 100) {\n // Integer division is slow so do it for a group of two digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n n -= 2;\n write2digits(out + n, static_cast(value % 100));\n value /= 100;\n }\n if (value >= 10) {\n n -= 2;\n write2digits(out + n, static_cast(value));\n } else {\n out[--n] = static_cast('0' + value);\n }\n return out + n;\n}\n\ntemplate \nFMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value,\n int num_digits) -> Char* {\n do_format_decimal(out, value, num_digits);\n return out + num_digits;\n}\n\ntemplate >::value)>\nFMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits)\n -> OutputIt {\n if (auto ptr = to_pointer(out, to_unsigned(num_digits))) {\n do_format_decimal(ptr, value, num_digits);\n return out;\n }\n // Buffer is large enough to hold all digits (digits10 + 1).\n char buffer[digits10() + 1];\n if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\\0');\n do_format_decimal(buffer, value, num_digits);\n return copy_noinline(buffer, buffer + num_digits, out);\n}\n\ntemplate \nFMT_CONSTEXPR auto do_format_base2e(int base_bits, Char* out, UInt value,\n int size, bool upper = false) -> Char* {\n out += size;\n do {\n const char* digits = upper ? \"0123456789ABCDEF\" : \"0123456789abcdef\";\n unsigned digit = static_cast(value & ((1u << base_bits) - 1));\n *--out = static_cast(base_bits < 4 ? static_cast('0' + digit)\n : digits[digit]);\n } while ((value >>= base_bits) != 0);\n return out;\n}\n\n// Formats an unsigned integer in the power of two base (binary, octal, hex).\ntemplate \nFMT_CONSTEXPR auto format_base2e(int base_bits, Char* out, UInt value,\n int num_digits, bool upper = false) -> Char* {\n do_format_base2e(base_bits, out, value, num_digits, upper);\n return out + num_digits;\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR inline auto format_base2e(int base_bits, OutputIt out, UInt value,\n int num_digits, bool upper = false)\n -> OutputIt {\n if (auto ptr = to_pointer(out, to_unsigned(num_digits))) {\n format_base2e(base_bits, ptr, value, num_digits, upper);\n return out;\n }\n // Make buffer large enough for any base.\n char buffer[num_bits()];\n if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\\0');\n format_base2e(base_bits, buffer, value, num_digits, upper);\n return detail::copy_noinline(buffer, buffer + num_digits, out);\n}\n\n// A converter from UTF-8 to UTF-16.\nclass utf8_to_utf16 {\n private:\n basic_memory_buffer buffer_;\n\n public:\n FMT_API explicit utf8_to_utf16(string_view s);\n inline operator basic_string_view() const {\n return {&buffer_[0], size()};\n }\n inline auto size() const -> size_t { return buffer_.size() - 1; }\n inline auto c_str() const -> const wchar_t* { return &buffer_[0]; }\n inline auto str() const -> std::wstring { return {&buffer_[0], size()}; }\n};\n\nenum class to_utf8_error_policy { abort, replace };\n\n// A converter from UTF-16/UTF-32 (host endian) to UTF-8.\ntemplate class to_utf8 {\n private:\n Buffer buffer_;\n\n public:\n to_utf8() {}\n explicit to_utf8(basic_string_view s,\n to_utf8_error_policy policy = to_utf8_error_policy::abort) {\n static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,\n \"expected utf16 or utf32\");\n if (!convert(s, policy)) {\n FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? \"invalid utf16\"\n : \"invalid utf32\"));\n }\n }\n operator string_view() const { return string_view(&buffer_[0], size()); }\n auto size() const -> size_t { return buffer_.size() - 1; }\n auto c_str() const -> const char* { return &buffer_[0]; }\n auto str() const -> std::string { return std::string(&buffer_[0], size()); }\n\n // Performs conversion returning a bool instead of throwing exception on\n // conversion error. This method may still throw in case of memory allocation\n // error.\n auto convert(basic_string_view s,\n to_utf8_error_policy policy = to_utf8_error_policy::abort)\n -> bool {\n if (!convert(buffer_, s, policy)) return false;\n buffer_.push_back(0);\n return true;\n }\n static auto convert(Buffer& buf, basic_string_view s,\n to_utf8_error_policy policy = to_utf8_error_policy::abort)\n -> bool {\n for (auto p = s.begin(); p != s.end(); ++p) {\n uint32_t c = static_cast(*p);\n if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {\n // Handle a surrogate pair.\n ++p;\n if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {\n if (policy == to_utf8_error_policy::abort) return false;\n buf.append(string_view(\"\\xEF\\xBF\\xBD\"));\n --p;\n continue;\n }\n c = (c << 10) + static_cast(*p) - 0x35fdc00;\n }\n if (c < 0x80) {\n buf.push_back(static_cast(c));\n } else if (c < 0x800) {\n buf.push_back(static_cast(0xc0 | (c >> 6)));\n buf.push_back(static_cast(0x80 | (c & 0x3f)));\n } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {\n buf.push_back(static_cast(0xe0 | (c >> 12)));\n buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6)));\n buf.push_back(static_cast(0x80 | (c & 0x3f)));\n } else if (c >= 0x10000 && c <= 0x10ffff) {\n buf.push_back(static_cast(0xf0 | (c >> 18)));\n buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12)));\n buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6)));\n buf.push_back(static_cast(0x80 | (c & 0x3f)));\n } else {\n return false;\n }\n }\n return true;\n }\n};\n\n// Computes 128-bit result of multiplication of two 64-bit unsigned integers.\nFMT_INLINE auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {\n#if FMT_USE_INT128\n auto p = static_cast(x) * static_cast(y);\n return {static_cast(p >> 64), static_cast(p)};\n#elif defined(_MSC_VER) && defined(_M_X64)\n auto hi = uint64_t();\n auto lo = _umul128(x, y, &hi);\n return {hi, lo};\n#else\n const uint64_t mask = static_cast(max_value());\n\n uint64_t a = x >> 32;\n uint64_t b = x & mask;\n uint64_t c = y >> 32;\n uint64_t d = y & mask;\n\n uint64_t ac = a * c;\n uint64_t bc = b * c;\n uint64_t ad = a * d;\n uint64_t bd = b * d;\n\n uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);\n\n return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),\n (intermediate << 32) + (bd & mask)};\n#endif\n}\n\nnamespace dragonbox {\n// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from\n// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.\ninline auto floor_log10_pow2(int e) noexcept -> int {\n FMT_ASSERT(e <= 2620 && e >= -2620, \"too large exponent\");\n static_assert((-1 >> 1) == -1, \"right shift is not arithmetic\");\n return (e * 315653) >> 20;\n}\n\ninline auto floor_log2_pow10(int e) noexcept -> int {\n FMT_ASSERT(e <= 1233 && e >= -1233, \"too large exponent\");\n return (e * 1741647) >> 19;\n}\n\n// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.\ninline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {\n#if FMT_USE_INT128\n auto p = static_cast(x) * static_cast(y);\n return static_cast(p >> 64);\n#elif defined(_MSC_VER) && defined(_M_X64)\n return __umulh(x, y);\n#else\n return umul128(x, y).high();\n#endif\n}\n\n// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a\n// 128-bit unsigned integer.\ninline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept\n -> uint128_fallback {\n uint128_fallback r = umul128(x, y.high());\n r += umul128_upper64(x, y.low());\n return r;\n}\n\nFMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;\n\n// Type-specific information that Dragonbox uses.\ntemplate struct float_info;\n\ntemplate <> struct float_info {\n using carrier_uint = uint32_t;\n static const int exponent_bits = 8;\n static const int kappa = 1;\n static const int big_divisor = 100;\n static const int small_divisor = 10;\n static const int min_k = -31;\n static const int max_k = 46;\n static const int shorter_interval_tie_lower_threshold = -35;\n static const int shorter_interval_tie_upper_threshold = -35;\n};\n\ntemplate <> struct float_info {\n using carrier_uint = uint64_t;\n static const int exponent_bits = 11;\n static const int kappa = 2;\n static const int big_divisor = 1000;\n static const int small_divisor = 100;\n static const int min_k = -292;\n static const int max_k = 341;\n static const int shorter_interval_tie_lower_threshold = -77;\n static const int shorter_interval_tie_upper_threshold = -77;\n};\n\n// An 80- or 128-bit floating point number.\ntemplate \nstruct float_info::digits == 64 ||\n std::numeric_limits::digits == 113 ||\n is_float128::value>> {\n using carrier_uint = detail::uint128_t;\n static const int exponent_bits = 15;\n};\n\n// A double-double floating point number.\ntemplate \nstruct float_info::value>> {\n using carrier_uint = detail::uint128_t;\n};\n\ntemplate struct decimal_fp {\n using significand_type = typename float_info::carrier_uint;\n significand_type significand;\n int exponent;\n};\n\ntemplate FMT_API auto to_decimal(T x) noexcept -> decimal_fp;\n} // namespace dragonbox\n\n// Returns true iff Float has the implicit bit which is not stored.\ntemplate constexpr auto has_implicit_bit() -> bool {\n // An 80-bit FP number has a 64-bit significand an no implicit bit.\n return std::numeric_limits::digits != 64;\n}\n\n// Returns the number of significand bits stored in Float. The implicit bit is\n// not counted since it is not stored.\ntemplate constexpr auto num_significand_bits() -> int {\n // std::numeric_limits may not support __float128.\n return is_float128() ? 112\n : (std::numeric_limits::digits -\n (has_implicit_bit() ? 1 : 0));\n}\n\ntemplate \nconstexpr auto exponent_mask() ->\n typename dragonbox::float_info::carrier_uint {\n using float_uint = typename dragonbox::float_info::carrier_uint;\n return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1)\n << num_significand_bits();\n}\ntemplate constexpr auto exponent_bias() -> int {\n // std::numeric_limits may not support __float128.\n return is_float128() ? 16383\n : std::numeric_limits::max_exponent - 1;\n}\n\nFMT_CONSTEXPR inline auto compute_exp_size(int exp) -> int {\n auto prefix_size = 2; // sign + 'e'\n auto abs_exp = exp >= 0 ? exp : -exp;\n if (abs_exp < 100) return prefix_size + 2;\n return prefix_size + (abs_exp >= 1000 ? 4 : 3);\n}\n\n// Writes the exponent exp in the form \"[+-]d{2,3}\" to buffer.\ntemplate \nFMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {\n FMT_ASSERT(-10000 < exp && exp < 10000, \"exponent out of range\");\n if (exp < 0) {\n *out++ = static_cast('-');\n exp = -exp;\n } else {\n *out++ = static_cast('+');\n }\n auto uexp = static_cast(exp);\n if (is_constant_evaluated()) {\n if (uexp < 10) *out++ = '0';\n return format_decimal(out, uexp, count_digits(uexp));\n }\n if (uexp >= 100u) {\n const char* top = digits2(uexp / 100);\n if (uexp >= 1000u) *out++ = static_cast(top[0]);\n *out++ = static_cast(top[1]);\n uexp %= 100;\n }\n const char* d = digits2(uexp);\n *out++ = static_cast(d[0]);\n *out++ = static_cast(d[1]);\n return out;\n}\n\n// A floating-point number f * pow(2, e) where F is an unsigned type.\ntemplate struct basic_fp {\n F f;\n int e;\n\n static constexpr int num_significand_bits =\n static_cast(sizeof(F) * num_bits());\n\n constexpr basic_fp() : f(0), e(0) {}\n constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}\n\n // Constructs fp from an IEEE754 floating-point number.\n template FMT_CONSTEXPR basic_fp(Float n) { assign(n); }\n\n // Assigns n to this and return true iff predecessor is closer than successor.\n template ::value)>\n FMT_CONSTEXPR auto assign(Float n) -> bool {\n static_assert(std::numeric_limits::digits <= 113, \"unsupported FP\");\n // Assume Float is in the format [sign][exponent][significand].\n using carrier_uint = typename dragonbox::float_info::carrier_uint;\n const auto num_float_significand_bits =\n detail::num_significand_bits();\n const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;\n const auto significand_mask = implicit_bit - 1;\n auto u = bit_cast(n);\n f = static_cast(u & significand_mask);\n auto biased_e = static_cast((u & exponent_mask()) >>\n num_float_significand_bits);\n // The predecessor is closer if n is a normalized power of 2 (f == 0)\n // other than the smallest normalized number (biased_e > 1).\n auto is_predecessor_closer = f == 0 && biased_e > 1;\n if (biased_e == 0)\n biased_e = 1; // Subnormals use biased exponent 1 (min exponent).\n else if (has_implicit_bit())\n f += static_cast(implicit_bit);\n e = biased_e - exponent_bias() - num_float_significand_bits;\n if (!has_implicit_bit()) ++e;\n return is_predecessor_closer;\n }\n\n template ::value)>\n FMT_CONSTEXPR auto assign(Float n) -> bool {\n static_assert(std::numeric_limits::is_iec559, \"unsupported FP\");\n return assign(static_cast(n));\n }\n};\n\nusing fp = basic_fp;\n\n// Normalizes the value converted from double and multiplied by (1 << SHIFT).\ntemplate \nFMT_CONSTEXPR auto normalize(basic_fp value) -> basic_fp {\n // Handle subnormals.\n const auto implicit_bit = F(1) << num_significand_bits();\n const auto shifted_implicit_bit = implicit_bit << SHIFT;\n while ((value.f & shifted_implicit_bit) == 0) {\n value.f <<= 1;\n --value.e;\n }\n // Subtract 1 to account for hidden bit.\n const auto offset = basic_fp::num_significand_bits -\n num_significand_bits() - SHIFT - 1;\n value.f <<= offset;\n value.e -= offset;\n return value;\n}\n\n// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.\nFMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {\n#if FMT_USE_INT128\n auto product = static_cast<__uint128_t>(lhs) * rhs;\n auto f = static_cast(product >> 64);\n return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f;\n#else\n // Multiply 32-bit parts of significands.\n uint64_t mask = (1ULL << 32) - 1;\n uint64_t a = lhs >> 32, b = lhs & mask;\n uint64_t c = rhs >> 32, d = rhs & mask;\n uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;\n // Compute mid 64-bit of result and round.\n uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);\n return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);\n#endif\n}\n\nFMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {\n return {multiply(x.f, y.f), x.e + y.e + 64};\n}\n\ntemplate () == num_bits()>\nusing convert_float_result =\n conditional_t::value || doublish, double, T>;\n\ntemplate \nconstexpr auto convert_float(T value) -> convert_float_result {\n return static_cast>(value);\n}\n\ntemplate \nauto select(T true_value, F) -> T {\n return true_value;\n}\ntemplate \nauto select(T, F false_value) -> F {\n return false_value;\n}\n\ntemplate \nFMT_CONSTEXPR FMT_NOINLINE auto fill(OutputIt it, size_t n,\n const basic_specs& specs) -> OutputIt {\n auto fill_size = specs.fill_size();\n if (fill_size == 1) return detail::fill_n(it, n, specs.fill_unit());\n if (const Char* data = specs.fill()) {\n for (size_t i = 0; i < n; ++i) it = copy(data, data + fill_size, it);\n }\n return it;\n}\n\n// Writes the output of f, padded according to format specifications in specs.\n// size: output size in code units.\n// width: output display width in (terminal) column positions.\ntemplate \nFMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs,\n size_t size, size_t width, F&& f) -> OutputIt {\n static_assert(default_align == align::left || default_align == align::right,\n \"\");\n unsigned spec_width = to_unsigned(specs.width);\n size_t padding = spec_width > width ? spec_width - width : 0;\n // Shifts are encoded as string literals because static constexpr is not\n // supported in constexpr functions.\n auto* shifts =\n default_align == align::left ? \"\\x1f\\x1f\\x00\\x01\" : \"\\x00\\x1f\\x00\\x01\";\n size_t left_padding = padding >> shifts[static_cast(specs.align())];\n size_t right_padding = padding - left_padding;\n auto it = reserve(out, size + padding * specs.fill_size());\n if (left_padding != 0) it = fill(it, left_padding, specs);\n it = f(it);\n if (right_padding != 0) it = fill(it, right_padding, specs);\n return base_iterator(out, it);\n}\n\ntemplate \nconstexpr auto write_padded(OutputIt out, const format_specs& specs,\n size_t size, F&& f) -> OutputIt {\n return write_padded(out, specs, size, size, f);\n}\n\ntemplate \nFMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,\n const format_specs& specs = {}) -> OutputIt {\n return write_padded(\n out, specs, bytes.size(), [bytes](reserve_iterator it) {\n const char* data = bytes.data();\n return copy(data, data + bytes.size(), it);\n });\n}\n\ntemplate \nauto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs)\n -> OutputIt {\n int num_digits = count_digits<4>(value);\n auto size = to_unsigned(num_digits) + size_t(2);\n auto write = [=](reserve_iterator it) {\n *it++ = static_cast('0');\n *it++ = static_cast('x');\n return format_base2e(4, it, value, num_digits);\n };\n return specs ? write_padded(out, *specs, size, write)\n : base_iterator(out, write(reserve(out, size)));\n}\n\n// Returns true iff the code point cp is printable.\nFMT_API auto is_printable(uint32_t cp) -> bool;\n\ninline auto needs_escape(uint32_t cp) -> bool {\n if (cp < 0x20 || cp == 0x7f || cp == '\"' || cp == '\\\\') return true;\n if (const_check(FMT_OPTIMIZE_SIZE > 1)) return false;\n return !is_printable(cp);\n}\n\ntemplate struct find_escape_result {\n const Char* begin;\n const Char* end;\n uint32_t cp;\n};\n\ntemplate \nauto find_escape(const Char* begin, const Char* end)\n -> find_escape_result {\n for (; begin != end; ++begin) {\n uint32_t cp = static_cast>(*begin);\n if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;\n if (needs_escape(cp)) return {begin, begin + 1, cp};\n }\n return {begin, nullptr, 0};\n}\n\ninline auto find_escape(const char* begin, const char* end)\n -> find_escape_result {\n if (const_check(!use_utf8)) return find_escape(begin, end);\n auto result = find_escape_result{end, nullptr, 0};\n for_each_codepoint(string_view(begin, to_unsigned(end - begin)),\n [&](uint32_t cp, string_view sv) {\n if (needs_escape(cp)) {\n result = {sv.begin(), sv.end(), cp};\n return false;\n }\n return true;\n });\n return result;\n}\n\ntemplate \nauto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {\n *out++ = static_cast('\\\\');\n *out++ = static_cast(prefix);\n Char buf[width];\n fill_n(buf, width, static_cast('0'));\n format_base2e(4, buf, cp, width);\n return copy(buf, buf + width, out);\n}\n\ntemplate \nauto write_escaped_cp(OutputIt out, const find_escape_result& escape)\n -> OutputIt {\n auto c = static_cast(escape.cp);\n switch (escape.cp) {\n case '\\n':\n *out++ = static_cast('\\\\');\n c = static_cast('n');\n break;\n case '\\r':\n *out++ = static_cast('\\\\');\n c = static_cast('r');\n break;\n case '\\t':\n *out++ = static_cast('\\\\');\n c = static_cast('t');\n break;\n case '\"': FMT_FALLTHROUGH;\n case '\\'': FMT_FALLTHROUGH;\n case '\\\\': *out++ = static_cast('\\\\'); break;\n default:\n if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp);\n if (escape.cp < 0x10000)\n return write_codepoint<4, Char>(out, 'u', escape.cp);\n if (escape.cp < 0x110000)\n return write_codepoint<8, Char>(out, 'U', escape.cp);\n for (Char escape_char : basic_string_view(\n escape.begin, to_unsigned(escape.end - escape.begin))) {\n out = write_codepoint<2, Char>(out, 'x',\n static_cast(escape_char) & 0xFF);\n }\n return out;\n }\n *out++ = c;\n return out;\n}\n\ntemplate \nauto write_escaped_string(OutputIt out, basic_string_view str)\n -> OutputIt {\n *out++ = static_cast('\"');\n auto begin = str.begin(), end = str.end();\n do {\n auto escape = find_escape(begin, end);\n out = copy(begin, escape.begin, out);\n begin = escape.end;\n if (!begin) break;\n out = write_escaped_cp(out, escape);\n } while (begin != end);\n *out++ = static_cast('\"');\n return out;\n}\n\ntemplate \nauto write_escaped_char(OutputIt out, Char v) -> OutputIt {\n Char v_array[1] = {v};\n *out++ = static_cast('\\'');\n if ((needs_escape(static_cast(v)) && v != static_cast('\"')) ||\n v == static_cast('\\'')) {\n out = write_escaped_cp(out,\n find_escape_result{v_array, v_array + 1,\n static_cast(v)});\n } else {\n *out++ = v;\n }\n *out++ = static_cast('\\'');\n return out;\n}\n\ntemplate \nFMT_CONSTEXPR auto write_char(OutputIt out, Char value,\n const format_specs& specs) -> OutputIt {\n bool is_debug = specs.type() == presentation_type::debug;\n return write_padded(out, specs, 1, [=](reserve_iterator it) {\n if (is_debug) return write_escaped_char(it, value);\n *it++ = value;\n return it;\n });\n}\n\ntemplate class digit_grouping {\n private:\n std::string grouping_;\n std::basic_string thousands_sep_;\n\n struct next_state {\n std::string::const_iterator group;\n int pos;\n };\n auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }\n\n // Returns the next digit group separator position.\n auto next(next_state& state) const -> int {\n if (thousands_sep_.empty()) return max_value();\n if (state.group == grouping_.end()) return state.pos += grouping_.back();\n if (*state.group <= 0 || *state.group == max_value())\n return max_value();\n state.pos += *state.group++;\n return state.pos;\n }\n\n public:\n explicit digit_grouping(locale_ref loc, bool localized = true) {\n if (!localized) return;\n auto sep = thousands_sep(loc);\n grouping_ = sep.grouping;\n if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);\n }\n digit_grouping(std::string grouping, std::basic_string sep)\n : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}\n\n auto has_separator() const -> bool { return !thousands_sep_.empty(); }\n\n auto count_separators(int num_digits) const -> int {\n int count = 0;\n auto state = initial_state();\n while (num_digits > next(state)) ++count;\n return count;\n }\n\n // Applies grouping to digits and writes the output to out.\n template \n auto apply(Out out, basic_string_view digits) const -> Out {\n auto num_digits = static_cast(digits.size());\n auto separators = basic_memory_buffer();\n separators.push_back(0);\n auto state = initial_state();\n while (int i = next(state)) {\n if (i >= num_digits) break;\n separators.push_back(i);\n }\n for (int i = 0, sep_index = static_cast(separators.size() - 1);\n i < num_digits; ++i) {\n if (num_digits - i == separators[sep_index]) {\n out = copy(thousands_sep_.data(),\n thousands_sep_.data() + thousands_sep_.size(), out);\n --sep_index;\n }\n *out++ = static_cast(digits[to_unsigned(i)]);\n }\n return out;\n }\n};\n\nFMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {\n prefix |= prefix != 0 ? value << 8 : value;\n prefix += (1u + (value > 0xff ? 1 : 0)) << 24;\n}\n\n// Writes a decimal integer with digit grouping.\ntemplate \nauto write_int(OutputIt out, UInt value, unsigned prefix,\n const format_specs& specs, const digit_grouping& grouping)\n -> OutputIt {\n static_assert(std::is_same, UInt>::value, \"\");\n int num_digits = 0;\n auto buffer = memory_buffer();\n switch (specs.type()) {\n default: FMT_ASSERT(false, \"\"); FMT_FALLTHROUGH;\n case presentation_type::none:\n case presentation_type::dec:\n num_digits = count_digits(value);\n format_decimal(appender(buffer), value, num_digits);\n break;\n case presentation_type::hex:\n if (specs.alt())\n prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0');\n num_digits = count_digits<4>(value);\n format_base2e(4, appender(buffer), value, num_digits, specs.upper());\n break;\n case presentation_type::oct:\n num_digits = count_digits<3>(value);\n // Octal prefix '0' is counted as a digit, so only add it if precision\n // is not greater than the number of digits.\n if (specs.alt() && specs.precision <= num_digits && value != 0)\n prefix_append(prefix, '0');\n format_base2e(3, appender(buffer), value, num_digits);\n break;\n case presentation_type::bin:\n if (specs.alt())\n prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0');\n num_digits = count_digits<1>(value);\n format_base2e(1, appender(buffer), value, num_digits);\n break;\n case presentation_type::chr:\n return write_char(out, static_cast(value), specs);\n }\n\n unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +\n to_unsigned(grouping.count_separators(num_digits));\n return write_padded(\n out, specs, size, size, [&](reserve_iterator it) {\n for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)\n *it++ = static_cast(p & 0xff);\n return grouping.apply(it, string_view(buffer.data(), buffer.size()));\n });\n}\n\n#if FMT_USE_LOCALE\n// Writes a localized value.\nFMT_API auto write_loc(appender out, loc_value value, const format_specs& specs,\n locale_ref loc) -> bool;\nauto write_loc(basic_appender out, loc_value value,\n const format_specs& specs, locale_ref loc) -> bool;\n#endif\ntemplate \ninline auto write_loc(OutputIt, const loc_value&, const format_specs&,\n locale_ref) -> bool {\n return false;\n}\n\ntemplate struct write_int_arg {\n UInt abs_value;\n unsigned prefix;\n};\n\ntemplate \nFMT_CONSTEXPR auto make_write_int_arg(T value, sign s)\n -> write_int_arg> {\n auto prefix = 0u;\n auto abs_value = static_cast>(value);\n if (is_negative(value)) {\n prefix = 0x01000000 | '-';\n abs_value = 0 - abs_value;\n } else {\n constexpr unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '};\n prefix = prefixes[static_cast(s)];\n }\n return {abs_value, prefix};\n}\n\ntemplate struct loc_writer {\n basic_appender out;\n const format_specs& specs;\n std::basic_string sep;\n std::string grouping;\n std::basic_string decimal_point;\n\n template ::value)>\n auto operator()(T value) -> bool {\n auto arg = make_write_int_arg(value, specs.sign());\n write_int(out, static_cast>(arg.abs_value), arg.prefix,\n specs, digit_grouping(grouping, sep));\n return true;\n }\n\n template ::value)>\n auto operator()(T) -> bool {\n return false;\n }\n};\n\n// Size and padding computation separate from write_int to avoid template bloat.\nstruct size_padding {\n unsigned size;\n unsigned padding;\n\n FMT_CONSTEXPR size_padding(int num_digits, unsigned prefix,\n const format_specs& specs)\n : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {\n if (specs.align() == align::numeric) {\n auto width = to_unsigned(specs.width);\n if (width > size) {\n padding = width - size;\n size = width;\n }\n } else if (specs.precision > num_digits) {\n size = (prefix >> 24) + to_unsigned(specs.precision);\n padding = to_unsigned(specs.precision - num_digits);\n }\n }\n};\n\ntemplate \nFMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg,\n const format_specs& specs) -> OutputIt {\n static_assert(std::is_same>::value, \"\");\n\n constexpr size_t buffer_size = num_bits();\n char buffer[buffer_size];\n if (is_constant_evaluated()) fill_n(buffer, buffer_size, '\\0');\n const char* begin = nullptr;\n const char* end = buffer + buffer_size;\n\n auto abs_value = arg.abs_value;\n auto prefix = arg.prefix;\n switch (specs.type()) {\n default: FMT_ASSERT(false, \"\"); FMT_FALLTHROUGH;\n case presentation_type::none:\n case presentation_type::dec:\n begin = do_format_decimal(buffer, abs_value, buffer_size);\n break;\n case presentation_type::hex:\n begin = do_format_base2e(4, buffer, abs_value, buffer_size, specs.upper());\n if (specs.alt())\n prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0');\n break;\n case presentation_type::oct: {\n begin = do_format_base2e(3, buffer, abs_value, buffer_size);\n // Octal prefix '0' is counted as a digit, so only add it if precision\n // is not greater than the number of digits.\n auto num_digits = end - begin;\n if (specs.alt() && specs.precision <= num_digits && abs_value != 0)\n prefix_append(prefix, '0');\n break;\n }\n case presentation_type::bin:\n begin = do_format_base2e(1, buffer, abs_value, buffer_size);\n if (specs.alt())\n prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0');\n break;\n case presentation_type::chr:\n return write_char(out, static_cast(abs_value), specs);\n }\n\n // Write an integer in the format\n // \n // prefix contains chars in three lower bytes and the size in the fourth byte.\n int num_digits = static_cast(end - begin);\n // Slightly faster check for specs.width == 0 && specs.precision == -1.\n if ((specs.width | (specs.precision + 1)) == 0) {\n auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));\n for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)\n *it++ = static_cast(p & 0xff);\n return base_iterator(out, copy(begin, end, it));\n }\n auto sp = size_padding(num_digits, prefix, specs);\n unsigned padding = sp.padding;\n return write_padded(\n out, specs, sp.size, [=](reserve_iterator it) {\n for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)\n *it++ = static_cast(p & 0xff);\n it = detail::fill_n(it, padding, static_cast('0'));\n return copy(begin, end, it);\n });\n}\n\ntemplate \nFMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out,\n write_int_arg arg,\n const format_specs& specs)\n -> OutputIt {\n return write_int(out, arg, specs);\n}\n\ntemplate ::value &&\n !std::is_same::value &&\n !std::is_same::value)>\nFMT_CONSTEXPR FMT_INLINE auto write(basic_appender out, T value,\n const format_specs& specs, locale_ref loc)\n -> basic_appender {\n if (specs.localized() && write_loc(out, value, specs, loc)) return out;\n return write_int_noinline(out, make_write_int_arg(value, specs.sign()),\n specs);\n}\n\n// An inlined version of write used in format string compilation.\ntemplate ::value &&\n !std::is_same::value &&\n !std::is_same::value &&\n !std::is_same>::value)>\nFMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,\n const format_specs& specs, locale_ref loc)\n -> OutputIt {\n if (specs.localized() && write_loc(out, value, specs, loc)) return out;\n return write_int(out, make_write_int_arg(value, specs.sign()), specs);\n}\n\ntemplate \nFMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs,\n locale_ref loc = {}) -> OutputIt {\n // char is formatted as unsigned char for consistency across platforms.\n using unsigned_type =\n conditional_t::value, unsigned char, unsigned>;\n return check_char_specs(specs)\n ? write_char(out, value, specs)\n : write(out, static_cast(value), specs, loc);\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR auto write(OutputIt out, basic_string_view s,\n const format_specs& specs) -> OutputIt {\n bool is_debug = specs.type() == presentation_type::debug;\n if (specs.precision < 0 && specs.width == 0) {\n auto&& it = reserve(out, s.size());\n return is_debug ? write_escaped_string(it, s) : copy(s, it);\n }\n\n size_t display_width_limit =\n specs.precision < 0 ? SIZE_MAX : to_unsigned(specs.precision);\n size_t display_width =\n !is_debug || specs.precision == 0 ? 0 : 1; // Account for opening '\"'.\n size_t size = !is_debug || specs.precision == 0 ? 0 : 1;\n for_each_codepoint(s, [&](uint32_t cp, string_view sv) {\n if (is_debug && needs_escape(cp)) {\n counting_buffer buf;\n write_escaped_cp(basic_appender(buf),\n find_escape_result{sv.begin(), sv.end(), cp});\n // We're reinterpreting bytes as display width. That's okay\n // because write_escaped_cp() only writes ASCII characters.\n size_t cp_width = buf.count();\n if (display_width + cp_width <= display_width_limit) {\n display_width += cp_width;\n size += cp_width;\n // If this is the end of the string, account for closing '\"'.\n if (display_width < display_width_limit && sv.end() == s.end()) {\n ++display_width;\n ++size;\n }\n return true;\n }\n\n size += display_width_limit - display_width;\n display_width = display_width_limit;\n return false;\n }\n\n size_t cp_width = display_width_of(cp);\n if (cp_width + display_width <= display_width_limit) {\n display_width += cp_width;\n size += sv.size();\n // If this is the end of the string, account for closing '\"'.\n if (is_debug && display_width < display_width_limit &&\n sv.end() == s.end()) {\n ++display_width;\n ++size;\n }\n return true;\n }\n\n return false;\n });\n\n struct bounded_output_iterator {\n reserve_iterator underlying_iterator;\n size_t bound;\n\n FMT_CONSTEXPR auto operator*() -> bounded_output_iterator& { return *this; }\n FMT_CONSTEXPR auto operator++() -> bounded_output_iterator& {\n return *this;\n }\n FMT_CONSTEXPR auto operator++(int) -> bounded_output_iterator& {\n return *this;\n }\n FMT_CONSTEXPR auto operator=(char c) -> bounded_output_iterator& {\n if (bound > 0) {\n *underlying_iterator++ = c;\n --bound;\n }\n return *this;\n }\n };\n\n return write_padded(\n out, specs, size, display_width, [=](reserve_iterator it) {\n return is_debug\n ? write_escaped_string(bounded_output_iterator{it, size}, s)\n .underlying_iterator\n : copy(s.data(), s.data() + size, it);\n });\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR auto write(OutputIt out, basic_string_view s,\n const format_specs& specs) -> OutputIt {\n auto data = s.data();\n auto size = s.size();\n if (specs.precision >= 0 && to_unsigned(specs.precision) < size)\n size = to_unsigned(specs.precision);\n\n bool is_debug = specs.type() == presentation_type::debug;\n if (is_debug) {\n auto buf = counting_buffer();\n write_escaped_string(basic_appender(buf), s);\n size = buf.count();\n }\n\n return write_padded(\n out, specs, size, [=](reserve_iterator it) {\n return is_debug ? write_escaped_string(it, s)\n : copy(data, data + size, it);\n });\n}\n\ntemplate \nFMT_CONSTEXPR auto write(OutputIt out, basic_string_view s,\n const format_specs& specs, locale_ref) -> OutputIt {\n return write(out, s, specs);\n}\n\ntemplate \nFMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs,\n locale_ref) -> OutputIt {\n if (specs.type() == presentation_type::pointer)\n return write_ptr(out, bit_cast(s), &specs);\n if (!s) report_error(\"string pointer is null\");\n return write(out, basic_string_view(s), specs, {});\n}\n\ntemplate ::value &&\n !std::is_same::value &&\n !std::is_same::value)>\nFMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {\n auto abs_value = static_cast>(value);\n bool negative = is_negative(value);\n // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.\n if (negative) abs_value = ~abs_value + 1;\n int num_digits = count_digits(abs_value);\n auto size = (negative ? 1 : 0) + static_cast(num_digits);\n if (auto ptr = to_pointer(out, size)) {\n if (negative) *ptr++ = static_cast('-');\n format_decimal(ptr, abs_value, num_digits);\n return out;\n }\n if (negative) *out++ = static_cast('-');\n return format_decimal(out, abs_value, num_digits);\n}\n\ntemplate \nFMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,\n format_specs& specs) -> const Char* {\n FMT_ASSERT(begin != end, \"\");\n auto alignment = align::none;\n auto p = begin + code_point_length(begin);\n if (end - p <= 0) p = begin;\n for (;;) {\n switch (to_ascii(*p)) {\n case '<': alignment = align::left; break;\n case '>': alignment = align::right; break;\n case '^': alignment = align::center; break;\n }\n if (alignment != align::none) {\n if (p != begin) {\n auto c = *begin;\n if (c == '}') return begin;\n if (c == '{') {\n report_error(\"invalid fill character '{'\");\n return begin;\n }\n specs.set_fill(basic_string_view(begin, to_unsigned(p - begin)));\n begin = p + 1;\n } else {\n ++begin;\n }\n break;\n } else if (p == begin) {\n break;\n }\n p = begin;\n }\n specs.set_align(alignment);\n return begin;\n}\n\ntemplate \nFMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,\n format_specs specs, sign s) -> OutputIt {\n auto str =\n isnan ? (specs.upper() ? \"NAN\" : \"nan\") : (specs.upper() ? \"INF\" : \"inf\");\n constexpr size_t str_size = 3;\n auto size = str_size + (s != sign::none ? 1 : 0);\n // Replace '0'-padding with space for non-finite values.\n const bool is_zero_fill =\n specs.fill_size() == 1 && specs.fill_unit() == '0';\n if (is_zero_fill) specs.set_fill(' ');\n return write_padded(out, specs, size,\n [=](reserve_iterator it) {\n if (s != sign::none)\n *it++ = detail::getsign(s);\n return copy(str, str + str_size, it);\n });\n}\n\n// A decimal floating-point number significand * pow(10, exp).\nstruct big_decimal_fp {\n const char* significand;\n int significand_size;\n int exponent;\n};\n\nconstexpr auto get_significand_size(const big_decimal_fp& f) -> int {\n return f.significand_size;\n}\ntemplate \ninline auto get_significand_size(const dragonbox::decimal_fp& f) -> int {\n return count_digits(f.significand);\n}\n\ntemplate \nconstexpr auto write_significand(OutputIt out, const char* significand,\n int significand_size) -> OutputIt {\n return copy(significand, significand + significand_size, out);\n}\ntemplate \ninline auto write_significand(OutputIt out, UInt significand,\n int significand_size) -> OutputIt {\n return format_decimal(out, significand, significand_size);\n}\ntemplate \nFMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,\n int significand_size, int exponent,\n const Grouping& grouping) -> OutputIt {\n if (!grouping.has_separator()) {\n out = write_significand(out, significand, significand_size);\n return detail::fill_n(out, exponent, static_cast('0'));\n }\n auto buffer = memory_buffer();\n write_significand(appender(buffer), significand, significand_size);\n detail::fill_n(appender(buffer), exponent, '0');\n return grouping.apply(out, string_view(buffer.data(), buffer.size()));\n}\n\ntemplate ::value)>\ninline auto write_significand(Char* out, UInt significand, int significand_size,\n int integral_size, Char decimal_point) -> Char* {\n if (!decimal_point) return format_decimal(out, significand, significand_size);\n out += significand_size + 1;\n Char* end = out;\n int floating_size = significand_size - integral_size;\n for (int i = floating_size / 2; i > 0; --i) {\n out -= 2;\n write2digits(out, static_cast(significand % 100));\n significand /= 100;\n }\n if (floating_size % 2 != 0) {\n *--out = static_cast('0' + significand % 10);\n significand /= 10;\n }\n *--out = decimal_point;\n format_decimal(out - integral_size, significand, integral_size);\n return end;\n}\n\ntemplate >::value)>\ninline auto write_significand(OutputIt out, UInt significand,\n int significand_size, int integral_size,\n Char decimal_point) -> OutputIt {\n // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.\n Char buffer[digits10() + 2];\n auto end = write_significand(buffer, significand, significand_size,\n integral_size, decimal_point);\n return detail::copy_noinline(buffer, end, out);\n}\n\ntemplate \nFMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,\n int significand_size, int integral_size,\n Char decimal_point) -> OutputIt {\n out = detail::copy_noinline(significand, significand + integral_size,\n out);\n if (!decimal_point) return out;\n *out++ = decimal_point;\n return detail::copy_noinline(significand + integral_size,\n significand + significand_size, out);\n}\n\ntemplate \nFMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,\n int significand_size, int integral_size,\n Char decimal_point,\n const Grouping& grouping) -> OutputIt {\n if (!grouping.has_separator()) {\n return write_significand(out, significand, significand_size, integral_size,\n decimal_point);\n }\n auto buffer = basic_memory_buffer();\n write_significand(basic_appender(buffer), significand, significand_size,\n integral_size, decimal_point);\n grouping.apply(\n out, basic_string_view(buffer.data(), to_unsigned(integral_size)));\n return detail::copy_noinline(buffer.data() + integral_size,\n buffer.end(), out);\n}\n\n// Numbers with exponents greater or equal to the returned value will use\n// the exponential notation.\ntemplate FMT_CONSTEVAL auto exp_upper() -> int {\n return std::numeric_limits::digits10 != 0\n ? min_of(16, std::numeric_limits::digits10 + 1)\n : 16;\n}\n\n// Use the fixed notation if the exponent is in [-4, exp_upper),\n// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.\nconstexpr auto use_fixed(int exp, int exp_upper) -> bool {\n return exp >= -4 && exp < exp_upper;\n}\n\ntemplate class fallback_digit_grouping {\n public:\n constexpr fallback_digit_grouping(locale_ref, bool) {}\n\n constexpr auto has_separator() const -> bool { return false; }\n\n constexpr auto count_separators(int) const -> int { return 0; }\n\n template \n constexpr auto apply(Out out, basic_string_view) const -> Out {\n return out;\n }\n};\n\ntemplate \nFMT_CONSTEXPR20 auto write_fixed(OutputIt out, const DecimalFP& f,\n int significand_size, Char decimal_point,\n const format_specs& specs, sign s,\n locale_ref loc = {}) -> OutputIt {\n using iterator = reserve_iterator;\n\n int exp = f.exponent + significand_size;\n long long size = significand_size + (s != sign::none ? 1 : 0);\n if (f.exponent >= 0) {\n // 1234e5 -> 123400000[.0+]\n size += f.exponent;\n int num_zeros = specs.precision - exp;\n abort_fuzzing_if(num_zeros > 5000);\n if (specs.alt()) {\n ++size;\n if (num_zeros <= 0 && specs.type() != presentation_type::fixed)\n num_zeros = 0;\n if (num_zeros > 0) size += num_zeros;\n }\n auto grouping = Grouping(loc, specs.localized());\n size += grouping.count_separators(exp);\n return write_padded(\n out, specs, static_cast(size), [&](iterator it) {\n if (s != sign::none) *it++ = detail::getsign(s);\n it = write_significand(it, f.significand, significand_size,\n f.exponent, grouping);\n if (!specs.alt()) return it;\n *it++ = decimal_point;\n return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;\n });\n }\n if (exp > 0) {\n // 1234e-2 -> 12.34[0+]\n int num_zeros = specs.alt() ? specs.precision - significand_size : 0;\n size += 1 + max_of(num_zeros, 0);\n auto grouping = Grouping(loc, specs.localized());\n size += grouping.count_separators(exp);\n return write_padded(\n out, specs, to_unsigned(size), [&](iterator it) {\n if (s != sign::none) *it++ = detail::getsign(s);\n it = write_significand(it, f.significand, significand_size, exp,\n decimal_point, grouping);\n return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it;\n });\n }\n // 1234e-6 -> 0.001234\n int num_zeros = -exp;\n if (significand_size == 0 && specs.precision >= 0 &&\n specs.precision < num_zeros) {\n num_zeros = specs.precision;\n }\n bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();\n size += 1 + (pointy ? 1 : 0) + num_zeros;\n return write_padded(\n out, specs, to_unsigned(size), [&](iterator it) {\n if (s != sign::none) *it++ = detail::getsign(s);\n *it++ = Char('0');\n if (!pointy) return it;\n *it++ = decimal_point;\n it = detail::fill_n(it, num_zeros, Char('0'));\n return write_significand(it, f.significand, significand_size);\n });\n}\n\ntemplate \nFMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,\n const format_specs& specs, sign s,\n int exp_upper, locale_ref loc) -> OutputIt {\n Char point = specs.localized() ? detail::decimal_point(loc) : Char('.');\n int significand_size = get_significand_size(f);\n int exp = f.exponent + significand_size - 1;\n if (specs.type() == presentation_type::fixed ||\n (specs.type() != presentation_type::exp &&\n use_fixed(exp, specs.precision > 0 ? specs.precision : exp_upper))) {\n return write_fixed(out, f, significand_size, point, specs,\n s, loc);\n }\n\n // Write value in the exponential format.\n int num_zeros = 0;\n long long size = significand_size + (s != sign::none ? 1 : 0);\n if (specs.alt()) {\n num_zeros = max_of(specs.precision - significand_size, 0);\n size += num_zeros;\n } else if (significand_size == 1) {\n point = Char();\n }\n size += (point ? 1 : 0) + compute_exp_size(exp);\n char exp_char = specs.upper() ? 'E' : 'e';\n auto write = [=](reserve_iterator it) {\n if (s != sign::none) *it++ = detail::getsign(s);\n // Insert a decimal point after the first digit and add an exponent.\n it = write_significand(it, f.significand, significand_size, 1, point);\n if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0'));\n *it++ = Char(exp_char);\n return write_exponent(exp, it);\n };\n auto usize = to_unsigned(size);\n return specs.width > 0\n ? write_padded(out, specs, usize, write)\n : base_iterator(out, write(reserve(out, usize)));\n}\n\ntemplate \nFMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,\n const format_specs& specs, sign s,\n int exp_upper, locale_ref loc) -> OutputIt {\n if (is_constant_evaluated()) {\n return do_write_float>(out, f, specs, s,\n exp_upper, loc);\n } else {\n return do_write_float>(out, f, specs, s,\n exp_upper, loc);\n }\n}\n\ntemplate constexpr auto isnan(T value) -> bool {\n return value != value; // std::isnan doesn't support __float128.\n}\n\ntemplate \nstruct has_isfinite : std::false_type {};\n\ntemplate \nstruct has_isfinite>\n : std::true_type {};\n\ntemplate ::value&& has_isfinite::value)>\nFMT_CONSTEXPR20 auto isfinite(T value) -> bool {\n constexpr T inf = T(std::numeric_limits::infinity());\n if (is_constant_evaluated())\n return !detail::isnan(value) && value < inf && value > -inf;\n return std::isfinite(value);\n}\ntemplate ::value)>\nFMT_CONSTEXPR auto isfinite(T value) -> bool {\n T inf = T(std::numeric_limits::infinity());\n // std::isfinite doesn't support __float128.\n return !detail::isnan(value) && value < inf && value > -inf;\n}\n\ntemplate ::value)>\nFMT_INLINE FMT_CONSTEXPR auto signbit(T value) -> bool {\n if (is_constant_evaluated()) {\n#ifdef __cpp_if_constexpr\n if constexpr (std::numeric_limits::is_iec559) {\n auto bits = detail::bit_cast(static_cast(value));\n return (bits >> (num_bits() - 1)) != 0;\n }\n#endif\n }\n return std::signbit(static_cast(value));\n}\n\ninline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {\n // Adjust fixed precision by exponent because it is relative to decimal\n // point.\n if (exp10 > 0 && precision > max_value() - exp10)\n FMT_THROW(format_error(\"number is too big\"));\n precision += exp10;\n}\n\nclass bigint {\n private:\n // A bigint is a number in the form bigit_[N - 1] ... bigit_[0] * 32^exp_.\n using bigit = uint32_t; // A big digit.\n using double_bigit = uint64_t;\n enum { bigit_bits = num_bits() };\n enum { bigits_capacity = 32 };\n basic_memory_buffer bigits_;\n int exp_;\n\n friend struct formatter;\n\n FMT_CONSTEXPR auto get_bigit(int i) const -> bigit {\n return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0;\n }\n\n FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) {\n auto result = double_bigit(bigits_[index]) - other - borrow;\n bigits_[index] = static_cast(result);\n borrow = static_cast(result >> (bigit_bits * 2 - 1));\n }\n\n FMT_CONSTEXPR void remove_leading_zeros() {\n int num_bigits = static_cast(bigits_.size()) - 1;\n while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits;\n bigits_.resize(to_unsigned(num_bigits + 1));\n }\n\n // Computes *this -= other assuming aligned bigints and *this >= other.\n FMT_CONSTEXPR void subtract_aligned(const bigint& other) {\n FMT_ASSERT(other.exp_ >= exp_, \"unaligned bigints\");\n FMT_ASSERT(compare(*this, other) >= 0, \"\");\n bigit borrow = 0;\n int i = other.exp_ - exp_;\n for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)\n subtract_bigits(i, other.bigits_[j], borrow);\n if (borrow != 0) subtract_bigits(i, 0, borrow);\n FMT_ASSERT(borrow == 0, \"\");\n remove_leading_zeros();\n }\n\n FMT_CONSTEXPR void multiply(uint32_t value) {\n bigit carry = 0;\n const double_bigit wide_value = value;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n double_bigit result = bigits_[i] * wide_value + carry;\n bigits_[i] = static_cast(result);\n carry = static_cast(result >> bigit_bits);\n }\n if (carry != 0) bigits_.push_back(carry);\n }\n\n template ::value ||\n std::is_same::value)>\n FMT_CONSTEXPR void multiply(UInt value) {\n using half_uint =\n conditional_t::value, uint64_t, uint32_t>;\n const int shift = num_bits() - bigit_bits;\n const UInt lower = static_cast(value);\n const UInt upper = value >> num_bits();\n UInt carry = 0;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n UInt result = lower * bigits_[i] + static_cast(carry);\n carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +\n (carry >> bigit_bits);\n bigits_[i] = static_cast(result);\n }\n while (carry != 0) {\n bigits_.push_back(static_cast(carry));\n carry >>= bigit_bits;\n }\n }\n\n template ::value ||\n std::is_same::value)>\n FMT_CONSTEXPR void assign(UInt n) {\n size_t num_bigits = 0;\n do {\n bigits_[num_bigits++] = static_cast(n);\n n >>= bigit_bits;\n } while (n != 0);\n bigits_.resize(num_bigits);\n exp_ = 0;\n }\n\n public:\n FMT_CONSTEXPR bigint() : exp_(0) {}\n explicit bigint(uint64_t n) { assign(n); }\n\n bigint(const bigint&) = delete;\n void operator=(const bigint&) = delete;\n\n FMT_CONSTEXPR void assign(const bigint& other) {\n auto size = other.bigits_.size();\n bigits_.resize(size);\n auto data = other.bigits_.data();\n copy(data, data + size, bigits_.data());\n exp_ = other.exp_;\n }\n\n template FMT_CONSTEXPR void operator=(Int n) {\n FMT_ASSERT(n > 0, \"\");\n assign(uint64_or_128_t(n));\n }\n\n FMT_CONSTEXPR auto num_bigits() const -> int {\n return static_cast(bigits_.size()) + exp_;\n }\n\n FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& {\n FMT_ASSERT(shift >= 0, \"\");\n exp_ += shift / bigit_bits;\n shift %= bigit_bits;\n if (shift == 0) return *this;\n bigit carry = 0;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n bigit c = bigits_[i] >> (bigit_bits - shift);\n bigits_[i] = (bigits_[i] << shift) + carry;\n carry = c;\n }\n if (carry != 0) bigits_.push_back(carry);\n return *this;\n }\n\n template FMT_CONSTEXPR auto operator*=(Int value) -> bigint& {\n FMT_ASSERT(value > 0, \"\");\n multiply(uint32_or_64_or_128_t(value));\n return *this;\n }\n\n friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int {\n int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits();\n if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1;\n int i = static_cast(b1.bigits_.size()) - 1;\n int j = static_cast(b2.bigits_.size()) - 1;\n int end = i - j;\n if (end < 0) end = 0;\n for (; i >= end; --i, --j) {\n bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j];\n if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1;\n }\n if (i != j) return i > j ? 1 : -1;\n return 0;\n }\n\n // Returns compare(lhs1 + lhs2, rhs).\n friend FMT_CONSTEXPR auto add_compare(const bigint& lhs1, const bigint& lhs2,\n const bigint& rhs) -> int {\n int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits());\n int num_rhs_bigits = rhs.num_bigits();\n if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;\n if (max_lhs_bigits > num_rhs_bigits) return 1;\n double_bigit borrow = 0;\n int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_);\n for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {\n double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i);\n bigit rhs_bigit = rhs.get_bigit(i);\n if (sum > rhs_bigit + borrow) return 1;\n borrow = rhs_bigit + borrow - sum;\n if (borrow > 1) return -1;\n borrow <<= bigit_bits;\n }\n return borrow != 0 ? -1 : 0;\n }\n\n // Assigns pow(10, exp) to this bigint.\n FMT_CONSTEXPR20 void assign_pow10(int exp) {\n FMT_ASSERT(exp >= 0, \"\");\n if (exp == 0) return *this = 1;\n int bitmask = 1 << (num_bits() -\n countl_zero(static_cast(exp)) - 1);\n // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by\n // repeated squaring and multiplication.\n *this = 5;\n bitmask >>= 1;\n while (bitmask != 0) {\n square();\n if ((exp & bitmask) != 0) *this *= 5;\n bitmask >>= 1;\n }\n *this <<= exp; // Multiply by pow(2, exp) by shifting.\n }\n\n FMT_CONSTEXPR20 void square() {\n int num_bigits = static_cast(bigits_.size());\n int num_result_bigits = 2 * num_bigits;\n basic_memory_buffer n(std::move(bigits_));\n bigits_.resize(to_unsigned(num_result_bigits));\n auto sum = uint128_t();\n for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {\n // Compute bigit at position bigit_index of the result by adding\n // cross-product terms n[i] * n[j] such that i + j == bigit_index.\n for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {\n // Most terms are multiplied twice which can be optimized in the future.\n sum += double_bigit(n[i]) * n[j];\n }\n bigits_[bigit_index] = static_cast(sum);\n sum >>= num_bits(); // Compute the carry.\n }\n // Do the same for the top half.\n for (int bigit_index = num_bigits; bigit_index < num_result_bigits;\n ++bigit_index) {\n for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)\n sum += double_bigit(n[i++]) * n[j--];\n bigits_[bigit_index] = static_cast(sum);\n sum >>= num_bits();\n }\n remove_leading_zeros();\n exp_ *= 2;\n }\n\n // If this bigint has a bigger exponent than other, adds trailing zero to make\n // exponents equal. This simplifies some operations such as subtraction.\n FMT_CONSTEXPR void align(const bigint& other) {\n int exp_difference = exp_ - other.exp_;\n if (exp_difference <= 0) return;\n int num_bigits = static_cast(bigits_.size());\n bigits_.resize(to_unsigned(num_bigits + exp_difference));\n for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)\n bigits_[j] = bigits_[i];\n fill_n(bigits_.data(), to_unsigned(exp_difference), 0U);\n exp_ -= exp_difference;\n }\n\n // Divides this bignum by divisor, assigning the remainder to this and\n // returning the quotient.\n FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {\n FMT_ASSERT(this != &divisor, \"\");\n if (compare(*this, divisor) < 0) return 0;\n FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, \"\");\n align(divisor);\n int quotient = 0;\n do {\n subtract_aligned(divisor);\n ++quotient;\n } while (compare(*this, divisor) >= 0);\n return quotient;\n }\n};\n\n// format_dragon flags.\nenum dragon {\n predecessor_closer = 1,\n fixup = 2, // Run fixup to correct exp10 which can be off by one.\n fixed = 4,\n};\n\n// Formats a floating-point number using a variation of the Fixed-Precision\n// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White:\n// https://fmt.dev/papers/p372-steele.pdf.\nFMT_CONSTEXPR20 inline void format_dragon(basic_fp value,\n unsigned flags, int num_digits,\n buffer& buf, int& exp10) {\n bigint numerator; // 2 * R in (FPP)^2.\n bigint denominator; // 2 * S in (FPP)^2.\n // lower and upper are differences between value and corresponding boundaries.\n bigint lower; // (M^- in (FPP)^2).\n bigint upper_store; // upper's value if different from lower.\n bigint* upper = nullptr; // (M^+ in (FPP)^2).\n // Shift numerator and denominator by an extra bit or two (if lower boundary\n // is closer) to make lower and upper integers. This eliminates multiplication\n // by 2 during later computations.\n bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;\n int shift = is_predecessor_closer ? 2 : 1;\n if (value.e >= 0) {\n numerator = value.f;\n numerator <<= value.e + shift;\n lower = 1;\n lower <<= value.e;\n if (is_predecessor_closer) {\n upper_store = 1;\n upper_store <<= value.e + 1;\n upper = &upper_store;\n }\n denominator.assign_pow10(exp10);\n denominator <<= shift;\n } else if (exp10 < 0) {\n numerator.assign_pow10(-exp10);\n lower.assign(numerator);\n if (is_predecessor_closer) {\n upper_store.assign(numerator);\n upper_store <<= 1;\n upper = &upper_store;\n }\n numerator *= value.f;\n numerator <<= shift;\n denominator = 1;\n denominator <<= shift - value.e;\n } else {\n numerator = value.f;\n numerator <<= shift;\n denominator.assign_pow10(exp10);\n denominator <<= shift - value.e;\n lower = 1;\n if (is_predecessor_closer) {\n upper_store = 1ULL << 1;\n upper = &upper_store;\n }\n }\n int even = static_cast((value.f & 1) == 0);\n if (!upper) upper = &lower;\n bool shortest = num_digits < 0;\n if ((flags & dragon::fixup) != 0) {\n if (add_compare(numerator, *upper, denominator) + even <= 0) {\n --exp10;\n numerator *= 10;\n if (num_digits < 0) {\n lower *= 10;\n if (upper != &lower) *upper *= 10;\n }\n }\n if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);\n }\n // Invariant: value == (numerator / denominator) * pow(10, exp10).\n if (shortest) {\n // Generate the shortest representation.\n num_digits = 0;\n char* data = buf.data();\n for (;;) {\n int digit = numerator.divmod_assign(denominator);\n bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.\n // numerator + upper >[=] pow10:\n bool high = add_compare(numerator, *upper, denominator) + even > 0;\n data[num_digits++] = static_cast('0' + digit);\n if (low || high) {\n if (!low) {\n ++data[num_digits - 1];\n } else if (high) {\n int result = add_compare(numerator, numerator, denominator);\n // Round half to even.\n if (result > 0 || (result == 0 && (digit % 2) != 0))\n ++data[num_digits - 1];\n }\n buf.try_resize(to_unsigned(num_digits));\n exp10 -= num_digits - 1;\n return;\n }\n numerator *= 10;\n lower *= 10;\n if (upper != &lower) *upper *= 10;\n }\n }\n // Generate the given number of digits.\n exp10 -= num_digits - 1;\n if (num_digits <= 0) {\n auto digit = '0';\n if (num_digits == 0) {\n denominator *= 10;\n digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';\n }\n buf.push_back(digit);\n return;\n }\n buf.try_resize(to_unsigned(num_digits));\n for (int i = 0; i < num_digits - 1; ++i) {\n int digit = numerator.divmod_assign(denominator);\n buf[i] = static_cast('0' + digit);\n numerator *= 10;\n }\n int digit = numerator.divmod_assign(denominator);\n auto result = add_compare(numerator, numerator, denominator);\n if (result > 0 || (result == 0 && (digit % 2) != 0)) {\n if (digit == 9) {\n const auto overflow = '0' + 10;\n buf[num_digits - 1] = overflow;\n // Propagate the carry.\n for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {\n buf[i] = '0';\n ++buf[i - 1];\n }\n if (buf[0] == overflow) {\n buf[0] = '1';\n if ((flags & dragon::fixed) != 0)\n buf.push_back('0');\n else\n ++exp10;\n }\n return;\n }\n ++digit;\n }\n buf[num_digits - 1] = static_cast('0' + digit);\n}\n\n// Formats a floating-point number using the hexfloat format.\ntemplate ::value)>\nFMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,\n buffer& buf) {\n // float is passed as double to reduce the number of instantiations and to\n // simplify implementation.\n static_assert(!std::is_same::value, \"\");\n\n using info = dragonbox::float_info;\n\n // Assume Float is in the format [sign][exponent][significand].\n using carrier_uint = typename info::carrier_uint;\n\n const auto num_float_significand_bits = detail::num_significand_bits();\n\n basic_fp f(value);\n f.e += num_float_significand_bits;\n if (!has_implicit_bit()) --f.e;\n\n const auto num_fraction_bits =\n num_float_significand_bits + (has_implicit_bit() ? 1 : 0);\n const auto num_xdigits = (num_fraction_bits + 3) / 4;\n\n const auto leading_shift = ((num_xdigits - 1) * 4);\n const auto leading_mask = carrier_uint(0xF) << leading_shift;\n const auto leading_xdigit =\n static_cast((f.f & leading_mask) >> leading_shift);\n if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);\n\n int print_xdigits = num_xdigits - 1;\n if (specs.precision >= 0 && print_xdigits > specs.precision) {\n const int shift = ((print_xdigits - specs.precision - 1) * 4);\n const auto mask = carrier_uint(0xF) << shift;\n const auto v = static_cast((f.f & mask) >> shift);\n\n if (v >= 8) {\n const auto inc = carrier_uint(1) << (shift + 4);\n f.f += inc;\n f.f &= ~(inc - 1);\n }\n\n // Check long double overflow\n if (!has_implicit_bit()) {\n const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;\n if ((f.f & implicit_bit) == implicit_bit) {\n f.f >>= 4;\n f.e += 4;\n }\n }\n\n print_xdigits = specs.precision;\n }\n\n char xdigits[num_bits() / 4];\n detail::fill_n(xdigits, sizeof(xdigits), '0');\n format_base2e(4, xdigits, f.f, num_xdigits, specs.upper());\n\n // Remove zero tail\n while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;\n\n buf.push_back('0');\n buf.push_back(specs.upper() ? 'X' : 'x');\n buf.push_back(xdigits[0]);\n if (specs.alt() || print_xdigits > 0 || print_xdigits < specs.precision)\n buf.push_back('.');\n buf.append(xdigits + 1, xdigits + 1 + print_xdigits);\n for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0');\n\n buf.push_back(specs.upper() ? 'P' : 'p');\n\n uint32_t abs_e;\n if (f.e < 0) {\n buf.push_back('-');\n abs_e = static_cast(-f.e);\n } else {\n buf.push_back('+');\n abs_e = static_cast(f.e);\n }\n format_decimal(appender(buf), abs_e, detail::count_digits(abs_e));\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,\n buffer& buf) {\n format_hexfloat(static_cast(value), specs, buf);\n}\n\nconstexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {\n // For checking rounding thresholds.\n // The kth entry is chosen to be the smallest integer such that the\n // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.\n // It is equal to ceil(2^31 + 2^32/10^(k + 1)).\n // These are stored in a string literal because we cannot have static arrays\n // in constexpr functions and non-static ones are poorly optimized.\n return U\"\\x9999999a\\x828f5c29\\x80418938\\x80068db9\\x8000a7c6\\x800010c7\"\n U\"\\x800001ae\\x8000002b\"[index];\n}\n\ntemplate \nFMT_CONSTEXPR20 auto format_float(Float value, int precision,\n const format_specs& specs, bool binary32,\n buffer& buf) -> int {\n // float is passed as double to reduce the number of instantiations.\n static_assert(!std::is_same::value, \"\");\n auto converted_value = convert_float(value);\n\n const bool fixed = specs.type() == presentation_type::fixed;\n if (value == 0) {\n if (precision <= 0 || !fixed) {\n buf.push_back('0');\n return 0;\n }\n buf.try_resize(to_unsigned(precision));\n fill_n(buf.data(), precision, '0');\n return -precision;\n }\n\n int exp = 0;\n bool use_dragon = true;\n unsigned dragon_flags = 0;\n if (!is_fast_float() || is_constant_evaluated()) {\n const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10)\n using info = dragonbox::float_info;\n const auto f = basic_fp(converted_value);\n // Compute exp, an approximate power of 10, such that\n // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).\n // This is based on log10(value) == log2(value) / log2(10) and approximation\n // of log2(value) by e + num_fraction_bits idea from double-conversion.\n auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;\n exp = static_cast(e);\n if (e > exp) ++exp; // Compute ceil.\n dragon_flags = dragon::fixup;\n } else {\n // Extract significand bits and exponent bits.\n using info = dragonbox::float_info;\n auto br = bit_cast(static_cast(value));\n\n const uint64_t significand_mask =\n (static_cast(1) << num_significand_bits()) - 1;\n uint64_t significand = (br & significand_mask);\n int exponent = static_cast((br & exponent_mask()) >>\n num_significand_bits());\n\n if (exponent != 0) { // Check if normal.\n exponent -= exponent_bias() + num_significand_bits();\n significand |=\n (static_cast(1) << num_significand_bits());\n significand <<= 1;\n } else {\n // Normalize subnormal inputs.\n FMT_ASSERT(significand != 0, \"zeros should not appear here\");\n int shift = countl_zero(significand);\n FMT_ASSERT(shift >= num_bits() - num_significand_bits(),\n \"\");\n shift -= (num_bits() - num_significand_bits() - 2);\n exponent = (std::numeric_limits::min_exponent -\n num_significand_bits()) -\n shift;\n significand <<= shift;\n }\n\n // Compute the first several nonzero decimal significand digits.\n // We call the number we get the first segment.\n const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);\n exp = -k;\n const int beta = exponent + dragonbox::floor_log2_pow10(k);\n uint64_t first_segment;\n bool has_more_segments;\n int digits_in_the_first_segment;\n {\n const auto r = dragonbox::umul192_upper128(\n significand << beta, dragonbox::get_cached_power(k));\n first_segment = r.high();\n has_more_segments = r.low() != 0;\n\n // The first segment can have 18 ~ 19 digits.\n if (first_segment >= 1000000000000000000ULL) {\n digits_in_the_first_segment = 19;\n } else {\n // When it is of 18-digits, we align it to 19-digits by adding a bogus\n // zero at the end.\n digits_in_the_first_segment = 18;\n first_segment *= 10;\n }\n }\n\n // Compute the actual number of decimal digits to print.\n if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);\n\n // Use Dragon4 only when there might be not enough digits in the first\n // segment.\n if (digits_in_the_first_segment > precision) {\n use_dragon = false;\n\n if (precision <= 0) {\n exp += digits_in_the_first_segment;\n\n if (precision < 0) {\n // Nothing to do, since all we have are just leading zeros.\n buf.try_resize(0);\n } else {\n // We may need to round-up.\n buf.try_resize(1);\n if ((first_segment | static_cast(has_more_segments)) >\n 5000000000000000000ULL) {\n buf[0] = '1';\n } else {\n buf[0] = '0';\n }\n }\n } // precision <= 0\n else {\n exp += digits_in_the_first_segment - precision;\n\n // When precision > 0, we divide the first segment into three\n // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits\n // in 32-bits which usually allows faster calculation than in\n // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize\n // division-by-constant for large 64-bit divisors, we do it here\n // manually. The magic number 7922816251426433760 below is equal to\n // ceil(2^(64+32) / 10^10).\n const uint32_t first_subsegment = static_cast(\n dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>\n 32);\n const uint64_t second_third_subsegments =\n first_segment - first_subsegment * 10000000000ULL;\n\n uint64_t prod;\n uint32_t digits;\n bool should_round_up;\n int number_of_digits_to_print = min_of(precision, 9);\n\n // Print a 9-digits subsegment, either the first or the second.\n auto print_subsegment = [&](uint32_t subsegment, char* buffer) {\n int number_of_digits_printed = 0;\n\n // If we want to print an odd number of digits from the subsegment,\n if ((number_of_digits_to_print & 1) != 0) {\n // Convert to 64-bit fixed-point fractional form with 1-digit\n // integer part. The magic number 720575941 is a good enough\n // approximation of 2^(32 + 24) / 10^8; see\n // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case\n // for details.\n prod = ((subsegment * static_cast(720575941)) >> 24) + 1;\n digits = static_cast(prod >> 32);\n *buffer = static_cast('0' + digits);\n number_of_digits_printed++;\n }\n // If we want to print an even number of digits from the\n // first_subsegment,\n else {\n // Convert to 64-bit fixed-point fractional form with 2-digits\n // integer part. The magic number 450359963 is a good enough\n // approximation of 2^(32 + 20) / 10^7; see\n // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case\n // for details.\n prod = ((subsegment * static_cast(450359963)) >> 20) + 1;\n digits = static_cast(prod >> 32);\n write2digits(buffer, digits);\n number_of_digits_printed += 2;\n }\n\n // Print all digit pairs.\n while (number_of_digits_printed < number_of_digits_to_print) {\n prod = static_cast(prod) * static_cast(100);\n digits = static_cast(prod >> 32);\n write2digits(buffer + number_of_digits_printed, digits);\n number_of_digits_printed += 2;\n }\n };\n\n // Print first subsegment.\n print_subsegment(first_subsegment, buf.data());\n\n // Perform rounding if the first subsegment is the last subsegment to\n // print.\n if (precision <= 9) {\n // Rounding inside the subsegment.\n // We round-up if:\n // - either the fractional part is strictly larger than 1/2, or\n // - the fractional part is exactly 1/2 and the last digit is odd.\n // We rely on the following observations:\n // - If fractional_part >= threshold, then the fractional part is\n // strictly larger than 1/2.\n // - If the MSB of fractional_part is set, then the fractional part\n // must be at least 1/2.\n // - When the MSB of fractional_part is set, either\n // second_third_subsegments being nonzero or has_more_segments\n // being true means there are further digits not printed, so the\n // fractional part is strictly larger than 1/2.\n if (precision < 9) {\n uint32_t fractional_part = static_cast(prod);\n should_round_up =\n fractional_part >= fractional_part_rounding_thresholds(\n 8 - number_of_digits_to_print) ||\n ((fractional_part >> 31) &\n ((digits & 1) | (second_third_subsegments != 0) |\n has_more_segments)) != 0;\n }\n // Rounding at the subsegment boundary.\n // In this case, the fractional part is at least 1/2 if and only if\n // second_third_subsegments >= 5000000000ULL, and is strictly larger\n // than 1/2 if we further have either second_third_subsegments >\n // 5000000000ULL or has_more_segments == true.\n else {\n should_round_up = second_third_subsegments > 5000000000ULL ||\n (second_third_subsegments == 5000000000ULL &&\n ((digits & 1) != 0 || has_more_segments));\n }\n }\n // Otherwise, print the second subsegment.\n else {\n // Compilers are not aware of how to leverage the maximum value of\n // second_third_subsegments to find out a better magic number which\n // allows us to eliminate an additional shift. 1844674407370955162 =\n // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).\n const uint32_t second_subsegment =\n static_cast(dragonbox::umul128_upper64(\n second_third_subsegments, 1844674407370955162ULL));\n const uint32_t third_subsegment =\n static_cast(second_third_subsegments) -\n second_subsegment * 10;\n\n number_of_digits_to_print = precision - 9;\n print_subsegment(second_subsegment, buf.data() + 9);\n\n // Rounding inside the subsegment.\n if (precision < 18) {\n // The condition third_subsegment != 0 implies that the segment was\n // of 19 digits, so in this case the third segment should be\n // consisting of a genuine digit from the input.\n uint32_t fractional_part = static_cast(prod);\n should_round_up =\n fractional_part >= fractional_part_rounding_thresholds(\n 8 - number_of_digits_to_print) ||\n ((fractional_part >> 31) &\n ((digits & 1) | (third_subsegment != 0) |\n has_more_segments)) != 0;\n }\n // Rounding at the subsegment boundary.\n else {\n // In this case, the segment must be of 19 digits, thus\n // the third subsegment should be consisting of a genuine digit from\n // the input.\n should_round_up = third_subsegment > 5 ||\n (third_subsegment == 5 &&\n ((digits & 1) != 0 || has_more_segments));\n }\n }\n\n // Round-up if necessary.\n if (should_round_up) {\n ++buf[precision - 1];\n for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {\n buf[i] = '0';\n ++buf[i - 1];\n }\n if (buf[0] > '9') {\n buf[0] = '1';\n if (fixed)\n buf[precision++] = '0';\n else\n ++exp;\n }\n }\n buf.try_resize(to_unsigned(precision));\n }\n } // if (digits_in_the_first_segment > precision)\n else {\n // Adjust the exponent for its use in Dragon4.\n exp += digits_in_the_first_segment - 1;\n }\n }\n if (use_dragon) {\n auto f = basic_fp();\n bool is_predecessor_closer = binary32 ? f.assign(static_cast(value))\n : f.assign(converted_value);\n if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;\n if (fixed) dragon_flags |= dragon::fixed;\n // Limit precision to the maximum possible number of significant digits in\n // an IEEE754 double because we don't need to generate zeros.\n const int max_double_digits = 767;\n if (precision > max_double_digits) precision = max_double_digits;\n format_dragon(f, dragon_flags, precision, buf, exp);\n }\n if (!fixed && !specs.alt()) {\n // Remove trailing zeros.\n auto num_digits = buf.size();\n while (num_digits > 0 && buf[num_digits - 1] == '0') {\n --num_digits;\n ++exp;\n }\n buf.try_resize(num_digits);\n }\n return exp;\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs,\n locale_ref loc = {}) -> OutputIt {\n if (specs.localized() && write_loc(out, value, specs, loc)) return out;\n\n // Use signbit because value < 0 is false for NaN.\n sign s = detail::signbit(value) ? sign::minus : specs.sign();\n\n if (!detail::isfinite(value))\n return write_nonfinite(out, detail::isnan(value), specs, s);\n\n if (specs.align() == align::numeric && s != sign::none) {\n *out++ = detail::getsign(s);\n s = sign::none;\n if (specs.width != 0) --specs.width;\n }\n\n const int exp_upper = detail::exp_upper();\n int precision = specs.precision;\n if (precision < 0) {\n if (specs.type() != presentation_type::none) {\n precision = 6;\n } else if (is_fast_float::value && !is_constant_evaluated()) {\n // Use Dragonbox for the shortest format.\n auto dec = dragonbox::to_decimal(static_cast>(value));\n return write_float(out, dec, specs, s, exp_upper, loc);\n }\n }\n\n memory_buffer buffer;\n if (specs.type() == presentation_type::hexfloat) {\n if (s != sign::none) buffer.push_back(detail::getsign(s));\n format_hexfloat(convert_float(value), specs, buffer);\n return write_bytes(out, {buffer.data(), buffer.size()},\n specs);\n }\n\n if (specs.type() == presentation_type::exp) {\n if (precision == max_value())\n report_error(\"number is too big\");\n else\n ++precision;\n if (specs.precision != 0) specs.set_alt();\n } else if (specs.type() == presentation_type::fixed) {\n if (specs.precision != 0) specs.set_alt();\n } else if (precision == 0) {\n precision = 1;\n }\n int exp = format_float(convert_float(value), precision, specs,\n std::is_same(), buffer);\n\n specs.precision = precision;\n auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp};\n return write_float(out, f, specs, s, exp_upper, loc);\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {\n if (is_constant_evaluated()) return write(out, value, format_specs());\n\n auto s = detail::signbit(value) ? sign::minus : sign::none;\n auto mask = exponent_mask>();\n if ((bit_cast(value) & mask) == mask)\n return write_nonfinite(out, std::isnan(value), {}, s);\n\n auto dec = dragonbox::to_decimal(static_cast>(value));\n auto significand = dec.significand;\n int significand_size = count_digits(significand);\n int exponent = dec.exponent + significand_size - 1;\n if (use_fixed(exponent, detail::exp_upper())) {\n return write_fixed>(\n out, dec, significand_size, Char('.'), {}, s);\n }\n\n // Write value in the exponential format.\n const char* prefix = \"e+\";\n int abs_exponent = exponent;\n if (exponent < 0) {\n abs_exponent = -exponent;\n prefix = \"e-\";\n }\n auto has_decimal_point = significand_size != 1;\n size_t size = std::is_pointer::value\n ? 0u\n : to_unsigned((s != sign::none ? 1 : 0) + significand_size +\n (has_decimal_point ? 1 : 0) +\n (abs_exponent >= 100 ? 5 : 4));\n if (auto ptr = to_pointer(out, size)) {\n if (s != sign::none) *ptr++ = Char('-');\n if (has_decimal_point) {\n auto begin = ptr;\n ptr = format_decimal(ptr, significand, significand_size + 1);\n *begin = begin[1];\n begin[1] = '.';\n } else {\n *ptr++ = static_cast('0' + significand);\n }\n if (std::is_same::value) {\n memcpy(ptr, prefix, 2);\n ptr += 2;\n } else {\n *ptr++ = prefix[0];\n *ptr++ = prefix[1];\n }\n if (abs_exponent >= 100) {\n *ptr++ = static_cast('0' + abs_exponent / 100);\n abs_exponent %= 100;\n }\n write2digits(ptr, static_cast(abs_exponent));\n return select::value>(ptr + 2, out);\n }\n auto it = reserve(out, size);\n if (s != sign::none) *it++ = Char('-');\n // Insert a decimal point after the first digit and add an exponent.\n it = write_significand(it, significand, significand_size, 1,\n has_decimal_point ? Char('.') : Char());\n *it++ = Char('e');\n it = write_exponent(exponent, it);\n return base_iterator(out, it);\n}\n\ntemplate ::value &&\n !is_fast_float::value)>\ninline auto write(OutputIt out, T value) -> OutputIt {\n return write(out, value, {});\n}\n\ntemplate \nauto write(OutputIt out, monostate, format_specs = {}, locale_ref = {})\n -> OutputIt {\n FMT_ASSERT(false, \"\");\n return out;\n}\n\ntemplate \nFMT_CONSTEXPR auto write(OutputIt out, basic_string_view value)\n -> OutputIt {\n return copy_noinline(value.begin(), value.end(), out);\n}\n\ntemplate ::value)>\nconstexpr auto write(OutputIt out, const T& value) -> OutputIt {\n return write(out, to_string_view(value));\n}\n\n// FMT_ENABLE_IF() condition separated to workaround an MSVC bug.\ntemplate <\n typename Char, typename OutputIt, typename T,\n bool check = std::is_enum::value && !std::is_same::value &&\n mapped_type_constant::value != type::custom_type,\n FMT_ENABLE_IF(check)>\nFMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {\n return write(out, static_cast>(value));\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {},\n locale_ref = {}) -> OutputIt {\n return specs.type() != presentation_type::none &&\n specs.type() != presentation_type::string\n ? write(out, value ? 1 : 0, specs, {})\n : write_bytes(out, value ? \"true\" : \"false\", specs);\n}\n\ntemplate \nFMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {\n auto it = reserve(out, 1);\n *it++ = value;\n return base_iterator(out, it);\n}\n\ntemplate \nFMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt {\n if (value) return write(out, basic_string_view(value));\n report_error(\"string pointer is null\");\n return out;\n}\n\ntemplate ::value)>\nauto write(OutputIt out, const T* value, const format_specs& specs = {},\n locale_ref = {}) -> OutputIt {\n return write_ptr(out, bit_cast(value), &specs);\n}\n\ntemplate ::value ==\n type::custom_type &&\n !std::is_fundamental::value)>\nFMT_CONSTEXPR auto write(OutputIt out, const T& value) -> OutputIt {\n auto f = formatter();\n auto parse_ctx = parse_context({});\n f.parse(parse_ctx);\n auto ctx = basic_format_context(out, {}, {});\n return f.format(value, ctx);\n}\n\ntemplate \nusing is_builtin =\n bool_constant::value || FMT_BUILTIN_TYPES>;\n\n// An argument visitor that formats the argument and writes it via the output\n// iterator. It's a class and not a generic lambda for compatibility with C++11.\ntemplate struct default_arg_formatter {\n using context = buffered_context;\n\n basic_appender out;\n\n void operator()(monostate) { report_error(\"argument not found\"); }\n\n template ::value)>\n void operator()(T value) {\n write(out, value);\n }\n\n template ::value)>\n void operator()(T) {\n FMT_ASSERT(false, \"\");\n }\n\n void operator()(typename basic_format_arg::handle h) {\n // Use a null locale since the default format must be unlocalized.\n auto parse_ctx = parse_context({});\n auto format_ctx = context(out, {}, {});\n h.format(parse_ctx, format_ctx);\n }\n};\n\ntemplate struct arg_formatter {\n basic_appender out;\n const format_specs& specs;\n FMT_NO_UNIQUE_ADDRESS locale_ref locale;\n\n template ::value)>\n FMT_CONSTEXPR FMT_INLINE void operator()(T value) {\n detail::write(out, value, specs, locale);\n }\n\n template ::value)>\n void operator()(T) {\n FMT_ASSERT(false, \"\");\n }\n\n void operator()(typename basic_format_arg>::handle) {\n // User-defined types are handled separately because they require access\n // to the parse context.\n }\n};\n\nstruct dynamic_spec_getter {\n template ::value)>\n FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {\n return is_negative(value) ? ~0ull : static_cast(value);\n }\n\n template ::value)>\n FMT_CONSTEXPR auto operator()(T) -> unsigned long long {\n report_error(\"width/precision is not integer\");\n return 0;\n }\n};\n\ntemplate \nFMT_CONSTEXPR void handle_dynamic_spec(\n arg_id_kind kind, int& value,\n const arg_ref& ref, Context& ctx) {\n if (kind == arg_id_kind::none) return;\n auto arg =\n kind == arg_id_kind::index ? ctx.arg(ref.index) : ctx.arg(ref.name);\n if (!arg) report_error(\"argument not found\");\n unsigned long long result = arg.visit(dynamic_spec_getter());\n if (result > to_unsigned(max_value()))\n report_error(\"width/precision is out of range\");\n value = static_cast(result);\n}\n\n#if FMT_USE_NONTYPE_TEMPLATE_ARGS\ntemplate Str>\nstruct static_named_arg : view {\n static constexpr auto name = Str.data;\n\n const T& value;\n static_named_arg(const T& v) : value(v) {}\n};\n\ntemplate Str>\nstruct is_named_arg> : std::true_type {};\n\ntemplate Str>\nstruct is_static_named_arg> : std::true_type {\n};\n\ntemplate Str>\nstruct udl_arg {\n template auto operator=(T&& value) const {\n return static_named_arg(std::forward(value));\n }\n};\n#else\ntemplate struct udl_arg {\n const Char* str;\n\n template auto operator=(T&& value) const -> named_arg {\n return {str, std::forward(value)};\n }\n};\n#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS\n\ntemplate struct format_handler {\n parse_context parse_ctx;\n buffered_context ctx;\n\n void on_text(const Char* begin, const Char* end) {\n copy_noinline(begin, end, ctx.out());\n }\n\n FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }\n FMT_CONSTEXPR auto on_arg_id(int id) -> int {\n parse_ctx.check_arg_id(id);\n return id;\n }\n FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int {\n parse_ctx.check_arg_id(id);\n int arg_id = ctx.arg_id(id);\n if (arg_id < 0) report_error(\"argument not found\");\n return arg_id;\n }\n\n FMT_INLINE void on_replacement_field(int id, const Char*) {\n ctx.arg(id).visit(default_arg_formatter{ctx.out()});\n }\n\n auto on_format_specs(int id, const Char* begin, const Char* end)\n -> const Char* {\n auto arg = ctx.arg(id);\n if (!arg) report_error(\"argument not found\");\n // Not using a visitor for custom types gives better codegen.\n if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();\n\n auto specs = dynamic_format_specs();\n begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());\n if (specs.dynamic()) {\n handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,\n ctx);\n handle_dynamic_spec(specs.dynamic_precision(), specs.precision,\n specs.precision_ref, ctx);\n }\n\n arg.visit(arg_formatter{ctx.out(), specs, ctx.locale()});\n return begin;\n }\n\n FMT_NORETURN void on_error(const char* message) { report_error(message); }\n};\n\n// It is used in format-inl.h and os.cc.\nusing format_func = void (*)(detail::buffer&, int, const char*);\nFMT_API void do_report_error(format_func func, int error_code,\n const char* message) noexcept;\n\nFMT_API void format_error_code(buffer& out, int error_code,\n string_view message) noexcept;\n\ntemplate \ntemplate \nFMT_CONSTEXPR auto native_formatter::format(\n const T& val, FormatContext& ctx) const -> decltype(ctx.out()) {\n if (!specs_.dynamic())\n return write(ctx.out(), val, specs_, ctx.locale());\n auto specs = format_specs(specs_);\n handle_dynamic_spec(specs.dynamic_width(), specs.width, specs_.width_ref,\n ctx);\n handle_dynamic_spec(specs.dynamic_precision(), specs.precision,\n specs_.precision_ref, ctx);\n return write(ctx.out(), val, specs, ctx.locale());\n}\n} // namespace detail\n\nFMT_BEGIN_EXPORT\n\n// A generic formatting context with custom output iterator and character\n// (code unit) support. Char is the format string code unit type which can be\n// different from OutputIt::value_type.\ntemplate class generic_context {\n private:\n OutputIt out_;\n basic_format_args args_;\n locale_ref loc_;\n\n public:\n using char_type = Char;\n using iterator = OutputIt;\n enum { builtin_types = FMT_BUILTIN_TYPES };\n\n constexpr generic_context(OutputIt out,\n basic_format_args args,\n locale_ref loc = {})\n : out_(out), args_(args), loc_(loc) {}\n generic_context(generic_context&&) = default;\n generic_context(const generic_context&) = delete;\n void operator=(const generic_context&) = delete;\n\n constexpr auto arg(int id) const -> basic_format_arg {\n return args_.get(id);\n }\n auto arg(basic_string_view name) const\n -> basic_format_arg {\n return args_.get(name);\n }\n constexpr auto arg_id(basic_string_view name) const -> int {\n return args_.get_id(name);\n }\n\n constexpr auto out() const -> iterator { return out_; }\n\n void advance_to(iterator it) {\n if (!detail::is_back_insert_iterator()) out_ = it;\n }\n\n constexpr auto locale() const -> locale_ref { return loc_; }\n};\n\nclass loc_value {\n private:\n basic_format_arg value_;\n\n public:\n template ::value)>\n loc_value(T value) : value_(value) {}\n\n template ::value)>\n loc_value(T) {}\n\n template auto visit(Visitor&& vis) -> decltype(vis(0)) {\n return value_.visit(vis);\n }\n};\n\n// A locale facet that formats values in UTF-8.\n// It is parameterized on the locale to avoid the heavy include.\ntemplate class format_facet : public Locale::facet {\n private:\n std::string separator_;\n std::string grouping_;\n std::string decimal_point_;\n\n protected:\n virtual auto do_put(appender out, loc_value val,\n const format_specs& specs) const -> bool;\n\n public:\n static FMT_API typename Locale::id id;\n\n explicit format_facet(Locale& loc);\n explicit format_facet(string_view sep = \"\", std::string grouping = \"\\3\",\n std::string decimal_point = \".\")\n : separator_(sep.data(), sep.size()),\n grouping_(grouping),\n decimal_point_(decimal_point) {}\n\n auto put(appender out, loc_value val, const format_specs& specs) const\n -> bool {\n return do_put(out, val, specs);\n }\n};\n\n#define FMT_FORMAT_AS(Type, Base) \\\n template \\\n struct formatter : formatter { \\\n template \\\n FMT_CONSTEXPR auto format(Type value, FormatContext& ctx) const \\\n -> decltype(ctx.out()) { \\\n return formatter::format(value, ctx); \\\n } \\\n }\n\nFMT_FORMAT_AS(signed char, int);\nFMT_FORMAT_AS(unsigned char, unsigned);\nFMT_FORMAT_AS(short, int);\nFMT_FORMAT_AS(unsigned short, unsigned);\nFMT_FORMAT_AS(long, detail::long_type);\nFMT_FORMAT_AS(unsigned long, detail::ulong_type);\nFMT_FORMAT_AS(Char*, const Char*);\nFMT_FORMAT_AS(detail::std_string_view, basic_string_view);\nFMT_FORMAT_AS(std::nullptr_t, const void*);\nFMT_FORMAT_AS(void*, const void*);\n\ntemplate \nstruct formatter : formatter, Char> {};\n\ntemplate \nclass formatter, Char>\n : public formatter, Char> {};\n\ntemplate \nstruct formatter, Char> : formatter {};\ntemplate \nstruct formatter, Char>\n : formatter {};\n\ntemplate \nstruct formatter\n : detail::native_formatter {};\n\ntemplate \nstruct formatter>>\n : formatter, Char> {\n template \n FMT_CONSTEXPR auto format(const T& value, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto&& val = format_as(value); // Make an lvalue reference for format.\n return formatter, Char>::format(val, ctx);\n }\n};\n\n/**\n * Converts `p` to `const void*` for pointer formatting.\n *\n * **Example**:\n *\n * auto s = fmt::format(\"{}\", fmt::ptr(p));\n */\ntemplate auto ptr(T p) -> const void* {\n static_assert(std::is_pointer::value, \"fmt::ptr used with non-pointer\");\n return detail::bit_cast(p);\n}\n\n/**\n * Converts `e` to the underlying type.\n *\n * **Example**:\n *\n * enum class color { red, green, blue };\n * auto s = fmt::format(\"{}\", fmt::underlying(color::red)); // s == \"0\"\n */\ntemplate \nconstexpr auto underlying(Enum e) noexcept -> underlying_t {\n return static_cast>(e);\n}\n\nnamespace enums {\ntemplate ::value)>\nconstexpr auto format_as(Enum e) noexcept -> underlying_t {\n return static_cast>(e);\n}\n} // namespace enums\n\n#ifdef __cpp_lib_byte\ntemplate \nstruct formatter : formatter {\n static auto format_as(std::byte b) -> unsigned char {\n return static_cast(b);\n }\n template \n auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) {\n return formatter::format(format_as(b), ctx);\n }\n};\n#endif\n\nstruct bytes {\n string_view data;\n\n inline explicit bytes(string_view s) : data(s) {}\n};\n\ntemplate <> struct formatter {\n private:\n detail::dynamic_format_specs<> specs_;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {\n return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,\n detail::type::string_type);\n }\n\n template \n auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto specs = specs_;\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,\n specs.width_ref, ctx);\n detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,\n specs.precision_ref, ctx);\n return detail::write_bytes(ctx.out(), b.data, specs);\n }\n};\n\n// group_digits_view is not derived from view because it copies the argument.\ntemplate struct group_digits_view {\n T value;\n};\n\n/**\n * Returns a view that formats an integer value using ',' as a\n * locale-independent thousands separator.\n *\n * **Example**:\n *\n * fmt::print(\"{}\", fmt::group_digits(12345));\n * // Output: \"12,345\"\n */\ntemplate auto group_digits(T value) -> group_digits_view {\n return {value};\n}\n\ntemplate struct formatter> : formatter {\n private:\n detail::dynamic_format_specs<> specs_;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {\n return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,\n detail::type::int_type);\n }\n\n template \n auto format(group_digits_view view, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto specs = specs_;\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,\n specs.width_ref, ctx);\n detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,\n specs.precision_ref, ctx);\n auto arg = detail::make_write_int_arg(view.value, specs.sign());\n return detail::write_int(\n ctx.out(), static_cast>(arg.abs_value),\n arg.prefix, specs, detail::digit_grouping(\"\\3\", \",\"));\n }\n};\n\ntemplate struct nested_view {\n const formatter* fmt;\n const T* value;\n};\n\ntemplate \nstruct formatter, Char> {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return ctx.begin();\n }\n template \n auto format(nested_view view, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return view.fmt->format(*view.value, ctx);\n }\n};\n\ntemplate struct nested_formatter {\n private:\n basic_specs specs_;\n int width_;\n formatter formatter_;\n\n public:\n constexpr nested_formatter() : width_(0) {}\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it == end) return it;\n auto specs = format_specs();\n it = detail::parse_align(it, end, specs);\n specs_ = specs;\n Char c = *it;\n auto width_ref = detail::arg_ref();\n if ((c >= '0' && c <= '9') || c == '{') {\n it = detail::parse_width(it, end, specs, width_ref, ctx);\n width_ = specs.width;\n }\n ctx.advance_to(it);\n return formatter_.parse(ctx);\n }\n\n template \n auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) {\n if (width_ == 0) return write(ctx.out());\n auto buf = basic_memory_buffer();\n write(basic_appender(buf));\n auto specs = format_specs();\n specs.width = width_;\n specs.copy_fill_from(specs_);\n specs.set_align(specs_.align());\n return detail::write(\n ctx.out(), basic_string_view(buf.data(), buf.size()), specs);\n }\n\n auto nested(const T& value) const -> nested_view {\n return nested_view{&formatter_, &value};\n }\n};\n\ninline namespace literals {\n#if FMT_USE_NONTYPE_TEMPLATE_ARGS\ntemplate constexpr auto operator\"\"_a() {\n using char_t = remove_cvref_t;\n return detail::udl_arg();\n}\n#else\n/**\n * User-defined literal equivalent of `fmt::arg`.\n *\n * **Example**:\n *\n * using namespace fmt::literals;\n * fmt::print(\"The answer is {answer}.\", \"answer\"_a=42);\n */\nconstexpr auto operator\"\"_a(const char* s, size_t) -> detail::udl_arg {\n return {s};\n}\n#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS\n} // namespace literals\n\n/// A fast integer formatter.\nclass format_int {\n private:\n // Buffer should be large enough to hold all digits (digits10 + 1),\n // a sign and a null character.\n enum { buffer_size = std::numeric_limits::digits10 + 3 };\n mutable char buffer_[buffer_size];\n char* str_;\n\n template \n FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* {\n auto n = static_cast>(value);\n return detail::do_format_decimal(buffer_, n, buffer_size - 1);\n }\n\n template \n FMT_CONSTEXPR20 auto format_signed(Int value) -> char* {\n auto abs_value = static_cast>(value);\n bool negative = value < 0;\n if (negative) abs_value = 0 - abs_value;\n auto begin = format_unsigned(abs_value);\n if (negative) *--begin = '-';\n return begin;\n }\n\n public:\n FMT_CONSTEXPR20 explicit format_int(int value) : str_(format_signed(value)) {}\n FMT_CONSTEXPR20 explicit format_int(long value)\n : str_(format_signed(value)) {}\n FMT_CONSTEXPR20 explicit format_int(long long value)\n : str_(format_signed(value)) {}\n FMT_CONSTEXPR20 explicit format_int(unsigned value)\n : str_(format_unsigned(value)) {}\n FMT_CONSTEXPR20 explicit format_int(unsigned long value)\n : str_(format_unsigned(value)) {}\n FMT_CONSTEXPR20 explicit format_int(unsigned long long value)\n : str_(format_unsigned(value)) {}\n\n /// Returns the number of characters written to the output buffer.\n FMT_CONSTEXPR20 auto size() const -> size_t {\n return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);\n }\n\n /// Returns a pointer to the output buffer content. No terminating null\n /// character is appended.\n FMT_CONSTEXPR20 auto data() const -> const char* { return str_; }\n\n /// Returns a pointer to the output buffer content with terminating null\n /// character appended.\n FMT_CONSTEXPR20 auto c_str() const -> const char* {\n buffer_[buffer_size - 1] = '\\0';\n return str_;\n }\n\n /// Returns the content of the output buffer as an `std::string`.\n inline auto str() const -> std::string { return {str_, size()}; }\n};\n\n#if FMT_CLANG_ANALYZER\n# define FMT_STRING_IMPL(s, base) s\n#else\n# define FMT_STRING_IMPL(s, base) \\\n [] { \\\n /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \\\n /* Use a macro-like name to avoid shadowing warnings. */ \\\n struct FMT_VISIBILITY(\"hidden\") FMT_COMPILE_STRING : base { \\\n using char_type = fmt::remove_cvref_t; \\\n constexpr explicit operator fmt::basic_string_view() \\\n const { \\\n return fmt::detail::compile_string_to_view(s); \\\n } \\\n }; \\\n using FMT_STRING_VIEW = \\\n fmt::basic_string_view; \\\n fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING())); \\\n return FMT_COMPILE_STRING(); \\\n }()\n#endif // FMT_CLANG_ANALYZER\n\n/**\n * Constructs a legacy compile-time format string from a string literal `s`.\n *\n * **Example**:\n *\n * // A compile-time error because 'd' is an invalid specifier for strings.\n * std::string s = fmt::format(FMT_STRING(\"{:d}\"), \"foo\");\n */\n#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string)\n\nFMT_API auto vsystem_error(int error_code, string_view fmt, format_args args)\n -> std::system_error;\n\n/**\n * Constructs `std::system_error` with a message formatted with\n * `fmt::format(fmt, args...)`.\n * `error_code` is a system error code as given by `errno`.\n *\n * **Example**:\n *\n * // This throws std::system_error with the description\n * // cannot open file 'madeup': No such file or directory\n * // or similar (system message may vary).\n * const char* filename = \"madeup\";\n * FILE* file = fopen(filename, \"r\");\n * if (!file)\n * throw fmt::system_error(errno, \"cannot open file '{}'\", filename);\n */\ntemplate \nauto system_error(int error_code, format_string fmt, T&&... args)\n -> std::system_error {\n return vsystem_error(error_code, fmt.str, vargs{{args...}});\n}\n\n/**\n * Formats an error message for an error returned by an operating system or a\n * language runtime, for example a file opening error, and writes it to `out`.\n * The format is the same as the one used by `std::system_error(ec, message)`\n * where `ec` is `std::error_code(error_code, std::generic_category())`.\n * It is implementation-defined but normally looks like:\n *\n * : \n *\n * where `` is the passed message and `` is the system\n * message corresponding to the error code.\n * `error_code` is a system error code as given by `errno`.\n */\nFMT_API void format_system_error(detail::buffer& out, int error_code,\n const char* message) noexcept;\n\n// Reports a system error without throwing an exception.\n// Can be used to report errors from destructors.\nFMT_API void report_system_error(int error_code, const char* message) noexcept;\n\ninline auto vformat(locale_ref loc, string_view fmt, format_args args)\n -> std::string {\n auto buf = memory_buffer();\n detail::vformat_to(buf, fmt, args, loc);\n return {buf.data(), buf.size()};\n}\n\ntemplate \nFMT_INLINE auto format(locale_ref loc, format_string fmt, T&&... args)\n -> std::string {\n return vformat(loc, fmt.str, vargs{{args...}});\n}\n\ntemplate ::value)>\nauto vformat_to(OutputIt out, locale_ref loc, string_view fmt, format_args args)\n -> OutputIt {\n auto&& buf = detail::get_buffer(out);\n detail::vformat_to(buf, fmt, args, loc);\n return detail::get_iterator(buf, out);\n}\n\ntemplate ::value)>\nFMT_INLINE auto format_to(OutputIt out, locale_ref loc, format_string fmt,\n T&&... args) -> OutputIt {\n return fmt::vformat_to(out, loc, fmt.str, vargs{{args...}});\n}\n\ntemplate \nFMT_NODISCARD FMT_INLINE auto formatted_size(locale_ref loc,\n format_string fmt,\n T&&... args) -> size_t {\n auto buf = detail::counting_buffer<>();\n detail::vformat_to(buf, fmt.str, vargs{{args...}}, loc);\n return buf.count();\n}\n\nFMT_API auto vformat(string_view fmt, format_args args) -> std::string;\n\n/**\n * Formats `args` according to specifications in `fmt` and returns the result\n * as a string.\n *\n * **Example**:\n *\n * #include \n * std::string message = fmt::format(\"The answer is {}.\", 42);\n */\ntemplate \nFMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args)\n -> std::string {\n return vformat(fmt.str, vargs{{args...}});\n}\n\n/**\n * Converts `value` to `std::string` using the default format for type `T`.\n *\n * **Example**:\n *\n * std::string answer = fmt::to_string(42);\n */\ntemplate ::value)>\nFMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(T value) -> std::string {\n // The buffer should be large enough to store the number including the sign\n // or \"false\" for bool.\n char buffer[max_of(detail::digits10() + 2, 5)];\n return {buffer, detail::write(buffer, value)};\n}\n\ntemplate ::value)>\nFMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(const T& value)\n -> std::string {\n return to_string(format_as(value));\n}\n\ntemplate ::value &&\n !detail::use_format_as::value)>\nFMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(const T& value)\n -> std::string {\n auto buffer = memory_buffer();\n detail::write(appender(buffer), value);\n return {buffer.data(), buffer.size()};\n}\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#ifdef FMT_HEADER_ONLY\n# define FMT_FUNC inline\n# include \"format-inl.h\"\n#endif\n\n// Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES.\n#ifdef FMT_REMOVE_TRANSITIVE_INCLUDES\n# undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES\n#endif\n\n#endif // FMT_FORMAT_H_\n" }, { "path": "include/spdlog/fmt/bundled/os.h", "content": "// Formatting library for C++ - optional OS-specific functionality\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_OS_H_\n#define FMT_OS_H_\n\n#include \"format.h\"\n\n#ifndef FMT_MODULE\n# include \n# include \n# include \n# include // std::system_error\n\n# if FMT_HAS_INCLUDE()\n# include // LC_NUMERIC_MASK on macOS\n# endif\n#endif // FMT_MODULE\n\n#ifndef FMT_USE_FCNTL\n// UWP doesn't provide _pipe.\n# if FMT_HAS_INCLUDE(\"winapifamily.h\")\n# include \n# endif\n# if (FMT_HAS_INCLUDE() || defined(__APPLE__) || \\\n defined(__linux__)) && \\\n (!defined(WINAPI_FAMILY) || \\\n (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) && \\\n !defined(__wasm__)\n# include // for O_RDONLY\n# define FMT_USE_FCNTL 1\n# else\n# define FMT_USE_FCNTL 0\n# endif\n#endif\n\n#ifndef FMT_POSIX\n# if defined(_WIN32) && !defined(__MINGW32__)\n// Fix warnings about deprecated symbols.\n# define FMT_POSIX(call) _##call\n# else\n# define FMT_POSIX(call) call\n# endif\n#endif\n\n// Calls to system functions are wrapped in FMT_SYSTEM for testability.\n#ifdef FMT_SYSTEM\n# define FMT_HAS_SYSTEM\n# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)\n#else\n# define FMT_SYSTEM(call) ::call\n# ifdef _WIN32\n// Fix warnings about deprecated symbols.\n# define FMT_POSIX_CALL(call) ::_##call\n# else\n# define FMT_POSIX_CALL(call) ::call\n# endif\n#endif\n\n// Retries the expression while it evaluates to error_result and errno\n// equals to EINTR.\n#ifndef _WIN32\n# define FMT_RETRY_VAL(result, expression, error_result) \\\n do { \\\n (result) = (expression); \\\n } while ((result) == (error_result) && errno == EINTR)\n#else\n# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)\n#endif\n\n#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)\n\nFMT_BEGIN_NAMESPACE\nFMT_BEGIN_EXPORT\n\n/**\n * A reference to a null-terminated string. It can be constructed from a C\n * string or `std::string`.\n *\n * You can use one of the following type aliases for common character types:\n *\n * +---------------+-----------------------------+\n * | Type | Definition |\n * +===============+=============================+\n * | cstring_view | basic_cstring_view |\n * +---------------+-----------------------------+\n * | wcstring_view | basic_cstring_view |\n * +---------------+-----------------------------+\n *\n * This class is most useful as a parameter type for functions that wrap C APIs.\n */\ntemplate class basic_cstring_view {\n private:\n const Char* data_;\n\n public:\n /// Constructs a string reference object from a C string.\n basic_cstring_view(const Char* s) : data_(s) {}\n\n /// Constructs a string reference from an `std::string` object.\n basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {}\n\n /// Returns the pointer to a C string.\n auto c_str() const -> const Char* { return data_; }\n};\n\nusing cstring_view = basic_cstring_view;\nusing wcstring_view = basic_cstring_view;\n\n#ifdef _WIN32\nFMT_API const std::error_category& system_category() noexcept;\n\nnamespace detail {\nFMT_API void format_windows_error(buffer& out, int error_code,\n const char* message) noexcept;\n}\n\nFMT_API std::system_error vwindows_error(int error_code, string_view fmt,\n format_args args);\n\n/**\n * Constructs a `std::system_error` object with the description of the form\n *\n * : \n *\n * where `` is the formatted message and `` is the\n * system message corresponding to the error code.\n * `error_code` is a Windows error code as given by `GetLastError`.\n * If `error_code` is not a valid error code such as -1, the system message\n * will look like \"error -1\".\n *\n * **Example**:\n *\n * // This throws a system_error with the description\n * // cannot open file 'foo': The system cannot find the file specified.\n * // or similar (system message may vary) if the file doesn't exist.\n * const char *filename = \"foo\";\n * LPOFSTRUCT of = LPOFSTRUCT();\n * HFILE file = OpenFile(filename, &of, OF_READ);\n * if (file == HFILE_ERROR) {\n * throw fmt::windows_error(GetLastError(),\n * \"cannot open file '{}'\", filename);\n * }\n */\ntemplate \nauto windows_error(int error_code, string_view message, const T&... args)\n -> std::system_error {\n return vwindows_error(error_code, message, vargs{{args...}});\n}\n\n// Reports a Windows error without throwing an exception.\n// Can be used to report errors from destructors.\nFMT_API void report_windows_error(int error_code, const char* message) noexcept;\n#else\ninline auto system_category() noexcept -> const std::error_category& {\n return std::system_category();\n}\n#endif // _WIN32\n\n// std::system is not available on some platforms such as iOS (#2248).\n#ifdef __OSX__\ntemplate >\nvoid say(const S& fmt, Args&&... args) {\n std::system(format(\"say \\\"{}\\\"\", format(fmt, args...)).c_str());\n}\n#endif\n\n// A buffered file.\nclass buffered_file {\n private:\n FILE* file_;\n\n friend class file;\n\n inline explicit buffered_file(FILE* f) : file_(f) {}\n\n public:\n buffered_file(const buffered_file&) = delete;\n void operator=(const buffered_file&) = delete;\n\n // Constructs a buffered_file object which doesn't represent any file.\n inline buffered_file() noexcept : file_(nullptr) {}\n\n // Destroys the object closing the file it represents if any.\n FMT_API ~buffered_file() noexcept;\n\n public:\n inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {\n other.file_ = nullptr;\n }\n\n inline auto operator=(buffered_file&& other) -> buffered_file& {\n close();\n file_ = other.file_;\n other.file_ = nullptr;\n return *this;\n }\n\n // Opens a file.\n FMT_API buffered_file(cstring_view filename, cstring_view mode);\n\n // Closes the file.\n FMT_API void close();\n\n // Returns the pointer to a FILE object representing this file.\n inline auto get() const noexcept -> FILE* { return file_; }\n\n FMT_API auto descriptor() const -> int;\n\n template \n inline void print(string_view fmt, const T&... args) {\n fmt::vargs vargs = {{args...}};\n detail::is_locking() ? fmt::vprint_buffered(file_, fmt, vargs)\n : fmt::vprint(file_, fmt, vargs);\n }\n};\n\n#if FMT_USE_FCNTL\n\n// A file. Closed file is represented by a file object with descriptor -1.\n// Methods that are not declared with noexcept may throw\n// fmt::system_error in case of failure. Note that some errors such as\n// closing the file multiple times will cause a crash on Windows rather\n// than an exception. You can get standard behavior by overriding the\n// invalid parameter handler with _set_invalid_parameter_handler.\nclass FMT_API file {\n private:\n int fd_; // File descriptor.\n\n // Constructs a file object with a given descriptor.\n explicit file(int fd) : fd_(fd) {}\n\n friend struct pipe;\n\n public:\n // Possible values for the oflag argument to the constructor.\n enum {\n RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.\n WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.\n RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing.\n CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist.\n APPEND = FMT_POSIX(O_APPEND), // Open in append mode.\n TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file.\n };\n\n // Constructs a file object which doesn't represent any file.\n inline file() noexcept : fd_(-1) {}\n\n // Opens a file and constructs a file object representing this file.\n file(cstring_view path, int oflag);\n\n public:\n file(const file&) = delete;\n void operator=(const file&) = delete;\n\n inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }\n\n // Move assignment is not noexcept because close may throw.\n inline auto operator=(file&& other) -> file& {\n close();\n fd_ = other.fd_;\n other.fd_ = -1;\n return *this;\n }\n\n // Destroys the object closing the file it represents if any.\n ~file() noexcept;\n\n // Returns the file descriptor.\n inline auto descriptor() const noexcept -> int { return fd_; }\n\n // Closes the file.\n void close();\n\n // Returns the file size. The size has signed type for consistency with\n // stat::st_size.\n auto size() const -> long long;\n\n // Attempts to read count bytes from the file into the specified buffer.\n auto read(void* buffer, size_t count) -> size_t;\n\n // Attempts to write count bytes from the specified buffer to the file.\n auto write(const void* buffer, size_t count) -> size_t;\n\n // Duplicates a file descriptor with the dup function and returns\n // the duplicate as a file object.\n static auto dup(int fd) -> file;\n\n // Makes fd be the copy of this file descriptor, closing fd first if\n // necessary.\n void dup2(int fd);\n\n // Makes fd be the copy of this file descriptor, closing fd first if\n // necessary.\n void dup2(int fd, std::error_code& ec) noexcept;\n\n // Creates a buffered_file object associated with this file and detaches\n // this file object from the file.\n auto fdopen(const char* mode) -> buffered_file;\n\n# if defined(_WIN32) && !defined(__MINGW32__)\n // Opens a file and constructs a file object representing this file by\n // wcstring_view filename. Windows only.\n static file open_windows_file(wcstring_view path, int oflag);\n# endif\n};\n\nstruct FMT_API pipe {\n file read_end;\n file write_end;\n\n // Creates a pipe setting up read_end and write_end file objects for reading\n // and writing respectively.\n pipe();\n};\n\n// Returns the memory page size.\nauto getpagesize() -> long;\n\nnamespace detail {\n\nstruct buffer_size {\n constexpr buffer_size() = default;\n size_t value = 0;\n FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {\n auto bs = buffer_size();\n bs.value = val;\n return bs;\n }\n};\n\nstruct ostream_params {\n int oflag = file::WRONLY | file::CREATE | file::TRUNC;\n size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;\n\n constexpr ostream_params() {}\n\n template \n ostream_params(T... params, int new_oflag) : ostream_params(params...) {\n oflag = new_oflag;\n }\n\n template \n ostream_params(T... params, detail::buffer_size bs)\n : ostream_params(params...) {\n this->buffer_size = bs.value;\n }\n\n// Intel has a bug that results in failure to deduce a constructor\n// for empty parameter packs.\n# if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000\n ostream_params(int new_oflag) : oflag(new_oflag) {}\n ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}\n# endif\n};\n\n} // namespace detail\n\nFMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();\n\n/// A fast buffered output stream for writing from a single thread. Writing from\n/// multiple threads without external synchronization may result in a data race.\nclass ostream : private detail::buffer {\n private:\n file file_;\n\n FMT_API ostream(cstring_view path, const detail::ostream_params& params);\n\n FMT_API static void grow(buffer& buf, size_t);\n\n public:\n FMT_API ostream(ostream&& other) noexcept;\n FMT_API ~ostream();\n\n operator writer() {\n detail::buffer& buf = *this;\n return buf;\n }\n\n inline void flush() {\n if (size() == 0) return;\n file_.write(data(), size() * sizeof(data()[0]));\n clear();\n }\n\n template \n friend auto output_file(cstring_view path, T... params) -> ostream;\n\n inline void close() {\n flush();\n file_.close();\n }\n\n /// Formats `args` according to specifications in `fmt` and writes the\n /// output to the file.\n template void print(format_string fmt, T&&... args) {\n vformat_to(appender(*this), fmt.str, vargs{{args...}});\n }\n};\n\n/**\n * Opens a file for writing. Supported parameters passed in `params`:\n *\n * - ``: Flags passed to [open](\n * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)\n * (`file::WRONLY | file::CREATE | file::TRUNC` by default)\n * - `buffer_size=`: Output buffer size\n *\n * **Example**:\n *\n * auto out = fmt::output_file(\"guide.txt\");\n * out.print(\"Don't {}\", \"Panic\");\n */\ntemplate \ninline auto output_file(cstring_view path, T... params) -> ostream {\n return {path, detail::ostream_params(params...)};\n}\n#endif // FMT_USE_FCNTL\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_OS_H_\n" }, { "path": "include/spdlog/fmt/bundled/ostream.h", "content": "// Formatting library for C++ - std::ostream support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_OSTREAM_H_\n#define FMT_OSTREAM_H_\n\n#ifndef FMT_MODULE\n# include // std::filebuf\n#endif\n\n#ifdef _WIN32\n# ifdef __GLIBCXX__\n# include \n# include \n# endif\n# include \n#endif\n\n#include \"chrono.h\" // formatbuf\n\n#ifdef _MSVC_STL_UPDATE\n# define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE\n#elif defined(_MSC_VER) && _MSC_VER < 1912 // VS 15.5\n# define FMT_MSVC_STL_UPDATE _MSVC_LANG\n#else\n# define FMT_MSVC_STL_UPDATE 0\n#endif\n\nFMT_BEGIN_NAMESPACE\nnamespace detail {\n\n// Generate a unique explicit instantiation in every translation unit using a\n// tag type in an anonymous namespace.\nnamespace {\nstruct file_access_tag {};\n} // namespace\ntemplate \nclass file_access {\n friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }\n};\n\n#if FMT_MSVC_STL_UPDATE\ntemplate class file_access;\nauto get_file(std::filebuf&) -> FILE*;\n#endif\n\n// Write the content of buf to os.\n// It is a separate function rather than a part of vprint to simplify testing.\ntemplate \nvoid write_buffer(std::basic_ostream& os, buffer& buf) {\n const Char* buf_data = buf.data();\n using unsigned_streamsize = make_unsigned_t;\n unsigned_streamsize size = buf.size();\n unsigned_streamsize max_size = to_unsigned(max_value());\n do {\n unsigned_streamsize n = size <= max_size ? size : max_size;\n os.write(buf_data, static_cast(n));\n buf_data += n;\n size -= n;\n } while (size != 0);\n}\n\ntemplate struct streamed_view {\n const T& value;\n};\n} // namespace detail\n\n// Formats an object of type T that has an overloaded ostream operator<<.\ntemplate \nstruct basic_ostream_formatter : formatter, Char> {\n void set_debug_format() = delete;\n\n template \n auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {\n auto buffer = basic_memory_buffer();\n auto&& formatbuf = detail::formatbuf>(buffer);\n auto&& output = std::basic_ostream(&formatbuf);\n output.imbue(std::locale::classic()); // The default is always unlocalized.\n output << value;\n output.exceptions(std::ios_base::failbit | std::ios_base::badbit);\n return formatter, Char>::format(\n {buffer.data(), buffer.size()}, ctx);\n }\n};\n\nusing ostream_formatter = basic_ostream_formatter;\n\ntemplate \nstruct formatter, Char>\n : basic_ostream_formatter {\n template \n auto format(detail::streamed_view view, Context& ctx) const\n -> decltype(ctx.out()) {\n return basic_ostream_formatter::format(view.value, ctx);\n }\n};\n\n/**\n * Returns a view that formats `value` via an ostream `operator<<`.\n *\n * **Example**:\n *\n * fmt::print(\"Current thread id: {}\\n\",\n * fmt::streamed(std::this_thread::get_id()));\n */\ntemplate \nconstexpr auto streamed(const T& value) -> detail::streamed_view {\n return {value};\n}\n\ninline void vprint(std::ostream& os, string_view fmt, format_args args) {\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n FILE* f = nullptr;\n#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI\n if (auto* buf = dynamic_cast(os.rdbuf()))\n f = detail::get_file(*buf);\n#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI\n auto* rdbuf = os.rdbuf();\n if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf))\n f = sfbuf->file();\n else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf))\n f = fbuf->file();\n#endif\n#ifdef _WIN32\n if (f) {\n int fd = _fileno(f);\n if (_isatty(fd)) {\n os.flush();\n if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;\n }\n }\n#endif\n detail::ignore_unused(f);\n detail::write_buffer(os, buffer);\n}\n\n/**\n * Prints formatted data to the stream `os`.\n *\n * **Example**:\n *\n * fmt::print(cerr, \"Don't {}!\", \"panic\");\n */\nFMT_EXPORT template \nvoid print(std::ostream& os, format_string fmt, T&&... args) {\n fmt::vargs vargs = {{args...}};\n if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);\n auto buffer = memory_buffer();\n detail::vformat_to(buffer, fmt.str, vargs);\n detail::write_buffer(os, buffer);\n}\n\nFMT_EXPORT template \nvoid println(std::ostream& os, format_string fmt, T&&... args) {\n fmt::print(os, FMT_STRING(\"{}\\n\"),\n fmt::format(fmt, std::forward(args)...));\n}\n\nFMT_END_NAMESPACE\n\n#endif // FMT_OSTREAM_H_\n" }, { "path": "include/spdlog/fmt/bundled/printf.h", "content": "// Formatting library for C++ - legacy printf implementation\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_PRINTF_H_\n#define FMT_PRINTF_H_\n\n#ifndef FMT_MODULE\n# include // std::find\n# include // std::numeric_limits\n#endif\n\n#include \"format.h\"\n\nFMT_BEGIN_NAMESPACE\nFMT_BEGIN_EXPORT\n\ntemplate class basic_printf_context {\n private:\n basic_appender out_;\n basic_format_args args_;\n\n static_assert(std::is_same::value ||\n std::is_same::value,\n \"Unsupported code unit type.\");\n\n public:\n using char_type = Char;\n enum { builtin_types = 1 };\n\n /// Constructs a `printf_context` object. References to the arguments are\n /// stored in the context object so make sure they have appropriate lifetimes.\n basic_printf_context(basic_appender out,\n basic_format_args args)\n : out_(out), args_(args) {}\n\n auto out() -> basic_appender { return out_; }\n void advance_to(basic_appender) {}\n\n auto locale() -> locale_ref { return {}; }\n\n auto arg(int id) const -> basic_format_arg {\n return args_.get(id);\n }\n};\n\nnamespace detail {\n\n// Return the result via the out param to workaround gcc bug 77539.\ntemplate \nFMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {\n for (out = first; out != last; ++out) {\n if (*out == value) return true;\n }\n return false;\n}\n\ntemplate <>\ninline auto find(const char* first, const char* last, char value,\n const char*& out) -> bool {\n out =\n static_cast(memchr(first, value, to_unsigned(last - first)));\n return out != nullptr;\n}\n\n// Checks if a value fits in int - used to avoid warnings about comparing\n// signed and unsigned integers.\ntemplate struct int_checker {\n template static auto fits_in_int(T value) -> bool {\n return value <= to_unsigned(max_value());\n }\n inline static auto fits_in_int(bool) -> bool { return true; }\n};\n\ntemplate <> struct int_checker {\n template static auto fits_in_int(T value) -> bool {\n return value >= (std::numeric_limits::min)() &&\n value <= max_value();\n }\n inline static auto fits_in_int(int) -> bool { return true; }\n};\n\nstruct printf_precision_handler {\n template ::value)>\n auto operator()(T value) -> int {\n if (!int_checker::is_signed>::fits_in_int(value))\n report_error(\"number is too big\");\n return max_of(static_cast(value), 0);\n }\n\n template ::value)>\n auto operator()(T) -> int {\n report_error(\"precision is not integer\");\n return 0;\n }\n};\n\n// An argument visitor that returns true iff arg is a zero integer.\nstruct is_zero_int {\n template ::value)>\n auto operator()(T value) -> bool {\n return value == 0;\n }\n\n template ::value)>\n auto operator()(T) -> bool {\n return false;\n }\n};\n\ntemplate struct make_unsigned_or_bool : std::make_unsigned {};\n\ntemplate <> struct make_unsigned_or_bool {\n using type = bool;\n};\n\ntemplate class arg_converter {\n private:\n using char_type = typename Context::char_type;\n\n basic_format_arg& arg_;\n char_type type_;\n\n public:\n arg_converter(basic_format_arg& arg, char_type type)\n : arg_(arg), type_(type) {}\n\n void operator()(bool value) {\n if (type_ != 's') operator()(value);\n }\n\n template ::value)>\n void operator()(U value) {\n bool is_signed = type_ == 'd' || type_ == 'i';\n using target_type = conditional_t::value, U, T>;\n if (const_check(sizeof(target_type) <= sizeof(int))) {\n // Extra casts are used to silence warnings.\n using unsigned_type = typename make_unsigned_or_bool::type;\n if (is_signed)\n arg_ = static_cast(static_cast(value));\n else\n arg_ = static_cast(static_cast(value));\n } else {\n // glibc's printf doesn't sign extend arguments of smaller types:\n // std::printf(\"%lld\", -42); // prints \"4294967254\"\n // but we don't have to do the same because it's a UB.\n if (is_signed)\n arg_ = static_cast(value);\n else\n arg_ = static_cast::type>(value);\n }\n }\n\n template ::value)>\n void operator()(U) {} // No conversion needed for non-integral types.\n};\n\n// Converts an integer argument to T for printf, if T is an integral type.\n// If T is void, the argument is converted to corresponding signed or unsigned\n// type depending on the type specifier: 'd' and 'i' - signed, other -\n// unsigned).\ntemplate \nvoid convert_arg(basic_format_arg& arg, Char type) {\n arg.visit(arg_converter(arg, type));\n}\n\n// Converts an integer argument to char for printf.\ntemplate class char_converter {\n private:\n basic_format_arg& arg_;\n\n public:\n explicit char_converter(basic_format_arg& arg) : arg_(arg) {}\n\n template ::value)>\n void operator()(T value) {\n arg_ = static_cast(value);\n }\n\n template ::value)>\n void operator()(T) {} // No conversion needed for non-integral types.\n};\n\n// An argument visitor that return a pointer to a C string if argument is a\n// string or null otherwise.\ntemplate struct get_cstring {\n template auto operator()(T) -> const Char* { return nullptr; }\n auto operator()(const Char* s) -> const Char* { return s; }\n};\n\n// Checks if an argument is a valid printf width specifier and sets\n// left alignment if it is negative.\nclass printf_width_handler {\n private:\n format_specs& specs_;\n\n public:\n inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}\n\n template ::value)>\n auto operator()(T value) -> unsigned {\n auto width = static_cast>(value);\n if (detail::is_negative(value)) {\n specs_.set_align(align::left);\n width = 0 - width;\n }\n unsigned int_max = to_unsigned(max_value());\n if (width > int_max) report_error(\"number is too big\");\n return static_cast(width);\n }\n\n template ::value)>\n auto operator()(T) -> unsigned {\n report_error(\"width is not integer\");\n return 0;\n }\n};\n\n// Workaround for a bug with the XL compiler when initializing\n// printf_arg_formatter's base class.\ntemplate \nauto make_arg_formatter(basic_appender iter, format_specs& s)\n -> arg_formatter {\n return {iter, s, locale_ref()};\n}\n\n// The `printf` argument formatter.\ntemplate \nclass printf_arg_formatter : public arg_formatter {\n private:\n using base = arg_formatter;\n using context_type = basic_printf_context;\n\n context_type& context_;\n\n void write_null_pointer(bool is_string = false) {\n auto s = this->specs;\n s.set_type(presentation_type::none);\n write_bytes(this->out, is_string ? \"(null)\" : \"(nil)\", s);\n }\n\n template void write(T value) {\n detail::write(this->out, value, this->specs, this->locale);\n }\n\n public:\n printf_arg_formatter(basic_appender iter, format_specs& s,\n context_type& ctx)\n : base(make_arg_formatter(iter, s)), context_(ctx) {}\n\n void operator()(monostate value) { write(value); }\n\n template ::value)>\n void operator()(T value) {\n // MSVC2013 fails to compile separate overloads for bool and Char so use\n // std::is_same instead.\n if (!std::is_same::value) {\n write(value);\n return;\n }\n format_specs s = this->specs;\n if (s.type() != presentation_type::none &&\n s.type() != presentation_type::chr) {\n return (*this)(static_cast(value));\n }\n s.set_sign(sign::none);\n s.clear_alt();\n s.set_fill(' '); // Ignore '0' flag for char types.\n // align::numeric needs to be overwritten here since the '0' flag is\n // ignored for non-numeric types\n if (s.align() == align::none || s.align() == align::numeric)\n s.set_align(align::right);\n detail::write(this->out, static_cast(value), s);\n }\n\n template ::value)>\n void operator()(T value) {\n write(value);\n }\n\n void operator()(const char* value) {\n if (value)\n write(value);\n else\n write_null_pointer(this->specs.type() != presentation_type::pointer);\n }\n\n void operator()(const wchar_t* value) {\n if (value)\n write(value);\n else\n write_null_pointer(this->specs.type() != presentation_type::pointer);\n }\n\n void operator()(basic_string_view value) { write(value); }\n\n void operator()(const void* value) {\n if (value)\n write(value);\n else\n write_null_pointer();\n }\n\n void operator()(typename basic_format_arg::handle handle) {\n auto parse_ctx = parse_context({});\n handle.format(parse_ctx, context_);\n }\n};\n\ntemplate \nvoid parse_flags(format_specs& specs, const Char*& it, const Char* end) {\n for (; it != end; ++it) {\n switch (*it) {\n case '-': specs.set_align(align::left); break;\n case '+': specs.set_sign(sign::plus); break;\n case '0': specs.set_fill('0'); break;\n case ' ':\n if (specs.sign() != sign::plus) specs.set_sign(sign::space);\n break;\n case '#': specs.set_alt(); break;\n default: return;\n }\n }\n}\n\ntemplate \nauto parse_header(const Char*& it, const Char* end, format_specs& specs,\n GetArg get_arg) -> int {\n int arg_index = -1;\n Char c = *it;\n if (c >= '0' && c <= '9') {\n // Parse an argument index (if followed by '$') or a width possibly\n // preceded with '0' flag(s).\n int value = parse_nonnegative_int(it, end, -1);\n if (it != end && *it == '$') { // value is an argument index\n ++it;\n arg_index = value != -1 ? value : max_value();\n } else {\n if (c == '0') specs.set_fill('0');\n if (value != 0) {\n // Nonzero value means that we parsed width and don't need to\n // parse it or flags again, so return now.\n if (value == -1) report_error(\"number is too big\");\n specs.width = value;\n return arg_index;\n }\n }\n }\n parse_flags(specs, it, end);\n // Parse width.\n if (it != end) {\n if (*it >= '0' && *it <= '9') {\n specs.width = parse_nonnegative_int(it, end, -1);\n if (specs.width == -1) report_error(\"number is too big\");\n } else if (*it == '*') {\n ++it;\n specs.width = static_cast(\n get_arg(-1).visit(detail::printf_width_handler(specs)));\n }\n }\n return arg_index;\n}\n\ninline auto parse_printf_presentation_type(char c, type t, bool& upper)\n -> presentation_type {\n using pt = presentation_type;\n constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;\n switch (c) {\n case 'd': return in(t, integral_set) ? pt::dec : pt::none;\n case 'o': return in(t, integral_set) ? pt::oct : pt::none;\n case 'X': upper = true; FMT_FALLTHROUGH;\n case 'x': return in(t, integral_set) ? pt::hex : pt::none;\n case 'E': upper = true; FMT_FALLTHROUGH;\n case 'e': return in(t, float_set) ? pt::exp : pt::none;\n case 'F': upper = true; FMT_FALLTHROUGH;\n case 'f': return in(t, float_set) ? pt::fixed : pt::none;\n case 'G': upper = true; FMT_FALLTHROUGH;\n case 'g': return in(t, float_set) ? pt::general : pt::none;\n case 'A': upper = true; FMT_FALLTHROUGH;\n case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;\n case 'c': return in(t, integral_set) ? pt::chr : pt::none;\n case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;\n case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;\n default: return pt::none;\n }\n}\n\ntemplate \nvoid vprintf(buffer& buf, basic_string_view format,\n basic_format_args args) {\n using iterator = basic_appender;\n auto out = iterator(buf);\n auto context = basic_printf_context(out, args);\n auto parse_ctx = parse_context(format);\n\n // Returns the argument with specified index or, if arg_index is -1, the next\n // argument.\n auto get_arg = [&](int arg_index) {\n if (arg_index < 0)\n arg_index = parse_ctx.next_arg_id();\n else\n parse_ctx.check_arg_id(--arg_index);\n auto arg = context.arg(arg_index);\n if (!arg) report_error(\"argument not found\");\n return arg;\n };\n\n const Char* start = parse_ctx.begin();\n const Char* end = parse_ctx.end();\n auto it = start;\n while (it != end) {\n if (!find(it, end, '%', it)) {\n it = end; // find leaves it == nullptr if it doesn't find '%'.\n break;\n }\n Char c = *it++;\n if (it != end && *it == c) {\n write(out, basic_string_view(start, to_unsigned(it - start)));\n start = ++it;\n continue;\n }\n write(out, basic_string_view(start, to_unsigned(it - 1 - start)));\n\n auto specs = format_specs();\n specs.set_align(align::right);\n\n // Parse argument index, flags and width.\n int arg_index = parse_header(it, end, specs, get_arg);\n if (arg_index == 0) report_error(\"argument not found\");\n\n // Parse precision.\n if (it != end && *it == '.') {\n ++it;\n c = it != end ? *it : 0;\n if ('0' <= c && c <= '9') {\n specs.precision = parse_nonnegative_int(it, end, 0);\n } else if (c == '*') {\n ++it;\n specs.precision =\n static_cast(get_arg(-1).visit(printf_precision_handler()));\n } else {\n specs.precision = 0;\n }\n }\n\n auto arg = get_arg(arg_index);\n // For d, i, o, u, x, and X conversion specifiers, if a precision is\n // specified, the '0' flag is ignored\n if (specs.precision >= 0 && is_integral_type(arg.type())) {\n // Ignore '0' for non-numeric types or if '-' present.\n specs.set_fill(' ');\n }\n if (specs.precision >= 0 && arg.type() == type::cstring_type) {\n auto str = arg.visit(get_cstring());\n auto str_end = str + specs.precision;\n auto nul = std::find(str, str_end, Char());\n auto sv = basic_string_view(\n str, to_unsigned(nul != str_end ? nul - str : specs.precision));\n arg = sv;\n }\n if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();\n if (specs.fill_unit() == '0') {\n if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {\n specs.set_align(align::numeric);\n } else {\n // Ignore '0' flag for non-numeric types or if '-' flag is also present.\n specs.set_fill(' ');\n }\n }\n\n // Parse length and convert the argument to the required type.\n c = it != end ? *it++ : 0;\n Char t = it != end ? *it : 0;\n switch (c) {\n case 'h':\n if (t == 'h') {\n ++it;\n t = it != end ? *it : 0;\n convert_arg(arg, t);\n } else {\n convert_arg(arg, t);\n }\n break;\n case 'l':\n if (t == 'l') {\n ++it;\n t = it != end ? *it : 0;\n convert_arg(arg, t);\n } else {\n convert_arg(arg, t);\n }\n break;\n case 'j': convert_arg(arg, t); break;\n case 'z': convert_arg(arg, t); break;\n case 't': convert_arg(arg, t); break;\n case 'L':\n // printf produces garbage when 'L' is omitted for long double, no\n // need to do the same.\n break;\n default: --it; convert_arg(arg, c);\n }\n\n // Parse type.\n if (it == end) report_error(\"invalid format string\");\n char type = static_cast(*it++);\n if (is_integral_type(arg.type())) {\n // Normalize type.\n switch (type) {\n case 'i':\n case 'u': type = 'd'; break;\n case 'c':\n arg.visit(char_converter>(arg));\n break;\n }\n }\n bool upper = false;\n specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));\n if (specs.type() == presentation_type::none)\n report_error(\"invalid format specifier\");\n if (upper) specs.set_upper();\n\n start = it;\n\n // Format argument.\n arg.visit(printf_arg_formatter(out, specs, context));\n }\n write(out, basic_string_view(start, to_unsigned(it - start)));\n}\n} // namespace detail\n\nusing printf_context = basic_printf_context;\nusing wprintf_context = basic_printf_context;\n\nusing printf_args = basic_format_args;\nusing wprintf_args = basic_format_args;\n\n/// Constructs an `format_arg_store` object that contains references to\n/// arguments and can be implicitly converted to `printf_args`.\ntemplate \ninline auto make_printf_args(T&... args)\n -> decltype(fmt::make_format_args>(args...)) {\n return fmt::make_format_args>(args...);\n}\n\ntemplate struct vprintf_args {\n using type = basic_format_args>;\n};\n\ntemplate \ninline auto vsprintf(basic_string_view fmt,\n typename vprintf_args::type args)\n -> std::basic_string {\n auto buf = basic_memory_buffer();\n detail::vprintf(buf, fmt, args);\n return {buf.data(), buf.size()};\n}\n\n/**\n * Formats `args` according to specifications in `fmt` and returns the result\n * as as string.\n *\n * **Example**:\n *\n * std::string message = fmt::sprintf(\"The answer is %d\", 42);\n */\ntemplate \ninline auto sprintf(string_view fmt, const T&... args) -> std::string {\n return vsprintf(fmt, make_printf_args(args...));\n}\ntemplate \nFMT_DEPRECATED auto sprintf(basic_string_view fmt, const T&... args)\n -> std::wstring {\n return vsprintf(fmt, make_printf_args(args...));\n}\n\ntemplate \nauto vfprintf(std::FILE* f, basic_string_view fmt,\n typename vprintf_args::type args) -> int {\n auto buf = basic_memory_buffer();\n detail::vprintf(buf, fmt, args);\n size_t size = buf.size();\n return std::fwrite(buf.data(), sizeof(Char), size, f) < size\n ? -1\n : static_cast(size);\n}\n\n/**\n * Formats `args` according to specifications in `fmt` and writes the output\n * to `f`.\n *\n * **Example**:\n *\n * fmt::fprintf(stderr, \"Don't %s!\", \"panic\");\n */\ntemplate \ninline auto fprintf(std::FILE* f, string_view fmt, const T&... args) -> int {\n return vfprintf(f, fmt, make_printf_args(args...));\n}\ntemplate \nFMT_DEPRECATED auto fprintf(std::FILE* f, basic_string_view fmt,\n const T&... args) -> int {\n return vfprintf(f, fmt, make_printf_args(args...));\n}\n\n/**\n * Formats `args` according to specifications in `fmt` and writes the output\n * to `stdout`.\n *\n * **Example**:\n *\n * fmt::printf(\"Elapsed time: %.2f seconds\", 1.23);\n */\ntemplate \ninline auto printf(string_view fmt, const T&... args) -> int {\n return vfprintf(stdout, fmt, make_printf_args(args...));\n}\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_PRINTF_H_\n" }, { "path": "include/spdlog/fmt/bundled/ranges.h", "content": "// Formatting library for C++ - range and tuple support\n//\n// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_RANGES_H_\n#define FMT_RANGES_H_\n\n#ifndef FMT_MODULE\n# include \n# include \n# include \n# include \n# include \n#endif\n\n#include \"format.h\"\n\n#if FMT_HAS_CPP_ATTRIBUTE(clang::lifetimebound)\n# define FMT_LIFETIMEBOUND [[clang::lifetimebound]]\n#else\n# define FMT_LIFETIMEBOUND\n#endif\nFMT_PRAGMA_CLANG(diagnostic error \"-Wreturn-stack-address\")\n\nFMT_BEGIN_NAMESPACE\n\nFMT_EXPORT\nenum class range_format { disabled, map, set, sequence, string, debug_string };\n\nnamespace detail {\n\ntemplate class is_map {\n template static auto check(U*) -> typename U::mapped_type;\n template static void check(...);\n\n public:\n static constexpr bool value =\n !std::is_void(nullptr))>::value;\n};\n\ntemplate class is_set {\n template static auto check(U*) -> typename U::key_type;\n template static void check(...);\n\n public:\n static constexpr bool value =\n !std::is_void(nullptr))>::value && !is_map::value;\n};\n\n// C array overload\ntemplate \nauto range_begin(const T (&arr)[N]) -> const T* {\n return arr;\n}\ntemplate auto range_end(const T (&arr)[N]) -> const T* {\n return arr + N;\n}\n\ntemplate \nstruct has_member_fn_begin_end_t : std::false_type {};\n\ntemplate \nstruct has_member_fn_begin_end_t().begin()),\n decltype(std::declval().end())>>\n : std::true_type {};\n\n// Member function overloads.\ntemplate \nauto range_begin(T&& rng) -> decltype(static_cast(rng).begin()) {\n return static_cast(rng).begin();\n}\ntemplate \nauto range_end(T&& rng) -> decltype(static_cast(rng).end()) {\n return static_cast(rng).end();\n}\n\n// ADL overloads. Only participate in overload resolution if member functions\n// are not found.\ntemplate \nauto range_begin(T&& rng)\n -> enable_if_t::value,\n decltype(begin(static_cast(rng)))> {\n return begin(static_cast(rng));\n}\ntemplate \nauto range_end(T&& rng) -> enable_if_t::value,\n decltype(end(static_cast(rng)))> {\n return end(static_cast(rng));\n}\n\ntemplate \nstruct has_const_begin_end : std::false_type {};\ntemplate \nstruct has_mutable_begin_end : std::false_type {};\n\ntemplate \nstruct has_const_begin_end<\n T, void_t&>())),\n decltype(detail::range_end(\n std::declval&>()))>>\n : std::true_type {};\n\ntemplate \nstruct has_mutable_begin_end<\n T, void_t())),\n decltype(detail::range_end(std::declval())),\n // the extra int here is because older versions of MSVC don't\n // SFINAE properly unless there are distinct types\n int>> : std::true_type {};\n\ntemplate struct is_range_ : std::false_type {};\ntemplate \nstruct is_range_\n : std::integral_constant::value ||\n has_mutable_begin_end::value)> {};\n\n// tuple_size and tuple_element check.\ntemplate class is_tuple_like_ {\n template ::type>\n static auto check(U* p) -> decltype(std::tuple_size::value, 0);\n template static void check(...);\n\n public:\n static constexpr bool value =\n !std::is_void(nullptr))>::value;\n};\n\n// Check for integer_sequence\n#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900\ntemplate \nusing integer_sequence = std::integer_sequence;\ntemplate using index_sequence = std::index_sequence;\ntemplate using make_index_sequence = std::make_index_sequence;\n#else\ntemplate struct integer_sequence {\n using value_type = T;\n\n static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }\n};\n\ntemplate using index_sequence = integer_sequence;\n\ntemplate \nstruct make_integer_sequence : make_integer_sequence {};\ntemplate \nstruct make_integer_sequence : integer_sequence {};\n\ntemplate \nusing make_index_sequence = make_integer_sequence;\n#endif\n\ntemplate \nusing tuple_index_sequence = make_index_sequence::value>;\n\ntemplate ::value>\nclass is_tuple_formattable_ {\n public:\n static constexpr bool value = false;\n};\ntemplate class is_tuple_formattable_ {\n template \n static auto all_true(index_sequence,\n integer_sequence= 0)...>) -> std::true_type;\n static auto all_true(...) -> std::false_type;\n\n template \n static auto check(index_sequence) -> decltype(all_true(\n index_sequence{},\n integer_sequence::type,\n C>::value)...>{}));\n\n public:\n static constexpr bool value =\n decltype(check(tuple_index_sequence{}))::value;\n};\n\ntemplate \nFMT_CONSTEXPR void for_each(index_sequence, Tuple&& t, F&& f) {\n using std::get;\n // Using a free function get(Tuple) now.\n const int unused[] = {0, ((void)f(get(t)), 0)...};\n ignore_unused(unused);\n}\n\ntemplate \nFMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {\n for_each(tuple_index_sequence>(),\n std::forward(t), std::forward(f));\n}\n\ntemplate \nvoid for_each2(index_sequence, Tuple1&& t1, Tuple2&& t2, F&& f) {\n using std::get;\n const int unused[] = {0, ((void)f(get(t1), get(t2)), 0)...};\n ignore_unused(unused);\n}\n\ntemplate \nvoid for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {\n for_each2(tuple_index_sequence>(),\n std::forward(t1), std::forward(t2),\n std::forward(f));\n}\n\nnamespace tuple {\n// Workaround a bug in MSVC 2019 (v140).\ntemplate \nusing result_t = std::tuple, Char>...>;\n\nusing std::get;\ntemplate \nauto get_formatters(index_sequence)\n -> result_t(std::declval()))...>;\n} // namespace tuple\n\n#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920\n// Older MSVC doesn't get the reference type correctly for arrays.\ntemplate struct range_reference_type_impl {\n using type = decltype(*detail::range_begin(std::declval()));\n};\n\ntemplate struct range_reference_type_impl {\n using type = T&;\n};\n\ntemplate \nusing range_reference_type = typename range_reference_type_impl::type;\n#else\ntemplate \nusing range_reference_type =\n decltype(*detail::range_begin(std::declval()));\n#endif\n\n// We don't use the Range's value_type for anything, but we do need the Range's\n// reference type, with cv-ref stripped.\ntemplate \nusing uncvref_type = remove_cvref_t>;\n\ntemplate \nstruct range_format_kind_\n : std::integral_constant, T>::value\n ? range_format::disabled\n : is_map::value ? range_format::map\n : is_set::value ? range_format::set\n : range_format::sequence> {};\n\ntemplate \nusing range_format_constant = std::integral_constant;\n\n// These are not generic lambdas for compatibility with C++11.\ntemplate struct parse_empty_specs {\n template FMT_CONSTEXPR void operator()(Formatter& f) {\n f.parse(ctx);\n detail::maybe_set_debug_format(f, true);\n }\n parse_context& ctx;\n};\ntemplate struct format_tuple_element {\n using char_type = typename FormatContext::char_type;\n\n template \n void operator()(const formatter& f, const T& v) {\n if (i > 0) ctx.advance_to(detail::copy(separator, ctx.out()));\n ctx.advance_to(f.format(v, ctx));\n ++i;\n }\n\n int i;\n FormatContext& ctx;\n basic_string_view separator;\n};\n\n} // namespace detail\n\nFMT_EXPORT\ntemplate struct is_tuple_like {\n static constexpr bool value =\n detail::is_tuple_like_::value && !detail::is_range_::value;\n};\n\nFMT_EXPORT\ntemplate struct is_tuple_formattable {\n static constexpr bool value = detail::is_tuple_formattable_::value;\n};\n\ntemplate \nstruct formatter::value &&\n fmt::is_tuple_formattable::value>> {\n private:\n decltype(detail::tuple::get_formatters(\n detail::tuple_index_sequence())) formatters_;\n\n basic_string_view separator_ = detail::string_literal{};\n basic_string_view opening_bracket_ =\n detail::string_literal{};\n basic_string_view closing_bracket_ =\n detail::string_literal{};\n\n public:\n FMT_CONSTEXPR formatter() {}\n\n FMT_CONSTEXPR void set_separator(basic_string_view sep) {\n separator_ = sep;\n }\n\n FMT_CONSTEXPR void set_brackets(basic_string_view open,\n basic_string_view close) {\n opening_bracket_ = open;\n closing_bracket_ = close;\n }\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin();\n auto end = ctx.end();\n if (it != end && detail::to_ascii(*it) == 'n') {\n ++it;\n set_brackets({}, {});\n set_separator({});\n }\n if (it != end && *it != '}') report_error(\"invalid format specifier\");\n ctx.advance_to(it);\n detail::for_each(formatters_, detail::parse_empty_specs{ctx});\n return it;\n }\n\n template \n auto format(const Tuple& value, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n ctx.advance_to(detail::copy(opening_bracket_, ctx.out()));\n detail::for_each2(\n formatters_, value,\n detail::format_tuple_element{0, ctx, separator_});\n return detail::copy(closing_bracket_, ctx.out());\n }\n};\n\nFMT_EXPORT\ntemplate struct is_range {\n static constexpr bool value =\n detail::is_range_::value && !detail::has_to_string_view::value;\n};\n\nnamespace detail {\n\ntemplate \nusing range_formatter_type = formatter, Char>;\n\ntemplate \nusing maybe_const_range =\n conditional_t::value, const R, R>;\n\ntemplate \nstruct is_formattable_delayed\n : is_formattable>, Char> {};\n} // namespace detail\n\ntemplate struct conjunction : std::true_type {};\ntemplate struct conjunction

: P {};\ntemplate \nstruct conjunction\n : conditional_t, P1> {};\n\nFMT_EXPORT\ntemplate \nstruct range_formatter;\n\ntemplate \nstruct range_formatter<\n T, Char,\n enable_if_t>,\n is_formattable>::value>> {\n private:\n detail::range_formatter_type underlying_;\n basic_string_view separator_ = detail::string_literal{};\n basic_string_view opening_bracket_ =\n detail::string_literal{};\n basic_string_view closing_bracket_ =\n detail::string_literal{};\n bool is_debug = false;\n\n template ::value)>\n auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {\n auto buf = basic_memory_buffer();\n for (; it != end; ++it) buf.push_back(*it);\n auto specs = format_specs();\n specs.set_type(presentation_type::debug);\n return detail::write(\n out, basic_string_view(buf.data(), buf.size()), specs);\n }\n\n template ::value)>\n auto write_debug_string(Output& out, It, Sentinel) const -> Output {\n return out;\n }\n\n public:\n FMT_CONSTEXPR range_formatter() {}\n\n FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type& {\n return underlying_;\n }\n\n FMT_CONSTEXPR void set_separator(basic_string_view sep) {\n separator_ = sep;\n }\n\n FMT_CONSTEXPR void set_brackets(basic_string_view open,\n basic_string_view close) {\n opening_bracket_ = open;\n closing_bracket_ = close;\n }\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin();\n auto end = ctx.end();\n detail::maybe_set_debug_format(underlying_, true);\n if (it == end) return underlying_.parse(ctx);\n\n switch (detail::to_ascii(*it)) {\n case 'n':\n set_brackets({}, {});\n ++it;\n break;\n case '?':\n is_debug = true;\n set_brackets({}, {});\n ++it;\n if (it == end || *it != 's') report_error(\"invalid format specifier\");\n FMT_FALLTHROUGH;\n case 's':\n if (!std::is_same::value)\n report_error(\"invalid format specifier\");\n if (!is_debug) {\n set_brackets(detail::string_literal{},\n detail::string_literal{});\n set_separator({});\n detail::maybe_set_debug_format(underlying_, false);\n }\n ++it;\n return it;\n }\n\n if (it != end && *it != '}') {\n if (*it != ':') report_error(\"invalid format specifier\");\n detail::maybe_set_debug_format(underlying_, false);\n ++it;\n }\n\n ctx.advance_to(it);\n return underlying_.parse(ctx);\n }\n\n template \n auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto out = ctx.out();\n auto it = detail::range_begin(range);\n auto end = detail::range_end(range);\n if (is_debug) return write_debug_string(out, std::move(it), end);\n\n out = detail::copy(opening_bracket_, out);\n int i = 0;\n for (; it != end; ++it) {\n if (i > 0) out = detail::copy(separator_, out);\n ctx.advance_to(out);\n auto&& item = *it; // Need an lvalue\n out = underlying_.format(item, ctx);\n ++i;\n }\n out = detail::copy(closing_bracket_, out);\n return out;\n }\n};\n\nFMT_EXPORT\ntemplate \nstruct range_format_kind\n : conditional_t<\n is_range::value, detail::range_format_kind_,\n std::integral_constant> {};\n\ntemplate \nstruct formatter<\n R, Char,\n enable_if_t::value != range_format::disabled &&\n range_format_kind::value != range_format::map &&\n range_format_kind::value != range_format::string &&\n range_format_kind::value != range_format::debug_string>,\n detail::is_formattable_delayed>::value>> {\n private:\n using range_type = detail::maybe_const_range;\n range_formatter, Char> range_formatter_;\n\n public:\n using nonlocking = void;\n\n FMT_CONSTEXPR formatter() {\n if (detail::const_check(range_format_kind::value !=\n range_format::set))\n return;\n range_formatter_.set_brackets(detail::string_literal{},\n detail::string_literal{});\n }\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return range_formatter_.parse(ctx);\n }\n\n template \n auto format(range_type& range, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return range_formatter_.format(range, ctx);\n }\n};\n\n// A map formatter.\ntemplate \nstruct formatter<\n R, Char,\n enable_if_t::value == range_format::map>,\n detail::is_formattable_delayed>::value>> {\n private:\n using map_type = detail::maybe_const_range;\n using element_type = detail::uncvref_type;\n\n decltype(detail::tuple::get_formatters(\n detail::tuple_index_sequence())) formatters_;\n bool no_delimiters_ = false;\n\n public:\n FMT_CONSTEXPR formatter() {}\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n auto it = ctx.begin();\n auto end = ctx.end();\n if (it != end) {\n if (detail::to_ascii(*it) == 'n') {\n no_delimiters_ = true;\n ++it;\n }\n if (it != end && *it != '}') {\n if (*it != ':') report_error(\"invalid format specifier\");\n ++it;\n }\n ctx.advance_to(it);\n }\n detail::for_each(formatters_, detail::parse_empty_specs{ctx});\n return it;\n }\n\n template \n auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {\n auto out = ctx.out();\n basic_string_view open = detail::string_literal{};\n if (!no_delimiters_) out = detail::copy(open, out);\n int i = 0;\n basic_string_view sep = detail::string_literal{};\n for (auto&& value : map) {\n if (i > 0) out = detail::copy(sep, out);\n ctx.advance_to(out);\n detail::for_each2(formatters_, value,\n detail::format_tuple_element{\n 0, ctx, detail::string_literal{}});\n ++i;\n }\n basic_string_view close = detail::string_literal{};\n if (!no_delimiters_) out = detail::copy(close, out);\n return out;\n }\n};\n\n// A (debug_)string formatter.\ntemplate \nstruct formatter<\n R, Char,\n enable_if_t::value == range_format::string ||\n range_format_kind::value ==\n range_format::debug_string>> {\n private:\n using range_type = detail::maybe_const_range;\n using string_type =\n conditional_t,\n decltype(detail::range_begin(std::declval())),\n decltype(detail::range_end(std::declval()))>::value,\n detail::std_string_view, std::basic_string>;\n\n formatter underlying_;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return underlying_.parse(ctx);\n }\n\n template \n auto format(range_type& range, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto out = ctx.out();\n if (detail::const_check(range_format_kind::value ==\n range_format::debug_string))\n *out++ = '\"';\n out = underlying_.format(\n string_type{detail::range_begin(range), detail::range_end(range)}, ctx);\n if (detail::const_check(range_format_kind::value ==\n range_format::debug_string))\n *out++ = '\"';\n return out;\n }\n};\n\ntemplate \nstruct join_view : detail::view {\n It begin;\n Sentinel end;\n basic_string_view sep;\n\n join_view(It b, Sentinel e, basic_string_view s)\n : begin(std::move(b)), end(e), sep(s) {}\n};\n\ntemplate \nstruct formatter, Char> {\n private:\n using value_type =\n#ifdef __cpp_lib_ranges\n std::iter_value_t;\n#else\n typename std::iterator_traits::value_type;\n#endif\n formatter, Char> value_formatter_;\n\n using view = conditional_t::value,\n const join_view,\n join_view>;\n\n public:\n using nonlocking = void;\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return value_formatter_.parse(ctx);\n }\n\n template \n auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) {\n using iter =\n conditional_t::value, It, It&>;\n iter it = value.begin;\n auto out = ctx.out();\n if (it == value.end) return out;\n out = value_formatter_.format(*it, ctx);\n ++it;\n while (it != value.end) {\n out = detail::copy(value.sep.begin(), value.sep.end(), out);\n ctx.advance_to(out);\n out = value_formatter_.format(*it, ctx);\n ++it;\n }\n return out;\n }\n};\n\nFMT_EXPORT\ntemplate struct tuple_join_view : detail::view {\n const Tuple& tuple;\n basic_string_view sep;\n\n tuple_join_view(const Tuple& t, basic_string_view s)\n : tuple(t), sep{s} {}\n};\n\n// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers\n// support in tuple_join. It is disabled by default because of issues with\n// the dynamic width and precision.\n#ifndef FMT_TUPLE_JOIN_SPECIFIERS\n# define FMT_TUPLE_JOIN_SPECIFIERS 0\n#endif\n\ntemplate \nstruct formatter, Char,\n enable_if_t::value>> {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return do_parse(ctx, std::tuple_size());\n }\n\n template \n auto format(const tuple_join_view& value,\n FormatContext& ctx) const -> typename FormatContext::iterator {\n return do_format(value, ctx, std::tuple_size());\n }\n\n private:\n decltype(detail::tuple::get_formatters(\n detail::tuple_index_sequence())) formatters_;\n\n FMT_CONSTEXPR auto do_parse(parse_context& ctx,\n std::integral_constant)\n -> const Char* {\n return ctx.begin();\n }\n\n template \n FMT_CONSTEXPR auto do_parse(parse_context& ctx,\n std::integral_constant)\n -> const Char* {\n auto end = ctx.begin();\n#if FMT_TUPLE_JOIN_SPECIFIERS\n end = std::get::value - N>(formatters_).parse(ctx);\n if (N > 1) {\n auto end1 = do_parse(ctx, std::integral_constant());\n if (end != end1)\n report_error(\"incompatible format specs for tuple elements\");\n }\n#endif\n return end;\n }\n\n template \n auto do_format(const tuple_join_view&, FormatContext& ctx,\n std::integral_constant) const ->\n typename FormatContext::iterator {\n return ctx.out();\n }\n\n template \n auto do_format(const tuple_join_view& value, FormatContext& ctx,\n std::integral_constant) const ->\n typename FormatContext::iterator {\n using std::get;\n auto out =\n std::get::value - N>(formatters_)\n .format(get::value - N>(value.tuple), ctx);\n if (N <= 1) return out;\n out = detail::copy(value.sep, out);\n ctx.advance_to(out);\n return do_format(value, ctx, std::integral_constant());\n }\n};\n\nnamespace detail {\n// Check if T has an interface like a container adaptor (e.g. std::stack,\n// std::queue, std::priority_queue).\ntemplate class is_container_adaptor_like {\n template static auto check(U* p) -> typename U::container_type;\n template static void check(...);\n\n public:\n static constexpr bool value =\n !std::is_void(nullptr))>::value;\n};\n\ntemplate struct all {\n const Container& c;\n auto begin() const -> typename Container::const_iterator { return c.begin(); }\n auto end() const -> typename Container::const_iterator { return c.end(); }\n};\n} // namespace detail\n\ntemplate \nstruct formatter<\n T, Char,\n enable_if_t,\n bool_constant::value ==\n range_format::disabled>>::value>>\n : formatter, Char> {\n using all = detail::all;\n template \n auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {\n struct getter : T {\n static auto get(const T& v) -> all {\n return {v.*(&getter::c)}; // Access c through the derived class.\n }\n };\n return formatter::format(getter::get(value), ctx);\n }\n};\n\nFMT_BEGIN_EXPORT\n\n/// Returns a view that formats the iterator range `[begin, end)` with elements\n/// separated by `sep`.\ntemplate \nauto join(It begin, Sentinel end, string_view sep) -> join_view {\n return {std::move(begin), end, sep};\n}\n\n/**\n * Returns a view that formats `range` with elements separated by `sep`.\n *\n * **Example**:\n *\n * auto v = std::vector{1, 2, 3};\n * fmt::print(\"{}\", fmt::join(v, \", \"));\n * // Output: 1, 2, 3\n *\n * `fmt::join` applies passed format specifiers to the range elements:\n *\n * fmt::print(\"{:02}\", fmt::join(v, \", \"));\n * // Output: 01, 02, 03\n */\ntemplate ::value)>\nauto join(Range&& r, string_view sep)\n -> join_view {\n return {detail::range_begin(r), detail::range_end(r), sep};\n}\n\n/**\n * Returns an object that formats `std::tuple` with elements separated by `sep`.\n *\n * **Example**:\n *\n * auto t = std::tuple(1, 'a');\n * fmt::print(\"{}\", fmt::join(t, \", \"));\n * // Output: 1, a\n */\ntemplate ::value)>\nFMT_CONSTEXPR auto join(const Tuple& tuple FMT_LIFETIMEBOUND, string_view sep)\n -> tuple_join_view {\n return {tuple, sep};\n}\n\n/**\n * Returns an object that formats `std::initializer_list` with elements\n * separated by `sep`.\n *\n * **Example**:\n *\n * fmt::print(\"{}\", fmt::join({1, 2, 3}, \", \"));\n * // Output: \"1, 2, 3\"\n */\ntemplate \nauto join(std::initializer_list list, string_view sep)\n -> join_view {\n return join(std::begin(list), std::end(list), sep);\n}\n\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_RANGES_H_\n" }, { "path": "include/spdlog/fmt/bundled/std.h", "content": "// Formatting library for C++ - formatters for standard library types\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_STD_H_\n#define FMT_STD_H_\n\n#include \"format.h\"\n#include \"ostream.h\"\n\n#ifndef FMT_MODULE\n# include \n# include \n# include \n# include \n# include // std::reference_wrapper\n# include \n# include \n# include \n# include // std::type_info\n# include // std::make_index_sequence\n\n// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.\n# if FMT_CPLUSPLUS >= 201703L\n# if FMT_HAS_INCLUDE() && \\\n (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)\n# include \n# endif\n# if FMT_HAS_INCLUDE()\n# include \n# endif\n# if FMT_HAS_INCLUDE()\n# include \n# endif\n# endif\n// Use > instead of >= in the version check because may be\n// available after C++17 but before C++20 is marked as implemented.\n# if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE()\n# include \n# endif\n# if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE()\n# include \n# endif\n#endif // FMT_MODULE\n\n#if FMT_HAS_INCLUDE()\n# include \n#endif\n\n// GCC 4 does not support FMT_HAS_INCLUDE.\n#if FMT_HAS_INCLUDE() || defined(__GLIBCXX__)\n# include \n// Android NDK with gabi++ library on some architectures does not implement\n// abi::__cxa_demangle().\n# ifndef __GABIXX_CXXABI_H__\n# define FMT_HAS_ABI_CXA_DEMANGLE\n# endif\n#endif\n\n#ifdef FMT_CPP_LIB_FILESYSTEM\n// Use the provided definition.\n#elif defined(__cpp_lib_filesystem)\n# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem\n#else\n# define FMT_CPP_LIB_FILESYSTEM 0\n#endif\n\n#ifdef FMT_CPP_LIB_VARIANT\n// Use the provided definition.\n#elif defined(__cpp_lib_variant)\n# define FMT_CPP_LIB_VARIANT __cpp_lib_variant\n#else\n# define FMT_CPP_LIB_VARIANT 0\n#endif\n\nFMT_BEGIN_NAMESPACE\nnamespace detail {\n\n#if FMT_CPP_LIB_FILESYSTEM\n\ntemplate \nauto get_path_string(const std::filesystem::path& p,\n const std::basic_string& native) {\n if constexpr (std::is_same_v && std::is_same_v)\n return to_utf8(native, to_utf8_error_policy::replace);\n else\n return p.string();\n}\n\ntemplate \nvoid write_escaped_path(basic_memory_buffer& quoted,\n const std::filesystem::path& p,\n const std::basic_string& native) {\n if constexpr (std::is_same_v &&\n std::is_same_v) {\n auto buf = basic_memory_buffer();\n write_escaped_string(std::back_inserter(buf), native);\n bool valid = to_utf8::convert(quoted, {buf.data(), buf.size()});\n FMT_ASSERT(valid, \"invalid utf16\");\n } else if constexpr (std::is_same_v) {\n write_escaped_string(\n std::back_inserter(quoted), native);\n } else {\n write_escaped_string(std::back_inserter(quoted), p.string());\n }\n}\n\n#endif // FMT_CPP_LIB_FILESYSTEM\n\n#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT\n\ntemplate \nauto write_escaped_alternative(OutputIt out, const T& v, FormatContext& ctx)\n -> OutputIt {\n if constexpr (has_to_string_view::value)\n return write_escaped_string(out, detail::to_string_view(v));\n if constexpr (std::is_same_v) return write_escaped_char(out, v);\n\n formatter, Char> underlying;\n maybe_set_debug_format(underlying, true);\n return underlying.format(v, ctx);\n}\n#endif\n\n#if FMT_CPP_LIB_VARIANT\n\ntemplate struct is_variant_like_ : std::false_type {};\ntemplate \nstruct is_variant_like_> : std::true_type {};\n\ntemplate class is_variant_formattable {\n template \n static auto check(std::index_sequence) -> std::conjunction<\n is_formattable, Char>...>;\n\n public:\n static constexpr bool value = decltype(check(\n std::make_index_sequence::value>()))::value;\n};\n\n#endif // FMT_CPP_LIB_VARIANT\n\n#if FMT_USE_RTTI\ninline auto normalize_libcxx_inline_namespaces(string_view demangled_name_view,\n char* begin) -> string_view {\n // Normalization of stdlib inline namespace names.\n // libc++ inline namespaces.\n // std::__1::* -> std::*\n // std::__1::__fs::* -> std::*\n // libstdc++ inline namespaces.\n // std::__cxx11::* -> std::*\n // std::filesystem::__cxx11::* -> std::filesystem::*\n if (demangled_name_view.starts_with(\"std::\")) {\n char* to = begin + 5; // std::\n for (const char *from = to, *end = begin + demangled_name_view.size();\n from < end;) {\n // This is safe, because demangled_name is NUL-terminated.\n if (from[0] == '_' && from[1] == '_') {\n const char* next = from + 1;\n while (next < end && *next != ':') next++;\n if (next[0] == ':' && next[1] == ':') {\n from = next + 2;\n continue;\n }\n }\n *to++ = *from++;\n }\n demangled_name_view = {begin, detail::to_unsigned(to - begin)};\n }\n return demangled_name_view;\n}\n\ntemplate \nauto normalize_msvc_abi_name(string_view abi_name_view, OutputIt out)\n -> OutputIt {\n const string_view demangled_name(abi_name_view);\n for (size_t i = 0; i < demangled_name.size(); ++i) {\n auto sub = demangled_name;\n sub.remove_prefix(i);\n if (sub.starts_with(\"enum \")) {\n i += 4;\n continue;\n }\n if (sub.starts_with(\"class \") || sub.starts_with(\"union \")) {\n i += 5;\n continue;\n }\n if (sub.starts_with(\"struct \")) {\n i += 6;\n continue;\n }\n if (*sub.begin() != ' ') *out++ = *sub.begin();\n }\n return out;\n}\n\ntemplate \nauto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {\n# ifdef FMT_HAS_ABI_CXA_DEMANGLE\n int status = 0;\n size_t size = 0;\n std::unique_ptr demangled_name_ptr(\n abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &free);\n\n string_view demangled_name_view;\n if (demangled_name_ptr) {\n demangled_name_view = normalize_libcxx_inline_namespaces(\n demangled_name_ptr.get(), demangled_name_ptr.get());\n } else {\n demangled_name_view = string_view(ti.name());\n }\n return detail::write_bytes(out, demangled_name_view);\n# elif FMT_MSC_VERSION && defined(_MSVC_STL_UPDATE)\n return normalize_msvc_abi_name(ti.name(), out);\n# elif FMT_MSC_VERSION && defined(_LIBCPP_VERSION)\n const string_view demangled_name = ti.name();\n std::string name_copy(demangled_name.size(), '\\0');\n // normalize_msvc_abi_name removes class, struct, union etc that MSVC has in\n // front of types\n name_copy.erase(normalize_msvc_abi_name(demangled_name, name_copy.begin()),\n name_copy.end());\n // normalize_libcxx_inline_namespaces removes the inline __1, __2, etc\n // namespaces libc++ uses for ABI versioning On MSVC ABI + libc++\n // environments, we need to eliminate both of them.\n const string_view normalized_name =\n normalize_libcxx_inline_namespaces(name_copy, name_copy.data());\n return detail::write_bytes(out, normalized_name);\n# else\n return detail::write_bytes(out, string_view(ti.name()));\n# endif\n}\n\n#endif // FMT_USE_RTTI\n\ntemplate \nstruct has_flip : std::false_type {};\n\ntemplate \nstruct has_flip().flip())>>\n : std::true_type {};\n\ntemplate struct is_bit_reference_like {\n static constexpr bool value = std::is_convertible::value &&\n std::is_nothrow_assignable::value &&\n has_flip::value;\n};\n\n// Workaround for libc++ incompatibility with C++ standard.\n// According to the Standard, `bitset::operator[] const` returns bool.\n#if defined(_LIBCPP_VERSION) && !defined(FMT_IMPORT_STD)\ntemplate \nstruct is_bit_reference_like> {\n static constexpr bool value = true;\n};\n#endif\n\ntemplate \nstruct has_format_as : std::false_type {};\ntemplate \nstruct has_format_as()))>>\n : std::true_type {};\n\ntemplate \nstruct has_format_as_member : std::false_type {};\ntemplate \nstruct has_format_as_member<\n T, void_t::format_as(std::declval()))>>\n : std::true_type {};\n\n} // namespace detail\n\ntemplate \nauto ptr(const std::unique_ptr& p) -> const void* {\n return p.get();\n}\ntemplate auto ptr(const std::shared_ptr& p) -> const void* {\n return p.get();\n}\n\n#if FMT_CPP_LIB_FILESYSTEM\n\ntemplate struct formatter {\n private:\n format_specs specs_;\n detail::arg_ref width_ref_;\n bool debug_ = false;\n char path_type_ = 0;\n\n public:\n FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }\n\n FMT_CONSTEXPR auto parse(parse_context& ctx) {\n auto it = ctx.begin(), end = ctx.end();\n if (it == end) return it;\n\n it = detail::parse_align(it, end, specs_);\n if (it == end) return it;\n\n Char c = *it;\n if ((c >= '0' && c <= '9') || c == '{')\n it = detail::parse_width(it, end, specs_, width_ref_, ctx);\n if (it != end && *it == '?') {\n debug_ = true;\n ++it;\n }\n if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);\n return it;\n }\n\n template \n auto format(const std::filesystem::path& p, FormatContext& ctx) const {\n auto specs = specs_;\n auto path_string =\n !path_type_ ? p.native()\n : p.generic_string();\n\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,\n ctx);\n if (!debug_) {\n auto s = detail::get_path_string(p, path_string);\n return detail::write(ctx.out(), basic_string_view(s), specs);\n }\n auto quoted = basic_memory_buffer();\n detail::write_escaped_path(quoted, p, path_string);\n return detail::write(ctx.out(),\n basic_string_view(quoted.data(), quoted.size()),\n specs);\n }\n};\n\nclass path : public std::filesystem::path {\n public:\n auto display_string() const -> std::string {\n const std::filesystem::path& base = *this;\n return fmt::format(FMT_STRING(\"{}\"), base);\n }\n auto system_string() const -> std::string { return string(); }\n\n auto generic_display_string() const -> std::string {\n const std::filesystem::path& base = *this;\n return fmt::format(FMT_STRING(\"{:g}\"), base);\n }\n auto generic_system_string() const -> std::string { return generic_string(); }\n};\n\n#endif // FMT_CPP_LIB_FILESYSTEM\n\ntemplate \nstruct formatter, Char>\n : nested_formatter, Char> {\n private:\n // This is a functor because C++11 doesn't support generic lambdas.\n struct writer {\n const std::bitset& bs;\n\n template \n FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {\n for (auto pos = N; pos > 0; --pos)\n out = detail::write(out, bs[pos - 1] ? Char('1') : Char('0'));\n return out;\n }\n };\n\n public:\n template \n auto format(const std::bitset& bs, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return this->write_padded(ctx, writer{bs});\n }\n};\n\ntemplate \nstruct formatter : basic_ostream_formatter {};\n\n#ifdef __cpp_lib_optional\ntemplate \nstruct formatter, Char,\n std::enable_if_t::value>> {\n private:\n formatter, Char> underlying_;\n static constexpr basic_string_view optional =\n detail::string_literal{};\n static constexpr basic_string_view none =\n detail::string_literal{};\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) {\n detail::maybe_set_debug_format(underlying_, true);\n return underlying_.parse(ctx);\n }\n\n template \n auto format(const std::optional& opt, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n if (!opt) return detail::write(ctx.out(), none);\n\n auto out = ctx.out();\n out = detail::write(out, optional);\n ctx.advance_to(out);\n out = underlying_.format(*opt, ctx);\n return detail::write(out, ')');\n }\n};\n#endif // __cpp_lib_optional\n\n#ifdef __cpp_lib_expected\ntemplate \nstruct formatter, Char,\n std::enable_if_t<(std::is_void::value ||\n is_formattable::value) &&\n is_formattable::value>> {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return ctx.begin();\n }\n\n template \n auto format(const std::expected& value, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto out = ctx.out();\n\n if (value.has_value()) {\n out = detail::write(out, \"expected(\");\n if constexpr (!std::is_void::value)\n out = detail::write_escaped_alternative(out, *value, ctx);\n } else {\n out = detail::write(out, \"unexpected(\");\n out = detail::write_escaped_alternative(out, value.error(), ctx);\n }\n *out++ = ')';\n return out;\n }\n};\n#endif // __cpp_lib_expected\n\n#ifdef __cpp_lib_source_location\ntemplate <> struct formatter {\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }\n\n template \n auto format(const std::source_location& loc, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto out = ctx.out();\n out = detail::write(out, loc.file_name());\n out = detail::write(out, ':');\n out = detail::write(out, loc.line());\n out = detail::write(out, ':');\n out = detail::write(out, loc.column());\n out = detail::write(out, \": \");\n out = detail::write(out, loc.function_name());\n return out;\n }\n};\n#endif\n\n#if FMT_CPP_LIB_VARIANT\n\ntemplate struct is_variant_like {\n static constexpr bool value = detail::is_variant_like_::value;\n};\n\ntemplate struct formatter {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return ctx.begin();\n }\n\n template \n auto format(const std::monostate&, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return detail::write(ctx.out(), \"monostate\");\n }\n};\n\ntemplate \nstruct formatter,\n detail::is_variant_formattable>>> {\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n return ctx.begin();\n }\n\n template \n auto format(const Variant& value, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto out = ctx.out();\n\n out = detail::write(out, \"variant(\");\n FMT_TRY {\n std::visit(\n [&](const auto& v) {\n out = detail::write_escaped_alternative(out, v, ctx);\n },\n value);\n }\n FMT_CATCH(const std::bad_variant_access&) {\n detail::write(out, \"valueless by exception\");\n }\n *out++ = ')';\n return out;\n }\n};\n\n#endif // FMT_CPP_LIB_VARIANT\n\ntemplate <> struct formatter {\n private:\n format_specs specs_;\n detail::arg_ref width_ref_;\n bool debug_ = false;\n\n public:\n FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }\n\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {\n auto it = ctx.begin(), end = ctx.end();\n if (it == end) return it;\n\n it = detail::parse_align(it, end, specs_);\n\n char c = *it;\n if (it != end && ((c >= '0' && c <= '9') || c == '{'))\n it = detail::parse_width(it, end, specs_, width_ref_, ctx);\n\n if (it != end && *it == '?') {\n debug_ = true;\n ++it;\n }\n if (it != end && *it == 's') {\n specs_.set_type(presentation_type::string);\n ++it;\n }\n return it;\n }\n\n template \n FMT_CONSTEXPR20 auto format(const std::error_code& ec,\n FormatContext& ctx) const -> decltype(ctx.out()) {\n auto specs = specs_;\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,\n ctx);\n auto buf = memory_buffer();\n if (specs_.type() == presentation_type::string) {\n buf.append(ec.message());\n } else {\n buf.append(string_view(ec.category().name()));\n buf.push_back(':');\n detail::write(appender(buf), ec.value());\n }\n auto quoted = memory_buffer();\n auto str = string_view(buf.data(), buf.size());\n if (debug_) {\n detail::write_escaped_string(std::back_inserter(quoted), str);\n str = string_view(quoted.data(), quoted.size());\n }\n return detail::write(ctx.out(), str, specs);\n }\n};\n\n#if FMT_USE_RTTI\ntemplate <> struct formatter {\n public:\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {\n return ctx.begin();\n }\n\n template \n auto format(const std::type_info& ti, Context& ctx) const\n -> decltype(ctx.out()) {\n return detail::write_demangled_name(ctx.out(), ti);\n }\n};\n#endif // FMT_USE_RTTI\n\ntemplate \nstruct formatter<\n T, char,\n typename std::enable_if::value>::type> {\n private:\n bool with_typename_ = false;\n\n public:\n FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {\n auto it = ctx.begin();\n auto end = ctx.end();\n if (it == end || *it == '}') return it;\n if (*it == 't') {\n ++it;\n with_typename_ = FMT_USE_RTTI != 0;\n }\n return it;\n }\n\n template \n auto format(const std::exception& ex, Context& ctx) const\n -> decltype(ctx.out()) {\n auto out = ctx.out();\n#if FMT_USE_RTTI\n if (with_typename_) {\n out = detail::write_demangled_name(out, typeid(ex));\n *out++ = ':';\n *out++ = ' ';\n }\n#endif\n return detail::write_bytes(out, string_view(ex.what()));\n }\n};\n\n// We can't use std::vector::reference and\n// std::bitset::reference because the compiler can't deduce Allocator and N\n// in partial specialization.\ntemplate \nstruct formatter::value>>\n : formatter {\n template \n FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return formatter::format(v, ctx);\n }\n};\n\ntemplate \nstruct formatter, Char,\n enable_if_t::value>>\n : formatter {\n template \n auto format(const std::atomic& v, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return formatter::format(v.load(), ctx);\n }\n};\n\n#ifdef __cpp_lib_atomic_flag_test\ntemplate \nstruct formatter : formatter {\n template \n auto format(const std::atomic_flag& v, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return formatter::format(v.test(), ctx);\n }\n};\n#endif // __cpp_lib_atomic_flag_test\n\ntemplate struct formatter, Char> {\n private:\n detail::dynamic_format_specs specs_;\n\n template \n FMT_CONSTEXPR auto do_format(const std::complex& c,\n detail::dynamic_format_specs& specs,\n FormatContext& ctx, OutputIt out) const\n -> OutputIt {\n if (c.real() != 0) {\n *out++ = Char('(');\n out = detail::write(out, c.real(), specs, ctx.locale());\n specs.set_sign(sign::plus);\n out = detail::write(out, c.imag(), specs, ctx.locale());\n if (!detail::isfinite(c.imag())) *out++ = Char(' ');\n *out++ = Char('i');\n *out++ = Char(')');\n return out;\n }\n out = detail::write(out, c.imag(), specs, ctx.locale());\n if (!detail::isfinite(c.imag())) *out++ = Char(' ');\n *out++ = Char('i');\n return out;\n }\n\n public:\n FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* {\n if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();\n return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,\n detail::type_constant::value);\n }\n\n template \n auto format(const std::complex& c, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n auto specs = specs_;\n if (specs.dynamic()) {\n detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,\n specs.width_ref, ctx);\n detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,\n specs.precision_ref, ctx);\n }\n\n if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());\n auto buf = basic_memory_buffer();\n\n auto outer_specs = format_specs();\n outer_specs.width = specs.width;\n outer_specs.copy_fill_from(specs);\n outer_specs.set_align(specs.align());\n\n specs.width = 0;\n specs.set_fill({});\n specs.set_align(align::none);\n\n do_format(c, specs, ctx, basic_appender(buf));\n return detail::write(ctx.out(),\n basic_string_view(buf.data(), buf.size()),\n outer_specs);\n }\n};\n\ntemplate \nstruct formatter, Char,\n // Guard against format_as because reference_wrapper is\n // implicitly convertible to T&.\n enable_if_t, Char>::value &&\n !detail::has_format_as::value &&\n !detail::has_format_as_member::value>>\n : formatter, Char> {\n template \n auto format(std::reference_wrapper ref, FormatContext& ctx) const\n -> decltype(ctx.out()) {\n return formatter, Char>::format(ref.get(), ctx);\n }\n};\n\nFMT_END_NAMESPACE\n\n#endif // FMT_STD_H_\n" }, { "path": "include/spdlog/fmt/bundled/xchar.h", "content": "// Formatting library for C++ - optional wchar_t and exotic character support\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_XCHAR_H_\n#define FMT_XCHAR_H_\n\n#include \"color.h\"\n#include \"format.h\"\n#include \"ostream.h\"\n#include \"ranges.h\"\n\n#ifndef FMT_MODULE\n# include \n# if FMT_USE_LOCALE\n# include \n# endif\n#endif\n\nFMT_BEGIN_NAMESPACE\nnamespace detail {\n\ntemplate \nusing is_exotic_char = bool_constant::value>;\n\ntemplate struct format_string_char {};\n\ntemplate \nstruct format_string_char<\n S, void_t())))>> {\n using type = char_t;\n};\n\ntemplate \nstruct format_string_char<\n S, enable_if_t::value>> {\n using type = typename S::char_type;\n};\n\ntemplate \nusing format_string_char_t = typename format_string_char::type;\n\ninline auto write_loc(basic_appender out, loc_value value,\n const format_specs& specs, locale_ref loc) -> bool {\n#if FMT_USE_LOCALE\n auto& numpunct =\n std::use_facet>(loc.get());\n auto separator = std::wstring();\n auto grouping = numpunct.grouping();\n if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());\n return value.visit(loc_writer{out, specs, separator, grouping, {}});\n#endif\n return false;\n}\n\ntemplate \nvoid vformat_to(buffer& buf, basic_string_view fmt,\n basic_format_args> args,\n locale_ref loc = {}) {\n static_assert(!std::is_same::value, \"\");\n auto out = basic_appender(buf);\n parse_format_string(\n fmt, format_handler{parse_context(fmt), {out, args, loc}});\n}\n} // namespace detail\n\nFMT_BEGIN_EXPORT\n\nusing wstring_view = basic_string_view;\nusing wformat_parse_context = parse_context;\nusing wformat_context = buffered_context;\nusing wformat_args = basic_format_args;\nusing wmemory_buffer = basic_memory_buffer;\n\ntemplate struct basic_fstring {\n private:\n basic_string_view str_;\n\n static constexpr int num_static_named_args =\n detail::count_static_named_args();\n\n using checker = detail::format_string_checker<\n Char, static_cast(sizeof...(T)), num_static_named_args,\n num_static_named_args != detail::count_named_args()>;\n\n using arg_pack = detail::arg_pack;\n\n public:\n using t = basic_fstring;\n\n template >::value)>\n FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {\n if (FMT_USE_CONSTEVAL)\n detail::parse_format_string(s, checker(s, arg_pack()));\n }\n template ::value&&\n std::is_same::value)>\n FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {\n FMT_CONSTEXPR auto sv = basic_string_view(S());\n FMT_CONSTEXPR int ignore =\n (parse_format_string(sv, checker(sv, arg_pack())), 0);\n detail::ignore_unused(ignore);\n }\n basic_fstring(runtime_format_string fmt) : str_(fmt.str) {}\n\n operator basic_string_view() const { return str_; }\n auto get() const -> basic_string_view { return str_; }\n};\n\ntemplate \nusing basic_format_string = basic_fstring;\n\ntemplate \nusing wformat_string = typename basic_format_string::t;\ninline auto runtime(wstring_view s) -> runtime_format_string {\n return {{s}};\n}\n\ntemplate \nconstexpr auto make_wformat_args(T&... args)\n -> decltype(fmt::make_format_args(args...)) {\n return fmt::make_format_args(args...);\n}\n\n#if !FMT_USE_NONTYPE_TEMPLATE_ARGS\ninline namespace literals {\ninline auto operator\"\"_a(const wchar_t* s, size_t) -> detail::udl_arg {\n return {s};\n}\n} // namespace literals\n#endif\n\ntemplate \nauto join(It begin, Sentinel end, wstring_view sep)\n -> join_view {\n return {begin, end, sep};\n}\n\ntemplate ::value)>\nauto join(Range&& range, wstring_view sep)\n -> join_view {\n return join(std::begin(range), std::end(range), sep);\n}\n\ntemplate \nauto join(std::initializer_list list, wstring_view sep)\n -> join_view {\n return join(std::begin(list), std::end(list), sep);\n}\n\ntemplate ::value)>\nauto join(const Tuple& tuple, basic_string_view sep)\n -> tuple_join_view {\n return {tuple, sep};\n}\n\ntemplate ::value)>\nauto vformat(basic_string_view fmt,\n basic_format_args> args)\n -> std::basic_string {\n auto buf = basic_memory_buffer();\n detail::vformat_to(buf, fmt, args);\n return {buf.data(), buf.size()};\n}\n\ntemplate \nauto format(wformat_string fmt, T&&... args) -> std::wstring {\n return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));\n}\n\ntemplate \nauto format_to(OutputIt out, wformat_string fmt, T&&... args)\n -> OutputIt {\n return vformat_to(out, fmt::wstring_view(fmt),\n fmt::make_wformat_args(args...));\n}\n\n// Pass char_t as a default template parameter instead of using\n// std::basic_string> to reduce the symbol size.\ntemplate ,\n FMT_ENABLE_IF(!std::is_same::value &&\n !std::is_same::value)>\nauto format(const S& fmt, T&&... args) -> std::basic_string {\n return vformat(detail::to_string_view(fmt),\n fmt::make_format_args>(args...));\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_exotic_char::value)>\ninline auto vformat(locale_ref loc, const S& fmt,\n basic_format_args> args)\n -> std::basic_string {\n auto buf = basic_memory_buffer();\n detail::vformat_to(buf, detail::to_string_view(fmt), args, loc);\n return {buf.data(), buf.size()};\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_exotic_char::value)>\ninline auto format(locale_ref loc, const S& fmt, T&&... args)\n -> std::basic_string {\n return vformat(loc, detail::to_string_view(fmt),\n fmt::make_format_args>(args...));\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_output_iterator::value&&\n detail::is_exotic_char::value)>\nauto vformat_to(OutputIt out, const S& fmt,\n basic_format_args> args) -> OutputIt {\n auto&& buf = detail::get_buffer(out);\n detail::vformat_to(buf, detail::to_string_view(fmt), args);\n return detail::get_iterator(buf, out);\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_output_iterator::value &&\n !std::is_same::value &&\n !std::is_same::value)>\ninline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {\n return vformat_to(out, detail::to_string_view(fmt),\n fmt::make_format_args>(args...));\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_output_iterator::value&&\n detail::is_exotic_char::value)>\ninline auto vformat_to(OutputIt out, locale_ref loc, const S& fmt,\n basic_format_args> args)\n -> OutputIt {\n auto&& buf = detail::get_buffer(out);\n vformat_to(buf, detail::to_string_view(fmt), args, loc);\n return detail::get_iterator(buf, out);\n}\n\ntemplate ,\n bool enable = detail::is_output_iterator::value &&\n detail::is_exotic_char::value>\ninline auto format_to(OutputIt out, locale_ref loc, const S& fmt, T&&... args)\n -> typename std::enable_if::type {\n return vformat_to(out, loc, detail::to_string_view(fmt),\n fmt::make_format_args>(args...));\n}\n\ntemplate ::value&&\n detail::is_exotic_char::value)>\ninline auto vformat_to_n(OutputIt out, size_t n, basic_string_view fmt,\n basic_format_args> args)\n -> format_to_n_result {\n using traits = detail::fixed_buffer_traits;\n auto buf = detail::iterator_buffer(out, n);\n detail::vformat_to(buf, fmt, args);\n return {buf.out(), buf.count()};\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_output_iterator::value&&\n detail::is_exotic_char::value)>\ninline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)\n -> format_to_n_result {\n return vformat_to_n(out, n, fmt::basic_string_view(fmt),\n fmt::make_format_args>(args...));\n}\n\ntemplate ,\n FMT_ENABLE_IF(detail::is_exotic_char::value)>\ninline auto formatted_size(const S& fmt, T&&... args) -> size_t {\n auto buf = detail::counting_buffer();\n detail::vformat_to(buf, detail::to_string_view(fmt),\n fmt::make_format_args>(args...));\n return buf.count();\n}\n\ninline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {\n auto buf = wmemory_buffer();\n detail::vformat_to(buf, fmt, args);\n buf.push_back(L'\\0');\n if (std::fputws(buf.data(), f) == -1)\n FMT_THROW(system_error(errno, FMT_STRING(\"cannot write to file\")));\n}\n\ninline void vprint(wstring_view fmt, wformat_args args) {\n vprint(stdout, fmt, args);\n}\n\ntemplate \nvoid print(std::FILE* f, wformat_string fmt, T&&... args) {\n return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));\n}\n\ntemplate void print(wformat_string fmt, T&&... args) {\n return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));\n}\n\ntemplate \nvoid println(std::FILE* f, wformat_string fmt, T&&... args) {\n return print(f, L\"{}\\n\", fmt::format(fmt, std::forward(args)...));\n}\n\ntemplate void println(wformat_string fmt, T&&... args) {\n return print(L\"{}\\n\", fmt::format(fmt, std::forward(args)...));\n}\n\ninline auto vformat(text_style ts, wstring_view fmt, wformat_args args)\n -> std::wstring {\n auto buf = wmemory_buffer();\n detail::vformat_to(buf, ts, fmt, args);\n return {buf.data(), buf.size()};\n}\n\ntemplate \ninline auto format(text_style ts, wformat_string fmt, T&&... args)\n -> std::wstring {\n return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));\n}\n\ninline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {\n auto buffer = basic_memory_buffer();\n detail::vformat_to(buffer, fmt, args);\n detail::write_buffer(os, buffer);\n}\n\ntemplate \nvoid print(std::wostream& os, wformat_string fmt, T&&... args) {\n vprint(os, fmt, fmt::make_format_args>(args...));\n}\n\ntemplate \nvoid println(std::wostream& os, wformat_string fmt, T&&... args) {\n print(os, L\"{}\\n\", fmt::format(fmt, std::forward(args)...));\n}\n\n/// Converts `value` to `std::wstring` using the default format for type `T`.\ntemplate inline auto to_wstring(const T& value) -> std::wstring {\n return format(FMT_STRING(L\"{}\"), value);\n}\nFMT_END_EXPORT\nFMT_END_NAMESPACE\n\n#endif // FMT_XCHAR_H_\n" }, { "path": "include/spdlog/fmt/chrono.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's chrono support\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/fmt/compile.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's compile-time support\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/fmt/fmt.h", "content": "//\n// Copyright(c) 2016-2018 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n\n//\n// Include a bundled header-only copy of fmtlib or an external one.\n// By default spdlog include its own copy.\n//\n#include \n\n#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format\n#include \n#elif !defined(SPDLOG_FMT_EXTERNAL)\n#if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)\n#define FMT_HEADER_ONLY\n#endif\n#ifndef FMT_USE_WINDOWS_H\n#define FMT_USE_WINDOWS_H 0\n#endif\n#include \n#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib\n#include \n#endif\n" }, { "path": "include/spdlog/fmt/ostr.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's ostream support\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/fmt/ranges.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's ranges support\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/fmt/std.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's std support (for formatting e.g.\n// std::filesystem::path, std::thread::id, std::monostate, std::variant, ...)\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/fmt/xchar.h", "content": "//\n// Copyright(c) 2016 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n//\n// include bundled or external copy of fmtlib's xchar support\n//\n#include \n\n#if !defined(SPDLOG_USE_STD_FORMAT)\n#if !defined(SPDLOG_FMT_EXTERNAL)\n#ifdef SPDLOG_HEADER_ONLY\n#ifndef FMT_HEADER_ONLY\n#define FMT_HEADER_ONLY\n#endif\n#endif\n#include \n#else\n#include \n#endif\n#endif\n" }, { "path": "include/spdlog/formatter.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\n\nclass formatter {\npublic:\n virtual ~formatter() = default;\n virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0;\n virtual std::unique_ptr clone() const = 0;\n};\n} // namespace spdlog\n" }, { "path": "include/spdlog/fwd.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\nnamespace spdlog {\nclass logger;\nclass formatter;\n\nnamespace sinks {\nclass sink;\n}\n\nnamespace level {\nenum level_enum : int;\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/logger-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n#include \n\n#include \n\nnamespace spdlog {\n\n// public methods\nSPDLOG_INLINE logger::logger(const logger &other)\n : name_(other.name_),\n sinks_(other.sinks_),\n level_(other.level_.load(std::memory_order_relaxed)),\n flush_level_(other.flush_level_.load(std::memory_order_relaxed)),\n custom_err_handler_(other.custom_err_handler_),\n tracer_(other.tracer_) {}\n\nSPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT\n : name_(std::move(other.name_)),\n sinks_(std::move(other.sinks_)),\n level_(other.level_.load(std::memory_order_relaxed)),\n flush_level_(other.flush_level_.load(std::memory_order_relaxed)),\n custom_err_handler_(std::move(other.custom_err_handler_)),\n tracer_(std::move(other.tracer_))\n\n{}\n\nSPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT {\n this->swap(other);\n return *this;\n}\n\nSPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT {\n name_.swap(other.name_);\n sinks_.swap(other.sinks_);\n\n // swap level_\n auto other_level = other.level_.load();\n auto my_level = level_.exchange(other_level);\n other.level_.store(my_level);\n\n // swap flush level_\n other_level = other.flush_level_.load();\n my_level = flush_level_.exchange(other_level);\n other.flush_level_.store(my_level);\n\n custom_err_handler_.swap(other.custom_err_handler_);\n std::swap(tracer_, other.tracer_);\n}\n\nSPDLOG_INLINE void swap(logger &a, logger &b) noexcept { a.swap(b); }\n\nSPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }\n\nSPDLOG_INLINE level::level_enum logger::level() const {\n return static_cast(level_.load(std::memory_order_relaxed));\n}\n\nSPDLOG_INLINE const std::string &logger::name() const { return name_; }\n\n// set formatting for the sinks in this logger.\n// each sink will get a separate instance of the formatter object.\nSPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) {\n for (auto it = sinks_.begin(); it != sinks_.end(); ++it) {\n if (std::next(it) == sinks_.end()) {\n // last element - we can be move it.\n (*it)->set_formatter(std::move(f));\n break; // to prevent clang-tidy warning\n } else {\n (*it)->set_formatter(f->clone());\n }\n }\n}\n\nSPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) {\n auto new_formatter = details::make_unique(std::move(pattern), time_type);\n set_formatter(std::move(new_formatter));\n}\n\n// create new backtrace sink and move to it all our child sinks\nSPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); }\n\n// restore orig sinks and level and delete the backtrace sink\nSPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); }\n\nSPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); }\n\n// flush functions\nSPDLOG_INLINE void logger::flush() { flush_(); }\n\nSPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); }\n\nSPDLOG_INLINE level::level_enum logger::flush_level() const {\n return static_cast(flush_level_.load(std::memory_order_relaxed));\n}\n\n// sinks\nSPDLOG_INLINE const std::vector &logger::sinks() const { return sinks_; }\n\nSPDLOG_INLINE std::vector &logger::sinks() { return sinks_; }\n\n// error handler\nSPDLOG_INLINE void logger::set_error_handler(err_handler handler) {\n custom_err_handler_ = std::move(handler);\n}\n\n// create new logger with same sinks and configuration.\nSPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) {\n auto cloned = std::make_shared(*this);\n cloned->name_ = std::move(logger_name);\n return cloned;\n}\n\n// protected methods\nSPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg,\n bool log_enabled,\n bool traceback_enabled) {\n if (log_enabled) {\n sink_it_(log_msg);\n }\n if (traceback_enabled) {\n tracer_.push_back(log_msg);\n }\n}\n\nSPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) {\n for (auto &sink : sinks_) {\n if (sink->should_log(msg.level)) {\n SPDLOG_TRY { sink->log(msg); }\n SPDLOG_LOGGER_CATCH(msg.source)\n }\n }\n\n if (should_flush_(msg)) {\n flush_();\n }\n}\n\nSPDLOG_INLINE void logger::flush_() {\n for (auto &sink : sinks_) {\n SPDLOG_TRY { sink->flush(); }\n SPDLOG_LOGGER_CATCH(source_loc())\n }\n}\n\nSPDLOG_INLINE void logger::dump_backtrace_() {\n using details::log_msg;\n if (tracer_.enabled() && !tracer_.empty()) {\n sink_it_(\n log_msg{name(), level::info, \"****************** Backtrace Start ******************\"});\n tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });\n sink_it_(\n log_msg{name(), level::info, \"****************** Backtrace End ********************\"});\n }\n}\n\nSPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) const {\n return (msg.level >= flush_level()) && (msg.level != level::off);\n}\n\nSPDLOG_INLINE void logger::err_handler_(const std::string &msg) const {\n if (custom_err_handler_) {\n custom_err_handler_(msg);\n } else {\n using std::chrono::system_clock;\n static std::mutex mutex;\n static std::chrono::system_clock::time_point last_report_time;\n static size_t err_counter = 0;\n std::lock_guard lk{mutex};\n auto now = system_clock::now();\n err_counter++;\n if (now - last_report_time < std::chrono::seconds(1)) {\n return;\n }\n last_report_time = now;\n auto tm_time = details::os::localtime(system_clock::to_time_t(now));\n char date_buf[64];\n std::strftime(date_buf, sizeof(date_buf), \"%Y-%m-%d %H:%M:%S\", &tm_time);\n#if defined(USING_R) && defined(R_R_H) // if in R environment\n REprintf(\"[*** LOG ERROR #%04zu ***] [%s] [%s] %s\\n\", err_counter, date_buf, name().c_str(),\n msg.c_str());\n#else\n std::fprintf(stderr, \"[*** LOG ERROR #%04zu ***] [%s] [%s] %s\\n\", err_counter, date_buf,\n name().c_str(), msg.c_str());\n#endif\n }\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/logger.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n// Thread safe logger (except for set_error_handler())\n// Has name, log level, vector of std::shared sink pointers and formatter\n// Upon each log write the logger:\n// 1. Checks if its log level is enough to log the message and if yes:\n// 2. Call the underlying sinks to do the job.\n// 3. Each sink use its own private copy of a formatter to format the message\n// and send to its destination.\n//\n// The use of private formatter per sink provides the opportunity to cache some\n// formatted data, and support for different format per sink.\n\n#include \n#include \n#include \n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\n#ifndef _WIN32\n#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows\n#endif\n#include \n#endif\n\n#include \n\n#ifndef SPDLOG_NO_EXCEPTIONS\n#define SPDLOG_LOGGER_CATCH(location) \\\n catch (const std::exception &ex) { \\\n if (location.filename) { \\\n err_handler_(fmt_lib::format(SPDLOG_FMT_STRING(\"{} [{}({})]\"), ex.what(), \\\n location.filename, location.line)); \\\n } else { \\\n err_handler_(ex.what()); \\\n } \\\n } \\\n catch (...) { \\\n err_handler_(\"Rethrowing unknown exception in logger\"); \\\n throw; \\\n }\n#else\n#define SPDLOG_LOGGER_CATCH(location)\n#endif\n\nnamespace spdlog {\n\nclass SPDLOG_API logger {\npublic:\n // Empty logger\n explicit logger(std::string name)\n : name_(std::move(name)),\n sinks_() {}\n\n // Logger with range on sinks\n template \n logger(std::string name, It begin, It end)\n : name_(std::move(name)),\n sinks_(begin, end) {}\n\n // Logger with single sink\n logger(std::string name, sink_ptr single_sink)\n : logger(std::move(name), {std::move(single_sink)}) {}\n\n // Logger with sinks init list\n logger(std::string name, sinks_init_list sinks)\n : logger(std::move(name), sinks.begin(), sinks.end()) {}\n\n virtual ~logger() = default;\n\n logger(const logger &other);\n logger(logger &&other) SPDLOG_NOEXCEPT;\n logger &operator=(logger other) SPDLOG_NOEXCEPT;\n void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;\n\n template \n void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args &&...args) {\n#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format < 202207L\n log_(loc, lvl, fmt, std::forward(args)...);\n#else\n log_(loc, lvl, fmt.get(), std::forward(args)...);\n#endif\n }\n\n template \n void log(level::level_enum lvl, format_string_t fmt, Args &&...args) {\n log(source_loc{}, lvl, fmt, std::forward(args)...);\n }\n\n template \n void log(level::level_enum lvl, const T &msg) {\n log(source_loc{}, lvl, msg);\n }\n\n // T cannot be statically converted to format string (including string_view/wstring_view)\n template ::value,\n int>::type = 0>\n void log(source_loc loc, level::level_enum lvl, const T &msg) {\n log(loc, lvl, \"{}\", msg);\n }\n\n void log(log_clock::time_point log_time,\n source_loc loc,\n level::level_enum lvl,\n string_view_t msg) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n\n details::log_msg log_msg(log_time, loc, name_, lvl, msg);\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n\n void log(source_loc loc, level::level_enum lvl, string_view_t msg) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n\n details::log_msg log_msg(loc, name_, lvl, msg);\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n\n void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); }\n\n template \n void trace(format_string_t fmt, Args &&...args) {\n log(level::trace, fmt, std::forward(args)...);\n }\n\n template \n void debug(format_string_t fmt, Args &&...args) {\n log(level::debug, fmt, std::forward(args)...);\n }\n\n template \n void info(format_string_t fmt, Args &&...args) {\n log(level::info, fmt, std::forward(args)...);\n }\n\n template \n void warn(format_string_t fmt, Args &&...args) {\n log(level::warn, fmt, std::forward(args)...);\n }\n\n template \n void error(format_string_t fmt, Args &&...args) {\n log(level::err, fmt, std::forward(args)...);\n }\n\n template \n void critical(format_string_t fmt, Args &&...args) {\n log(level::critical, fmt, std::forward(args)...);\n }\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\n template \n void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args &&...args) {\n#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format < 202207L\n log_(loc, lvl, fmt, std::forward(args)...);\n#else\n log_(loc, lvl, fmt.get(), std::forward(args)...);\n#endif\n }\n\n template \n void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) {\n log(source_loc{}, lvl, fmt, std::forward(args)...);\n }\n\n void log(log_clock::time_point log_time,\n source_loc loc,\n level::level_enum lvl,\n wstring_view_t msg) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n\n memory_buf_t buf;\n details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);\n details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size()));\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n\n void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n\n memory_buf_t buf;\n details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf);\n details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n\n void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); }\n\n template \n void trace(wformat_string_t fmt, Args &&...args) {\n log(level::trace, fmt, std::forward(args)...);\n }\n\n template \n void debug(wformat_string_t fmt, Args &&...args) {\n log(level::debug, fmt, std::forward(args)...);\n }\n\n template \n void info(wformat_string_t fmt, Args &&...args) {\n log(level::info, fmt, std::forward(args)...);\n }\n\n template \n void warn(wformat_string_t fmt, Args &&...args) {\n log(level::warn, fmt, std::forward(args)...);\n }\n\n template \n void error(wformat_string_t fmt, Args &&...args) {\n log(level::err, fmt, std::forward(args)...);\n }\n\n template \n void critical(wformat_string_t fmt, Args &&...args) {\n log(level::critical, fmt, std::forward(args)...);\n }\n#endif\n\n template \n void trace(const T &msg) {\n log(level::trace, msg);\n }\n\n template \n void debug(const T &msg) {\n log(level::debug, msg);\n }\n\n template \n void info(const T &msg) {\n log(level::info, msg);\n }\n\n template \n void warn(const T &msg) {\n log(level::warn, msg);\n }\n\n template \n void error(const T &msg) {\n log(level::err, msg);\n }\n\n template \n void critical(const T &msg) {\n log(level::critical, msg);\n }\n\n // return true if logging is enabled for the given level.\n bool should_log(level::level_enum msg_level) const {\n return msg_level >= level_.load(std::memory_order_relaxed);\n }\n\n // return true if backtrace logging is enabled.\n bool should_backtrace() const { return tracer_.enabled(); }\n\n void set_level(level::level_enum log_level);\n\n level::level_enum level() const;\n\n const std::string &name() const;\n\n // set formatting for the sinks in this logger.\n // each sink will get a separate instance of the formatter object.\n void set_formatter(std::unique_ptr f);\n\n // set formatting for the sinks in this logger.\n // equivalent to\n // set_formatter(make_unique(pattern, time_type))\n // Note: each sink will get a new instance of a formatter object, replacing the old one.\n void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);\n\n // backtrace support.\n // efficiently store all debug/trace messages in a circular buffer until needed for debugging.\n void enable_backtrace(size_t n_messages);\n void disable_backtrace();\n void dump_backtrace();\n\n // flush functions\n void flush();\n void flush_on(level::level_enum log_level);\n level::level_enum flush_level() const;\n\n // sinks\n const std::vector &sinks() const;\n\n std::vector &sinks();\n\n // error handler\n void set_error_handler(err_handler);\n\n // create new logger with same sinks and configuration.\n virtual std::shared_ptr clone(std::string logger_name);\n\nprotected:\n std::string name_;\n std::vector sinks_;\n spdlog::level_t level_{level::info};\n spdlog::level_t flush_level_{level::off};\n err_handler custom_err_handler_{nullptr};\n details::backtracer tracer_;\n\n // common implementation for after templated public api has been resolved\n template \n void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n SPDLOG_TRY {\n memory_buf_t buf;\n#ifdef SPDLOG_USE_STD_FORMAT\n fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...));\n#else\n fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...));\n#endif\n\n details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n SPDLOG_LOGGER_CATCH(loc)\n }\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\n template \n void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) {\n bool log_enabled = should_log(lvl);\n bool traceback_enabled = tracer_.enabled();\n if (!log_enabled && !traceback_enabled) {\n return;\n }\n SPDLOG_TRY {\n // format to wmemory_buffer and convert to utf8\n wmemory_buf_t wbuf;\n fmt_lib::vformat_to(std::back_inserter(wbuf), fmt,\n fmt_lib::make_format_args(args...));\n\n memory_buf_t buf;\n details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);\n details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));\n log_it_(log_msg, log_enabled, traceback_enabled);\n }\n SPDLOG_LOGGER_CATCH(loc)\n }\n#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT\n\n // log the given message (if the given log level is high enough),\n // and save backtrace (if backtrace is enabled).\n void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);\n virtual void sink_it_(const details::log_msg &msg);\n virtual void flush_();\n void dump_backtrace_();\n bool should_flush_(const details::log_msg &msg) const;\n\n // handle errors during logging.\n // default handler prints the error to stderr at max rate of 1 message/sec.\n void err_handler_(const std::string &msg) const;\n};\n\nvoid swap(logger &a, logger &b) noexcept;\n\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"logger-inl.h\"\n#endif\n" }, { "path": "include/spdlog/mdc.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#if defined(SPDLOG_NO_TLS)\n#error \"This header requires thread local storage support, but SPDLOG_NO_TLS is defined.\"\n#endif\n\n#include \n#include \n\n#include \n\n// MDC is a simple map of key->string values stored in thread local storage whose content will be\n// printed by the loggers. Note: Not supported in async mode (thread local storage - so the async\n// thread pool have different copy).\n//\n// Usage example:\n// spdlog::mdc::put(\"mdc_key_1\", \"mdc_value_1\");\n// spdlog::info(\"Hello, {}\", \"World!\"); // => [2024-04-26 02:08:05.040] [info]\n// [mdc_key_1:mdc_value_1] Hello, World!\n\nnamespace spdlog {\nclass SPDLOG_API mdc {\npublic:\n using mdc_map_t = std::map;\n\n static void put(const std::string &key, const std::string &value) {\n get_context()[key] = value;\n }\n\n static std::string get(const std::string &key) {\n auto &context = get_context();\n auto it = context.find(key);\n if (it != context.end()) {\n return it->second;\n }\n return \"\";\n }\n\n static void remove(const std::string &key) { get_context().erase(key); }\n\n static void clear() { get_context().clear(); }\n\n static mdc_map_t &get_context() {\n static thread_local mdc_map_t context;\n return context;\n }\n};\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/pattern_formatter-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n#include \n\n#ifndef SPDLOG_NO_TLS\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\n///////////////////////////////////////////////////////////////////////\n// name & level pattern appender\n///////////////////////////////////////////////////////////////////////\n\nclass scoped_padder {\npublic:\n scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest)\n : padinfo_(padinfo),\n dest_(dest) {\n remaining_pad_ = static_cast(padinfo.width_) - static_cast(wrapped_size);\n if (remaining_pad_ <= 0) {\n return;\n }\n\n if (padinfo_.side_ == padding_info::pad_side::left) {\n pad_it(remaining_pad_);\n remaining_pad_ = 0;\n } else if (padinfo_.side_ == padding_info::pad_side::center) {\n auto half_pad = remaining_pad_ / 2;\n auto reminder = remaining_pad_ & 1;\n pad_it(half_pad);\n remaining_pad_ = half_pad + reminder; // for the right side\n }\n }\n\n template \n static unsigned int count_digits(T n) {\n return fmt_helper::count_digits(n);\n }\n\n ~scoped_padder() {\n if (remaining_pad_ >= 0) {\n pad_it(remaining_pad_);\n } else if (padinfo_.truncate_) {\n long new_size = static_cast(dest_.size()) + remaining_pad_;\n if (new_size < 0) {\n new_size = 0;\n }\n dest_.resize(static_cast(new_size));\n }\n }\n\nprivate:\n void pad_it(long count) {\n fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast(count)),\n dest_);\n }\n\n const padding_info &padinfo_;\n memory_buf_t &dest_;\n long remaining_pad_;\n string_view_t spaces_{\" \", 64};\n};\n\nstruct null_scoped_padder {\n null_scoped_padder(size_t /*wrapped_size*/,\n const padding_info & /*padinfo*/,\n memory_buf_t & /*dest*/) {}\n\n template \n static unsigned int count_digits(T /* number */) {\n return 0;\n }\n};\n\ntemplate \nclass name_formatter final : public flag_formatter {\npublic:\n explicit name_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n ScopedPadder p(msg.logger_name.size(), padinfo_, dest);\n fmt_helper::append_string_view(msg.logger_name, dest);\n }\n};\n\n// log level appender\ntemplate \nclass level_formatter final : public flag_formatter {\npublic:\n explicit level_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n const string_view_t &level_name = level::to_string_view(msg.level);\n ScopedPadder p(level_name.size(), padinfo_, dest);\n fmt_helper::append_string_view(level_name, dest);\n }\n};\n\n// short log level appender\ntemplate \nclass short_level_formatter final : public flag_formatter {\npublic:\n explicit short_level_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n string_view_t level_name{level::to_short_c_str(msg.level)};\n ScopedPadder p(level_name.size(), padinfo_, dest);\n fmt_helper::append_string_view(level_name, dest);\n }\n};\n\n///////////////////////////////////////////////////////////////////////\n// Date time pattern appenders\n///////////////////////////////////////////////////////////////////////\n\nstatic const char *ampm(const tm &t) { return t.tm_hour >= 12 ? \"PM\" : \"AM\"; }\n\nstatic int to12h(const tm &t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; }\n\n// Abbreviated weekday name\nstatic std::array days{{\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"}};\n\ntemplate \nclass a_formatter final : public flag_formatter {\npublic:\n explicit a_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n string_view_t field_value{days[static_cast(tm_time.tm_wday)]};\n ScopedPadder p(field_value.size(), padinfo_, dest);\n fmt_helper::append_string_view(field_value, dest);\n }\n};\n\n// Full weekday name\nstatic std::array full_days{\n {\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"}};\n\ntemplate \nclass A_formatter : public flag_formatter {\npublic:\n explicit A_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n string_view_t field_value{full_days[static_cast(tm_time.tm_wday)]};\n ScopedPadder p(field_value.size(), padinfo_, dest);\n fmt_helper::append_string_view(field_value, dest);\n }\n};\n\n// Abbreviated month\nstatic const std::array months{\n {\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"}};\n\ntemplate \nclass b_formatter final : public flag_formatter {\npublic:\n explicit b_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n string_view_t field_value{months[static_cast(tm_time.tm_mon)]};\n ScopedPadder p(field_value.size(), padinfo_, dest);\n fmt_helper::append_string_view(field_value, dest);\n }\n};\n\n// Full month name\nstatic const std::array full_months{{\"January\", \"February\", \"March\", \"April\",\n \"May\", \"June\", \"July\", \"August\", \"September\",\n \"October\", \"November\", \"December\"}};\n\ntemplate \nclass B_formatter final : public flag_formatter {\npublic:\n explicit B_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n string_view_t field_value{full_months[static_cast(tm_time.tm_mon)]};\n ScopedPadder p(field_value.size(), padinfo_, dest);\n fmt_helper::append_string_view(field_value, dest);\n }\n};\n\n// Date and time representation (Thu Aug 23 15:35:46 2014)\ntemplate \nclass c_formatter final : public flag_formatter {\npublic:\n explicit c_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 24;\n ScopedPadder p(field_size, padinfo_, dest);\n\n fmt_helper::append_string_view(days[static_cast(tm_time.tm_wday)], dest);\n dest.push_back(' ');\n fmt_helper::append_string_view(months[static_cast(tm_time.tm_mon)], dest);\n dest.push_back(' ');\n fmt_helper::append_int(tm_time.tm_mday, dest);\n dest.push_back(' ');\n // time\n\n fmt_helper::pad2(tm_time.tm_hour, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_min, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_sec, dest);\n dest.push_back(' ');\n fmt_helper::append_int(tm_time.tm_year + 1900, dest);\n }\n};\n\n// year - 2 digit\ntemplate \nclass C_formatter final : public flag_formatter {\npublic:\n explicit C_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_year % 100, dest);\n }\n};\n\n// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01\ntemplate \nclass D_formatter final : public flag_formatter {\npublic:\n explicit D_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 8;\n ScopedPadder p(field_size, padinfo_, dest);\n\n fmt_helper::pad2(tm_time.tm_mon + 1, dest);\n dest.push_back('/');\n fmt_helper::pad2(tm_time.tm_mday, dest);\n dest.push_back('/');\n fmt_helper::pad2(tm_time.tm_year % 100, dest);\n }\n};\n\n// year - 4 digit\ntemplate \nclass Y_formatter final : public flag_formatter {\npublic:\n explicit Y_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 4;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::append_int(tm_time.tm_year + 1900, dest);\n }\n};\n\n// month 1-12\ntemplate \nclass m_formatter final : public flag_formatter {\npublic:\n explicit m_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_mon + 1, dest);\n }\n};\n\n// day of month 1-31\ntemplate \nclass d_formatter final : public flag_formatter {\npublic:\n explicit d_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_mday, dest);\n }\n};\n\n// hours in 24 format 0-23\ntemplate \nclass H_formatter final : public flag_formatter {\npublic:\n explicit H_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_hour, dest);\n }\n};\n\n// hours in 12 format 1-12\ntemplate \nclass I_formatter final : public flag_formatter {\npublic:\n explicit I_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(to12h(tm_time), dest);\n }\n};\n\n// minutes 0-59\ntemplate \nclass M_formatter final : public flag_formatter {\npublic:\n explicit M_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_min, dest);\n }\n};\n\n// seconds 0-59\ntemplate \nclass S_formatter final : public flag_formatter {\npublic:\n explicit S_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad2(tm_time.tm_sec, dest);\n }\n};\n\n// milliseconds\ntemplate \nclass e_formatter final : public flag_formatter {\npublic:\n explicit e_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n auto millis = fmt_helper::time_fraction(msg.time);\n const size_t field_size = 3;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad3(static_cast(millis.count()), dest);\n }\n};\n\n// microseconds\ntemplate \nclass f_formatter final : public flag_formatter {\npublic:\n explicit f_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n auto micros = fmt_helper::time_fraction(msg.time);\n\n const size_t field_size = 6;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad6(static_cast(micros.count()), dest);\n }\n};\n\n// nanoseconds\ntemplate \nclass F_formatter final : public flag_formatter {\npublic:\n explicit F_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n auto ns = fmt_helper::time_fraction(msg.time);\n const size_t field_size = 9;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::pad9(static_cast(ns.count()), dest);\n }\n};\n\n// seconds since epoch\ntemplate \nclass E_formatter final : public flag_formatter {\npublic:\n explicit E_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n const size_t field_size = 10;\n ScopedPadder p(field_size, padinfo_, dest);\n auto duration = msg.time.time_since_epoch();\n auto seconds = std::chrono::duration_cast(duration).count();\n fmt_helper::append_int(seconds, dest);\n }\n};\n\n// AM/PM\ntemplate \nclass p_formatter final : public flag_formatter {\npublic:\n explicit p_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 2;\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::append_string_view(ampm(tm_time), dest);\n }\n};\n\n// 12 hour clock 02:55:02 pm\ntemplate \nclass r_formatter final : public flag_formatter {\npublic:\n explicit r_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 11;\n ScopedPadder p(field_size, padinfo_, dest);\n\n fmt_helper::pad2(to12h(tm_time), dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_min, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_sec, dest);\n dest.push_back(' ');\n fmt_helper::append_string_view(ampm(tm_time), dest);\n }\n};\n\n// 24-hour HH:MM time, equivalent to %H:%M\ntemplate \nclass R_formatter final : public flag_formatter {\npublic:\n explicit R_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 5;\n ScopedPadder p(field_size, padinfo_, dest);\n\n fmt_helper::pad2(tm_time.tm_hour, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_min, dest);\n }\n};\n\n// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S\ntemplate \nclass T_formatter final : public flag_formatter {\npublic:\n explicit T_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 8;\n ScopedPadder p(field_size, padinfo_, dest);\n\n fmt_helper::pad2(tm_time.tm_hour, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_min, dest);\n dest.push_back(':');\n fmt_helper::pad2(tm_time.tm_sec, dest);\n }\n};\n\n// ISO 8601 offset from UTC in timezone (+-HH:MM)\n// If SPDLOG_NO_TZ_OFFSET is defined, print \"+??.??\" instead.\ntemplate \nclass z_formatter final : public flag_formatter {\npublic:\n explicit z_formatter(padding_info padinfo, pattern_time_type time_type)\n : flag_formatter(padinfo),\n time_type_(time_type) {}\n\n z_formatter() = default;\n z_formatter(const z_formatter &) = delete;\n z_formatter &operator=(const z_formatter &) = delete;\n\n void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {\n const size_t field_size = 6;\n ScopedPadder p(field_size, padinfo_, dest);\n#ifdef SPDLOG_NO_TZ_OFFSET\n const char *str = \"+??:??\";\n dest.append(str, str + 6);\n#else\n if (time_type_ == pattern_time_type::utc) {\n const char *zeroes = \"+00:00\";\n dest.append(zeroes, zeroes + 6);\n return;\n }\n auto total_minutes = get_cached_offset(msg, tm_time);\n bool is_negative = total_minutes < 0;\n if (is_negative) {\n total_minutes = -total_minutes;\n dest.push_back('-');\n } else {\n dest.push_back('+');\n }\n\n fmt_helper::pad2(total_minutes / 60, dest); // hours\n dest.push_back(':');\n fmt_helper::pad2(total_minutes % 60, dest); // minutes\n#endif // SPDLOG_NO_TZ_OFFSET\n }\n\nprivate:\n pattern_time_type time_type_;\n log_clock::time_point last_update_{std::chrono::seconds(0)};\n int offset_minutes_{0};\n\n int get_cached_offset(const log_msg &msg, const std::tm &tm_time) {\n // refresh every 10 seconds\n if (msg.time - last_update_ >= std::chrono::seconds(10)) {\n offset_minutes_ = os::utc_minutes_offset(tm_time);\n last_update_ = msg.time;\n }\n return offset_minutes_;\n }\n};\n\n// Thread id\ntemplate \nclass t_formatter final : public flag_formatter {\npublic:\n explicit t_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n const auto field_size = ScopedPadder::count_digits(msg.thread_id);\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::append_int(msg.thread_id, dest);\n }\n};\n\n// Current pid\ntemplate \nclass pid_formatter final : public flag_formatter {\npublic:\n explicit pid_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {\n const auto pid = static_cast(details::os::pid());\n auto field_size = ScopedPadder::count_digits(pid);\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::append_int(pid, dest);\n }\n};\n\ntemplate \nclass v_formatter final : public flag_formatter {\npublic:\n explicit v_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n ScopedPadder p(msg.payload.size(), padinfo_, dest);\n fmt_helper::append_string_view(msg.payload, dest);\n }\n};\n\nclass ch_formatter final : public flag_formatter {\npublic:\n explicit ch_formatter(char ch)\n : ch_(ch) {}\n\n void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {\n dest.push_back(ch_);\n }\n\nprivate:\n char ch_;\n};\n\n// aggregate user chars to display as is\nclass aggregate_formatter final : public flag_formatter {\npublic:\n aggregate_formatter() = default;\n\n void add_ch(char ch) { str_ += ch; }\n void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {\n fmt_helper::append_string_view(str_, dest);\n }\n\nprivate:\n std::string str_;\n};\n\n// mark the color range. expect it to be in the form of \"%^colored text%$\"\nclass color_start_formatter final : public flag_formatter {\npublic:\n explicit color_start_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n msg.color_range_start = dest.size();\n }\n};\n\nclass color_stop_formatter final : public flag_formatter {\npublic:\n explicit color_stop_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n msg.color_range_end = dest.size();\n }\n};\n\n// print source location\ntemplate \nclass source_location_formatter final : public flag_formatter {\npublic:\n explicit source_location_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n if (msg.source.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n }\n\n size_t text_size;\n if (padinfo_.enabled()) {\n // calc text size for padding based on \"filename:line\"\n text_size = std::char_traits::length(msg.source.filename) +\n ScopedPadder::count_digits(msg.source.line) + 1;\n } else {\n text_size = 0;\n }\n\n ScopedPadder p(text_size, padinfo_, dest);\n fmt_helper::append_string_view(msg.source.filename, dest);\n dest.push_back(':');\n fmt_helper::append_int(msg.source.line, dest);\n }\n};\n\n// print source filename\ntemplate \nclass source_filename_formatter final : public flag_formatter {\npublic:\n explicit source_filename_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n if (msg.source.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n }\n size_t text_size =\n padinfo_.enabled() ? std::char_traits::length(msg.source.filename) : 0;\n ScopedPadder p(text_size, padinfo_, dest);\n fmt_helper::append_string_view(msg.source.filename, dest);\n }\n};\n\ntemplate \nclass short_filename_formatter final : public flag_formatter {\npublic:\n explicit short_filename_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning(disable : 4127) // consider using 'if constexpr' instead\n#endif // _MSC_VER\n static const char *basename(const char *filename) {\n // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr\n // the branch will be elided by optimizations\n if (sizeof(os::folder_seps) == 2) {\n const char *rv = std::strrchr(filename, os::folder_seps[0]);\n return rv != nullptr ? rv + 1 : filename;\n } else {\n const std::reverse_iterator begin(filename + std::strlen(filename));\n const std::reverse_iterator end(filename);\n\n const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps),\n std::end(os::folder_seps) - 1);\n return it != end ? it.base() : filename;\n }\n }\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif // _MSC_VER\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n if (msg.source.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n }\n auto filename = basename(msg.source.filename);\n size_t text_size = padinfo_.enabled() ? std::char_traits::length(filename) : 0;\n ScopedPadder p(text_size, padinfo_, dest);\n fmt_helper::append_string_view(filename, dest);\n }\n};\n\ntemplate \nclass source_linenum_formatter final : public flag_formatter {\npublic:\n explicit source_linenum_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n if (msg.source.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n }\n\n auto field_size = ScopedPadder::count_digits(msg.source.line);\n ScopedPadder p(field_size, padinfo_, dest);\n fmt_helper::append_int(msg.source.line, dest);\n }\n};\n\n// print source funcname\ntemplate \nclass source_funcname_formatter final : public flag_formatter {\npublic:\n explicit source_funcname_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n if (msg.source.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n }\n size_t text_size =\n padinfo_.enabled() ? std::char_traits::length(msg.source.funcname) : 0;\n ScopedPadder p(text_size, padinfo_, dest);\n fmt_helper::append_string_view(msg.source.funcname, dest);\n }\n};\n\n// print elapsed time since last message\ntemplate \nclass elapsed_formatter final : public flag_formatter {\npublic:\n using DurationUnits = Units;\n\n explicit elapsed_formatter(padding_info padinfo)\n : flag_formatter(padinfo),\n last_message_time_(log_clock::now()) {}\n\n void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {\n auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero());\n auto delta_units = std::chrono::duration_cast(delta);\n last_message_time_ = msg.time;\n auto delta_count = static_cast(delta_units.count());\n auto n_digits = static_cast(ScopedPadder::count_digits(delta_count));\n ScopedPadder p(n_digits, padinfo_, dest);\n fmt_helper::append_int(delta_count, dest);\n }\n\nprivate:\n log_clock::time_point last_message_time_;\n};\n\n// Class for formatting Mapped Diagnostic Context (MDC) in log messages.\n// Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message\n#ifndef SPDLOG_NO_TLS\ntemplate \nclass mdc_formatter : public flag_formatter {\npublic:\n explicit mdc_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {\n const auto &mdc_map = mdc::get_context();\n if (mdc_map.empty()) {\n ScopedPadder p(0, padinfo_, dest);\n return;\n } else {\n format_mdc(mdc_map, dest);\n }\n }\n\n void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) {\n const auto last_element = std::prev(mdc_map.end());\n for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) {\n const auto &key = it->first;\n const auto &value = it->second;\n size_t content_size = key.size() + value.size() + 1; // 1 for ':'\n\n if (it != last_element) {\n content_size++; // 1 for ' '\n }\n\n ScopedPadder p(content_size, padinfo_, dest);\n fmt_helper::append_string_view(key, dest);\n fmt_helper::append_string_view(\":\", dest);\n fmt_helper::append_string_view(value, dest);\n if (it != last_element) {\n fmt_helper::append_string_view(\" \", dest);\n }\n }\n }\n};\n#endif\n\n// Full info formatter\n// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v\nclass full_formatter final : public flag_formatter {\npublic:\n explicit full_formatter(padding_info padinfo)\n : flag_formatter(padinfo) {}\n\n void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {\n using std::chrono::duration_cast;\n using std::chrono::milliseconds;\n using std::chrono::seconds;\n\n // cache the date/time part for the next second.\n auto duration = msg.time.time_since_epoch();\n auto secs = duration_cast(duration);\n\n if (cache_timestamp_ != secs || cached_datetime_.size() == 0) {\n cached_datetime_.clear();\n cached_datetime_.push_back('[');\n fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);\n cached_datetime_.push_back('-');\n\n fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);\n cached_datetime_.push_back('-');\n\n fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);\n cached_datetime_.push_back(' ');\n\n fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);\n cached_datetime_.push_back(':');\n\n fmt_helper::pad2(tm_time.tm_min, cached_datetime_);\n cached_datetime_.push_back(':');\n\n fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);\n cached_datetime_.push_back('.');\n\n cache_timestamp_ = secs;\n }\n dest.append(cached_datetime_.begin(), cached_datetime_.end());\n\n auto millis = fmt_helper::time_fraction(msg.time);\n fmt_helper::pad3(static_cast(millis.count()), dest);\n dest.push_back(']');\n dest.push_back(' ');\n\n // append logger name if exists\n if (msg.logger_name.size() > 0) {\n dest.push_back('[');\n fmt_helper::append_string_view(msg.logger_name, dest);\n dest.push_back(']');\n dest.push_back(' ');\n }\n\n dest.push_back('[');\n // wrap the level name with color\n msg.color_range_start = dest.size();\n // fmt_helper::append_string_view(level::to_c_str(msg.level), dest);\n fmt_helper::append_string_view(level::to_string_view(msg.level), dest);\n msg.color_range_end = dest.size();\n dest.push_back(']');\n dest.push_back(' ');\n\n // add source location if present\n if (!msg.source.empty()) {\n dest.push_back('[');\n const char *filename =\n details::short_filename_formatter::basename(\n msg.source.filename);\n fmt_helper::append_string_view(filename, dest);\n dest.push_back(':');\n fmt_helper::append_int(msg.source.line, dest);\n dest.push_back(']');\n dest.push_back(' ');\n }\n\n#ifndef SPDLOG_NO_TLS\n // add mdc if present\n auto &mdc_map = mdc::get_context();\n if (!mdc_map.empty()) {\n dest.push_back('[');\n mdc_formatter_.format_mdc(mdc_map, dest);\n dest.push_back(']');\n dest.push_back(' ');\n }\n#endif\n // fmt_helper::append_string_view(msg.msg(), dest);\n fmt_helper::append_string_view(msg.payload, dest);\n }\n\nprivate:\n std::chrono::seconds cache_timestamp_{0};\n memory_buf_t cached_datetime_;\n\n#ifndef SPDLOG_NO_TLS\n mdc_formatter mdc_formatter_{padding_info {}};\n#endif\n};\n\n} // namespace details\n\nSPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern,\n pattern_time_type time_type,\n std::string eol,\n custom_flags custom_user_flags)\n : pattern_(std::move(pattern)),\n eol_(std::move(eol)),\n pattern_time_type_(time_type),\n need_localtime_(false),\n last_log_secs_(0),\n custom_handlers_(std::move(custom_user_flags)) {\n std::memset(&cached_tm_, 0, sizeof(cached_tm_));\n compile_pattern_(pattern_);\n}\n\n// use by default full formatter for if pattern is not given\nSPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol)\n : pattern_(\"%+\"),\n eol_(std::move(eol)),\n pattern_time_type_(time_type),\n need_localtime_(true),\n last_log_secs_(0) {\n std::memset(&cached_tm_, 0, sizeof(cached_tm_));\n formatters_.push_back(details::make_unique(details::padding_info{}));\n}\n\nSPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const {\n custom_flags cloned_custom_formatters;\n for (auto &it : custom_handlers_) {\n cloned_custom_formatters[it.first] = it.second->clone();\n }\n auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_,\n std::move(cloned_custom_formatters));\n cloned->need_localtime(need_localtime_);\n#if defined(__GNUC__) && __GNUC__ < 5\n return std::move(cloned);\n#else\n return cloned;\n#endif\n}\n\nSPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) {\n if (need_localtime_) {\n const auto secs =\n std::chrono::duration_cast(msg.time.time_since_epoch());\n if (secs != last_log_secs_) {\n cached_tm_ = get_time_(msg);\n last_log_secs_ = secs;\n }\n }\n\n for (auto &f : formatters_) {\n f->format(msg, cached_tm_, dest);\n }\n // write eol\n details::fmt_helper::append_string_view(eol_, dest);\n}\n\nSPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) {\n pattern_ = std::move(pattern);\n need_localtime_ = false;\n compile_pattern_(pattern_);\n}\n\nSPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; }\n\nSPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) const {\n if (pattern_time_type_ == pattern_time_type::local) {\n return details::os::localtime(log_clock::to_time_t(msg.time));\n }\n return details::os::gmtime(log_clock::to_time_t(msg.time));\n}\n\ntemplate \nSPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) {\n // process custom flags\n auto it = custom_handlers_.find(flag);\n if (it != custom_handlers_.end()) {\n auto custom_handler = it->second->clone();\n custom_handler->set_padding_info(padding);\n formatters_.push_back(std::move(custom_handler));\n return;\n }\n\n // process built-in flags\n switch (flag) {\n case ('+'): // default formatter\n formatters_.push_back(details::make_unique(padding));\n need_localtime_ = true;\n break;\n\n case 'n': // logger name\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case 'l': // level\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case 'L': // short level\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('t'): // thread id\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('v'): // the message text\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('a'): // weekday\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('A'): // short weekday\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('b'):\n case ('h'): // month\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('B'): // short month\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('c'): // datetime\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('C'): // year 2 digits\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('Y'): // year 4 digits\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('D'):\n case ('x'): // datetime MM/DD/YY\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('m'): // month 1-12\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('d'): // day of month 1-31\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('H'): // hours 24\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('I'): // hours 12\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('M'): // minutes\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('S'): // seconds\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('e'): // milliseconds\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('f'): // microseconds\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('F'): // nanoseconds\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('E'): // seconds since epoch\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('p'): // am/pm\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('r'): // 12 hour clock 02:55:02 pm\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('R'): // 24-hour HH:MM time\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n\n case ('T'):\n case ('X'): // ISO 8601 time format (HH:MM:SS)\n formatters_.push_back(details::make_unique>(padding));\n need_localtime_ = true;\n break;\n case ('z'): // timezone\n formatters_.push_back(\n details::make_unique>(padding, pattern_time_type_));\n need_localtime_ = true;\n break;\n case ('P'): // pid\n formatters_.push_back(details::make_unique>(padding));\n break;\n\n case ('^'): // color range start\n formatters_.push_back(details::make_unique(padding));\n break;\n\n case ('$'): // color range end\n formatters_.push_back(details::make_unique(padding));\n break;\n\n case ('@'): // source location (filename:filenumber)\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('s'): // short source filename - without directory name\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('g'): // full source filename\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('#'): // source line number\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('!'): // source funcname\n formatters_.push_back(\n details::make_unique>(padding));\n break;\n\n case ('%'): // % char\n formatters_.push_back(details::make_unique('%'));\n break;\n\n case ('u'): // elapsed time since last log message in nanos\n formatters_.push_back(\n details::make_unique>(\n padding));\n break;\n\n case ('i'): // elapsed time since last log message in micros\n formatters_.push_back(\n details::make_unique>(\n padding));\n break;\n\n case ('o'): // elapsed time since last log message in millis\n formatters_.push_back(\n details::make_unique>(\n padding));\n break;\n\n case ('O'): // elapsed time since last log message in seconds\n formatters_.push_back(\n details::make_unique>(\n padding));\n break;\n\n#ifndef SPDLOG_NO_TLS // mdc formatter requires TLS support\n case ('&'):\n formatters_.push_back(details::make_unique>(padding));\n break;\n#endif\n\n default: // Unknown flag appears as is\n auto unknown_flag = details::make_unique();\n\n if (!padding.truncate_) {\n unknown_flag->add_ch('%');\n unknown_flag->add_ch(flag);\n formatters_.push_back((std::move(unknown_flag)));\n }\n // fix issue #1617 (prev char was '!' and should have been treated as funcname flag\n // instead of truncating flag) spdlog::set_pattern(\"[%10!] %v\") => \"[ main] some\n // message\" spdlog::set_pattern(\"[%3!!] %v\") => \"[mai] some message\"\n else {\n padding.truncate_ = false;\n formatters_.push_back(\n details::make_unique>(padding));\n unknown_flag->add_ch(flag);\n formatters_.push_back((std::move(unknown_flag)));\n }\n\n break;\n }\n}\n\n// Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X)\n// Advance the given it pass the end of the padding spec found (if any)\n// Return padding.\nSPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(\n std::string::const_iterator &it, std::string::const_iterator end) {\n using details::padding_info;\n using details::scoped_padder;\n const size_t max_width = 64;\n if (it == end) {\n return padding_info{};\n }\n\n padding_info::pad_side side;\n switch (*it) {\n case '-':\n side = padding_info::pad_side::right;\n ++it;\n break;\n case '=':\n side = padding_info::pad_side::center;\n ++it;\n break;\n default:\n side = details::padding_info::pad_side::left;\n break;\n }\n\n if (it == end || !std::isdigit(static_cast(*it))) {\n return padding_info{}; // no padding if no digit found here\n }\n\n auto width = static_cast(*it) - '0';\n for (++it; it != end && std::isdigit(static_cast(*it)); ++it) {\n auto digit = static_cast(*it) - '0';\n width = width * 10 + digit;\n }\n\n // search for the optional truncate marker '!'\n bool truncate;\n if (it != end && *it == '!') {\n truncate = true;\n ++it;\n } else {\n truncate = false;\n }\n return details::padding_info{std::min(width, max_width), side, truncate};\n}\n\nSPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) {\n auto end = pattern.end();\n std::unique_ptr user_chars;\n formatters_.clear();\n for (auto it = pattern.begin(); it != end; ++it) {\n if (*it == '%') {\n if (user_chars) // append user chars found so far\n {\n formatters_.push_back(std::move(user_chars));\n }\n\n auto padding = handle_padspec_(++it, end);\n\n if (it != end) {\n if (padding.enabled()) {\n handle_flag_(*it, padding);\n } else {\n handle_flag_(*it, padding);\n }\n } else {\n break;\n }\n } else // chars not following the % sign should be displayed as is\n {\n if (!user_chars) {\n user_chars = details::make_unique();\n }\n user_chars->add_ch(*it);\n }\n }\n if (user_chars) // append raw chars found so far\n {\n formatters_.push_back(std::move(user_chars));\n }\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/pattern_formatter.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace details {\n\n// padding information.\nstruct padding_info {\n enum class pad_side { left, right, center };\n\n padding_info() = default;\n padding_info(size_t width, padding_info::pad_side side, bool truncate)\n : width_(width),\n side_(side),\n truncate_(truncate),\n enabled_(true) {}\n\n bool enabled() const { return enabled_; }\n size_t width_ = 0;\n pad_side side_ = pad_side::left;\n bool truncate_ = false;\n bool enabled_ = false;\n};\n\nclass SPDLOG_API flag_formatter {\npublic:\n explicit flag_formatter(padding_info padinfo)\n : padinfo_(padinfo) {}\n flag_formatter() = default;\n virtual ~flag_formatter() = default;\n virtual void format(const details::log_msg &msg,\n const std::tm &tm_time,\n memory_buf_t &dest) = 0;\n\nprotected:\n padding_info padinfo_;\n};\n\n} // namespace details\n\nclass SPDLOG_API custom_flag_formatter : public details::flag_formatter {\npublic:\n virtual std::unique_ptr clone() const = 0;\n\n void set_padding_info(const details::padding_info &padding) {\n flag_formatter::padinfo_ = padding;\n }\n};\n\nclass SPDLOG_API pattern_formatter final : public formatter {\npublic:\n using custom_flags = std::unordered_map>;\n\n explicit pattern_formatter(std::string pattern,\n pattern_time_type time_type = pattern_time_type::local,\n std::string eol = spdlog::details::os::default_eol,\n custom_flags custom_user_flags = custom_flags());\n\n // use default pattern is not given\n explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local,\n std::string eol = spdlog::details::os::default_eol);\n\n pattern_formatter(const pattern_formatter &other) = delete;\n pattern_formatter &operator=(const pattern_formatter &other) = delete;\n\n std::unique_ptr clone() const override;\n void format(const details::log_msg &msg, memory_buf_t &dest) override;\n\n template \n pattern_formatter &add_flag(char flag, Args &&...args) {\n custom_handlers_[flag] = details::make_unique(std::forward(args)...);\n return *this;\n }\n void set_pattern(std::string pattern);\n void need_localtime(bool need = true);\n\nprivate:\n std::string pattern_;\n std::string eol_;\n pattern_time_type pattern_time_type_;\n bool need_localtime_;\n std::tm cached_tm_;\n std::chrono::seconds last_log_secs_;\n std::vector> formatters_;\n custom_flags custom_handlers_;\n\n std::tm get_time_(const details::log_msg &msg) const;\n template \n void handle_flag_(char flag, details::padding_info padding);\n\n // Extract given pad spec (e.g. %8X)\n // Advance the given it pass the end of the padding spec found (if any)\n // Return padding.\n static details::padding_info handle_padspec_(std::string::const_iterator &it,\n std::string::const_iterator end);\n\n void compile_pattern_(const std::string &pattern);\n};\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"pattern_formatter-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/android_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifdef __ANDROID__\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#if !defined(SPDLOG_ANDROID_RETRIES)\n#define SPDLOG_ANDROID_RETRIES 2\n#endif\n\nnamespace spdlog {\nnamespace sinks {\n\n/*\n * Android sink\n * (logging using __android_log_write or __android_log_buf_write depending on the specified\n * BufferID)\n */\ntemplate \nclass android_sink final : public base_sink {\npublic:\n explicit android_sink(std::string tag = \"spdlog\", bool use_raw_msg = false)\n : tag_(std::move(tag)),\n use_raw_msg_(use_raw_msg) {}\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n const android_LogPriority priority = convert_to_android_(msg.level);\n memory_buf_t formatted;\n if (use_raw_msg_) {\n details::fmt_helper::append_string_view(msg.payload, formatted);\n } else {\n base_sink::formatter_->format(msg, formatted);\n }\n formatted.push_back('\\0');\n const char *msg_output = formatted.data();\n\n // See system/core/liblog/logger_write.c for explanation of return value\n int ret = android_log(priority, tag_.c_str(), msg_output);\n if (ret == -EPERM) {\n return; // !__android_log_is_loggable\n }\n int retry_count = 0;\n while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {\n details::os::sleep_for_millis(5);\n ret = android_log(priority, tag_.c_str(), msg_output);\n retry_count++;\n }\n\n if (ret < 0) {\n throw_spdlog_ex(\"logging to Android failed\", ret);\n }\n }\n\n void flush_() override {}\n\nprivate:\n // There might be liblog versions used, that do not support __android_log_buf_write. So we only\n // compile and link against\n // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,\n // when using the default log buffer, always log via __android_log_write.\n template \n typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log(\n int prio, const char *tag, const char *text) {\n return __android_log_write(prio, tag, text);\n }\n\n template \n typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log(\n int prio, const char *tag, const char *text) {\n return __android_log_buf_write(ID, prio, tag, text);\n }\n\n static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {\n switch (level) {\n case spdlog::level::trace:\n return ANDROID_LOG_VERBOSE;\n case spdlog::level::debug:\n return ANDROID_LOG_DEBUG;\n case spdlog::level::info:\n return ANDROID_LOG_INFO;\n case spdlog::level::warn:\n return ANDROID_LOG_WARN;\n case spdlog::level::err:\n return ANDROID_LOG_ERROR;\n case spdlog::level::critical:\n return ANDROID_LOG_FATAL;\n default:\n return ANDROID_LOG_DEFAULT;\n }\n }\n\n std::string tag_;\n bool use_raw_msg_;\n};\n\nusing android_sink_mt = android_sink;\nusing android_sink_st = android_sink;\n\ntemplate \nusing android_sink_buf_mt = android_sink;\ntemplate \nusing android_sink_buf_st = android_sink;\n\n} // namespace sinks\n\n// Create and register android syslog logger\n\ntemplate \ninline std::shared_ptr android_logger_mt(const std::string &logger_name,\n const std::string &tag = \"spdlog\") {\n return Factory::template create(logger_name, tag);\n}\n\ntemplate \ninline std::shared_ptr android_logger_st(const std::string &logger_name,\n const std::string &tag = \"spdlog\") {\n return Factory::template create(logger_name, tag);\n}\n\n} // namespace spdlog\n\n#endif // __ANDROID__\n" }, { "path": "include/spdlog/sinks/ansicolor_sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nSPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode)\n : target_file_(target_file),\n mutex_(ConsoleMutex::mutex()),\n formatter_(details::make_unique())\n\n{\n set_color_mode_(mode);\n colors_.at(level::trace) = to_string_(white);\n colors_.at(level::debug) = to_string_(cyan);\n colors_.at(level::info) = to_string_(green);\n colors_.at(level::warn) = to_string_(yellow_bold);\n colors_.at(level::err) = to_string_(red_bold);\n colors_.at(level::critical) = to_string_(bold_on_red);\n colors_.at(level::off) = to_string_(reset);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level,\n string_view_t color) {\n std::lock_guard lock(mutex_);\n colors_.at(static_cast(color_level)) = to_string_(color);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) {\n // Wrap the originally formatted message in color codes.\n // If color is not supported in the terminal, log as is instead.\n std::lock_guard lock(mutex_);\n msg.color_range_start = 0;\n msg.color_range_end = 0;\n memory_buf_t formatted;\n formatter_->format(msg, formatted);\n if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {\n // before color range\n print_range_(formatted, 0, msg.color_range_start);\n // in color range\n print_ccode_(colors_.at(static_cast(msg.level)));\n print_range_(formatted, msg.color_range_start, msg.color_range_end);\n print_ccode_(reset);\n // after color range\n print_range_(formatted, msg.color_range_end, formatted.size());\n } else // no color\n {\n print_range_(formatted, 0, formatted.size());\n }\n fflush(target_file_);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::flush() {\n std::lock_guard lock(mutex_);\n fflush(target_file_);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) {\n std::lock_guard lock(mutex_);\n formatter_ = std::unique_ptr(new pattern_formatter(pattern));\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::set_formatter(\n std::unique_ptr sink_formatter) {\n std::lock_guard lock(mutex_);\n formatter_ = std::move(sink_formatter);\n}\n\ntemplate \nSPDLOG_INLINE bool ansicolor_sink::should_color() const {\n return should_do_colors_;\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) {\n std::lock_guard lock(mutex_);\n set_color_mode_(mode);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::set_color_mode_(color_mode mode) {\n switch (mode) {\n case color_mode::always:\n should_do_colors_ = true;\n return;\n case color_mode::automatic:\n should_do_colors_ =\n details::os::in_terminal(target_file_) && details::os::is_color_terminal();\n return;\n case color_mode::never:\n should_do_colors_ = false;\n return;\n default:\n should_do_colors_ = false;\n }\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::print_ccode_(\n const string_view_t &color_code) const {\n details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_);\n}\n\ntemplate \nSPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted,\n size_t start,\n size_t end) const {\n details::os::fwrite_bytes(formatted.data() + start, end - start, target_file_);\n}\n\ntemplate \nSPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) {\n return std::string(sv.data(), sv.size());\n}\n\n// ansicolor_stdout_sink\ntemplate \nSPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode)\n : ansicolor_sink(stdout, mode) {}\n\n// ansicolor_stderr_sink\ntemplate \nSPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode)\n : ansicolor_sink(stderr, mode) {}\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/ansicolor_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\n/**\n * This sink prefixes the output with an ANSI escape sequence color code\n * depending on the severity\n * of the message.\n * If no color terminal detected, omit the escape codes.\n */\n\ntemplate \nclass ansicolor_sink : public sink {\npublic:\n using mutex_t = typename ConsoleMutex::mutex_t;\n ansicolor_sink(FILE *target_file, color_mode mode);\n ~ansicolor_sink() override = default;\n\n ansicolor_sink(const ansicolor_sink &other) = delete;\n ansicolor_sink(ansicolor_sink &&other) = delete;\n\n ansicolor_sink &operator=(const ansicolor_sink &other) = delete;\n ansicolor_sink &operator=(ansicolor_sink &&other) = delete;\n\n void set_color(level::level_enum color_level, string_view_t color);\n void set_color_mode(color_mode mode);\n bool should_color() const;\n\n void log(const details::log_msg &msg) override;\n void flush() override;\n void set_pattern(const std::string &pattern) override;\n void set_formatter(std::unique_ptr sink_formatter) override;\n\n // Formatting codes\n const string_view_t reset = \"\\033[m\";\n const string_view_t bold = \"\\033[1m\";\n const string_view_t dark = \"\\033[2m\";\n const string_view_t underline = \"\\033[4m\";\n const string_view_t blink = \"\\033[5m\";\n const string_view_t reverse = \"\\033[7m\";\n const string_view_t concealed = \"\\033[8m\";\n const string_view_t clear_line = \"\\033[K\";\n\n // Foreground colors\n const string_view_t black = \"\\033[30m\";\n const string_view_t red = \"\\033[31m\";\n const string_view_t green = \"\\033[32m\";\n const string_view_t yellow = \"\\033[33m\";\n const string_view_t blue = \"\\033[34m\";\n const string_view_t magenta = \"\\033[35m\";\n const string_view_t cyan = \"\\033[36m\";\n const string_view_t white = \"\\033[37m\";\n\n /// Background colors\n const string_view_t on_black = \"\\033[40m\";\n const string_view_t on_red = \"\\033[41m\";\n const string_view_t on_green = \"\\033[42m\";\n const string_view_t on_yellow = \"\\033[43m\";\n const string_view_t on_blue = \"\\033[44m\";\n const string_view_t on_magenta = \"\\033[45m\";\n const string_view_t on_cyan = \"\\033[46m\";\n const string_view_t on_white = \"\\033[47m\";\n\n /// Bold colors\n const string_view_t yellow_bold = \"\\033[33m\\033[1m\";\n const string_view_t red_bold = \"\\033[31m\\033[1m\";\n const string_view_t bold_on_red = \"\\033[1m\\033[41m\";\n\nprotected:\n FILE *target_file_;\n\nprivate:\n mutex_t &mutex_;\n bool should_do_colors_;\n std::unique_ptr formatter_;\n std::array colors_;\n void set_color_mode_(color_mode mode);\n void print_ccode_(const string_view_t &color_code) const;\n void print_range_(const memory_buf_t &formatted, size_t start, size_t end) const;\n static std::string to_string_(const string_view_t &sv);\n};\n\ntemplate \nclass ansicolor_stdout_sink : public ansicolor_sink {\npublic:\n explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);\n};\n\ntemplate \nclass ansicolor_stderr_sink : public ansicolor_sink {\npublic:\n explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);\n};\n\nusing ansicolor_stdout_sink_mt = ansicolor_stdout_sink;\nusing ansicolor_stdout_sink_st = ansicolor_stdout_sink;\n\nusing ansicolor_stderr_sink_mt = ansicolor_stderr_sink;\nusing ansicolor_stderr_sink_st = ansicolor_stderr_sink;\n\n} // namespace sinks\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"ansicolor_sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/base_sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n\ntemplate \nSPDLOG_INLINE spdlog::sinks::base_sink::base_sink()\n : formatter_{details::make_unique()} {}\n\ntemplate \nSPDLOG_INLINE spdlog::sinks::base_sink::base_sink(\n std::unique_ptr formatter)\n : formatter_{std::move(formatter)} {}\n\ntemplate \nvoid SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg &msg) {\n std::lock_guard lock(mutex_);\n sink_it_(msg);\n}\n\ntemplate \nvoid SPDLOG_INLINE spdlog::sinks::base_sink::flush() {\n std::lock_guard lock(mutex_);\n flush_();\n}\n\ntemplate \nvoid SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern(const std::string &pattern) {\n std::lock_guard lock(mutex_);\n set_pattern_(pattern);\n}\n\ntemplate \nvoid SPDLOG_INLINE\nspdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) {\n std::lock_guard lock(mutex_);\n set_formatter_(std::move(sink_formatter));\n}\n\ntemplate \nvoid SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) {\n set_formatter_(details::make_unique(pattern));\n}\n\ntemplate \nvoid SPDLOG_INLINE\nspdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) {\n formatter_ = std::move(sink_formatter);\n}\n" }, { "path": "include/spdlog/sinks/base_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n//\n// base sink templated over a mutex (either dummy or real)\n// concrete implementation should override the sink_it_() and flush_() methods.\n// locking is taken care of in this class - no locking needed by the\n// implementers..\n//\n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\ntemplate \nclass SPDLOG_API base_sink : public sink {\npublic:\n base_sink();\n explicit base_sink(std::unique_ptr formatter);\n ~base_sink() override = default;\n\n base_sink(const base_sink &) = delete;\n base_sink(base_sink &&) = delete;\n\n base_sink &operator=(const base_sink &) = delete;\n base_sink &operator=(base_sink &&) = delete;\n\n void log(const details::log_msg &msg) final override;\n void flush() final override;\n void set_pattern(const std::string &pattern) final override;\n void set_formatter(std::unique_ptr sink_formatter) final override;\n\nprotected:\n // sink formatter\n std::unique_ptr formatter_;\n Mutex mutex_;\n\n virtual void sink_it_(const details::log_msg &msg) = 0;\n virtual void flush_() = 0;\n virtual void set_pattern_(const std::string &pattern);\n virtual void set_formatter_(std::unique_ptr sink_formatter);\n};\n} // namespace sinks\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"base_sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/basic_file_sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nSPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename,\n bool truncate,\n const file_event_handlers &event_handlers)\n : file_helper_{event_handlers} {\n file_helper_.open(filename, truncate);\n}\n\ntemplate \nSPDLOG_INLINE const filename_t &basic_file_sink::filename() const {\n return file_helper_.filename();\n}\n\ntemplate \nSPDLOG_INLINE void basic_file_sink::truncate() {\n std::lock_guard lock(base_sink::mutex_);\n file_helper_.reopen(true);\n}\n\ntemplate \nSPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n file_helper_.write(formatted);\n}\n\ntemplate \nSPDLOG_INLINE void basic_file_sink::flush_() {\n file_helper_.flush();\n}\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/basic_file_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n/*\n * Trivial file sink with single file as target\n */\ntemplate \nclass basic_file_sink final : public base_sink {\npublic:\n explicit basic_file_sink(const filename_t &filename,\n bool truncate = false,\n const file_event_handlers &event_handlers = {});\n const filename_t &filename() const;\n void truncate();\n\nprotected:\n void sink_it_(const details::log_msg &msg) override;\n void flush_() override;\n\nprivate:\n details::file_helper file_helper_;\n};\n\nusing basic_file_sink_mt = basic_file_sink;\nusing basic_file_sink_st = basic_file_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \ninline std::shared_ptr basic_logger_mt(const std::string &logger_name,\n const filename_t &filename,\n bool truncate = false,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, truncate,\n event_handlers);\n}\n\ntemplate \ninline std::shared_ptr basic_logger_st(const std::string &logger_name,\n const filename_t &filename,\n bool truncate = false,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, truncate,\n event_handlers);\n}\n\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"basic_file_sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/callback_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n#include \n\nnamespace spdlog {\n\n// callbacks type\ntypedef std::function custom_log_callback;\n\nnamespace sinks {\n/*\n * Trivial callback sink, gets a callback function and calls it on each log\n */\ntemplate \nclass callback_sink final : public base_sink {\npublic:\n explicit callback_sink(const custom_log_callback &callback)\n : callback_{callback} {}\n\nprotected:\n void sink_it_(const details::log_msg &msg) override { callback_(msg); }\n void flush_() override {}\n\nprivate:\n custom_log_callback callback_;\n};\n\nusing callback_sink_mt = callback_sink;\nusing callback_sink_st = callback_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \ninline std::shared_ptr callback_logger_mt(const std::string &logger_name,\n const custom_log_callback &callback) {\n return Factory::template create(logger_name, callback);\n}\n\ntemplate \ninline std::shared_ptr callback_logger_st(const std::string &logger_name,\n const custom_log_callback &callback) {\n return Factory::template create(logger_name, callback);\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/daily_file_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\n/*\n * Generator of daily log file names in format basename.YYYY-MM-DD.ext\n */\nstruct daily_filename_calculator {\n // Create filename for the form basename.YYYY-MM-DD\n static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {\n filename_t basename, ext;\n std::tie(basename, ext) = details::file_helper::split_by_extension(filename);\n return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T(\"{}_{:04d}-{:02d}-{:02d}{}\")),\n basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,\n ext);\n }\n};\n\n/*\n * Generator of daily log file names with strftime format.\n * Usages:\n * auto sink =\n * std::make_shared(\"myapp-%Y-%m-%d:%H:%M:%S.log\", hour,\n * minute);\" auto logger = spdlog::daily_logger_format_mt(\"loggername, \"myapp-%Y-%m-%d:%X.log\",\n * hour, minute)\"\n *\n */\nstruct daily_filename_format_calculator {\n static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) {\n#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)\n std::wstringstream stream;\n#else\n std::stringstream stream;\n#endif\n stream << std::put_time(&now_tm, file_path.c_str());\n return stream.str();\n }\n};\n\n/*\n * Rotating file sink based on date.\n * If truncate != false , the created file will be truncated.\n * If max_files > 0, retain only the last max_files and delete previous.\n * Note that old log files from previous executions will not be deleted by this class,\n * rotation and deletion is only applied while the program is running.\n */\ntemplate \nclass daily_file_sink final : public base_sink {\npublic:\n // create daily file sink which rotates on given time\n daily_file_sink(filename_t base_filename,\n int rotation_hour,\n int rotation_minute,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {})\n : base_filename_(std::move(base_filename)),\n rotation_h_(rotation_hour),\n rotation_m_(rotation_minute),\n file_helper_{event_handlers},\n truncate_(truncate),\n max_files_(max_files),\n filenames_q_() {\n if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||\n rotation_minute > 59) {\n throw_spdlog_ex(\"daily_file_sink: Invalid rotation time in ctor\");\n }\n\n auto now = log_clock::now();\n const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));\n file_helper_.open(new_filename, truncate_);\n rotation_tp_ = next_rotation_tp_();\n\n if (max_files_ > 0) {\n init_filenames_q_();\n }\n }\n\n filename_t filename() {\n std::lock_guard lock(base_sink::mutex_);\n return file_helper_.filename();\n }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n auto time = msg.time;\n bool should_rotate = time >= rotation_tp_;\n if (should_rotate) {\n const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));\n file_helper_.open(new_filename, truncate_);\n rotation_tp_ = next_rotation_tp_();\n }\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n file_helper_.write(formatted);\n\n // Do the cleaning only at the end because it might throw on failure.\n if (should_rotate && max_files_ > 0) {\n delete_old_();\n }\n }\n\n void flush_() override { file_helper_.flush(); }\n\nprivate:\n void init_filenames_q_() {\n using details::os::path_exists;\n\n filenames_q_ = details::circular_q(static_cast(max_files_));\n std::vector filenames;\n auto now = log_clock::now();\n while (filenames.size() < max_files_) {\n const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));\n if (!path_exists(new_filename)) {\n break;\n }\n filenames.emplace_back(new_filename);\n now -= std::chrono::hours(24);\n }\n for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {\n filenames_q_.push_back(std::move(*iter));\n }\n }\n\n tm now_tm(log_clock::time_point tp) {\n time_t tnow = log_clock::to_time_t(tp);\n return spdlog::details::os::localtime(tnow);\n }\n\n log_clock::time_point next_rotation_tp_() {\n auto now = log_clock::now();\n tm date = now_tm(now);\n date.tm_hour = rotation_h_;\n date.tm_min = rotation_m_;\n date.tm_sec = 0;\n auto rotation_time = log_clock::from_time_t(std::mktime(&date));\n if (rotation_time > now) {\n return rotation_time;\n }\n return {rotation_time + std::chrono::hours(24)};\n }\n\n // Delete the file N rotations ago.\n // Throw spdlog_ex on failure to delete the old file.\n void delete_old_() {\n using details::os::filename_to_str;\n using details::os::remove_if_exists;\n\n filename_t current_file = file_helper_.filename();\n if (filenames_q_.full()) {\n auto old_filename = std::move(filenames_q_.front());\n filenames_q_.pop_front();\n bool ok = remove_if_exists(old_filename) == 0;\n if (!ok) {\n filenames_q_.push_back(std::move(current_file));\n throw_spdlog_ex(\"Failed removing daily file \" + filename_to_str(old_filename),\n errno);\n }\n }\n filenames_q_.push_back(std::move(current_file));\n }\n\n filename_t base_filename_;\n int rotation_h_;\n int rotation_m_;\n log_clock::time_point rotation_tp_;\n details::file_helper file_helper_;\n bool truncate_;\n uint16_t max_files_;\n details::circular_q filenames_q_;\n};\n\nusing daily_file_sink_mt = daily_file_sink;\nusing daily_file_sink_st = daily_file_sink;\nusing daily_file_format_sink_mt = daily_file_sink;\nusing daily_file_format_sink_st =\n daily_file_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \ninline std::shared_ptr daily_logger_mt(const std::string &logger_name,\n const filename_t &filename,\n int hour = 0,\n int minute = 0,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, hour, minute,\n truncate, max_files, event_handlers);\n}\n\ntemplate \ninline std::shared_ptr daily_logger_format_mt(\n const std::string &logger_name,\n const filename_t &filename,\n int hour = 0,\n int minute = 0,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(\n logger_name, filename, hour, minute, truncate, max_files, event_handlers);\n}\n\ntemplate \ninline std::shared_ptr daily_logger_st(const std::string &logger_name,\n const filename_t &filename,\n int hour = 0,\n int minute = 0,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, hour, minute,\n truncate, max_files, event_handlers);\n}\n\ntemplate \ninline std::shared_ptr daily_logger_format_st(\n const std::string &logger_name,\n const filename_t &filename,\n int hour = 0,\n int minute = 0,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(\n logger_name, filename, hour, minute, truncate, max_files, event_handlers);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/dist_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \"base_sink.h\"\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n// Distribution sink (mux). Stores a vector of sinks which get called when log\n// is called\n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nclass dist_sink : public base_sink {\npublic:\n dist_sink() = default;\n explicit dist_sink(std::vector> sinks)\n : sinks_(std::move(sinks)) {}\n\n dist_sink(const dist_sink &) = delete;\n dist_sink &operator=(const dist_sink &) = delete;\n\n void add_sink(std::shared_ptr sub_sink) {\n std::lock_guard lock(base_sink::mutex_);\n sinks_.push_back(sub_sink);\n }\n\n void remove_sink(std::shared_ptr sub_sink) {\n std::lock_guard lock(base_sink::mutex_);\n sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end());\n }\n\n void set_sinks(std::vector> sinks) {\n std::lock_guard lock(base_sink::mutex_);\n sinks_ = std::move(sinks);\n }\n\n std::vector> &sinks() { return sinks_; }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n for (auto &sub_sink : sinks_) {\n if (sub_sink->should_log(msg.level)) {\n sub_sink->log(msg);\n }\n }\n }\n\n void flush_() override {\n for (auto &sub_sink : sinks_) {\n sub_sink->flush();\n }\n }\n\n void set_pattern_(const std::string &pattern) override {\n set_formatter_(details::make_unique(pattern));\n }\n\n void set_formatter_(std::unique_ptr sink_formatter) override {\n base_sink::formatter_ = std::move(sink_formatter);\n for (auto &sub_sink : sinks_) {\n sub_sink->set_formatter(base_sink::formatter_->clone());\n }\n }\n std::vector> sinks_;\n};\n\nusing dist_sink_mt = dist_sink;\nusing dist_sink_st = dist_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/dup_filter_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \"dist_sink.h\"\n#include \n#include \n\n#include \n#include \n#include \n#include \n\n// Duplicate message removal sink.\n// Skip the message if previous one is identical and less than \"max_skip_duration\" have passed\n//\n// Example:\n//\n// #include \n//\n// int main() {\n// auto dup_filter = std::make_shared(std::chrono::seconds(5),\n// level::info); dup_filter->add_sink(std::make_shared());\n// spdlog::logger l(\"logger\", dup_filter);\n// l.info(\"Hello\");\n// l.info(\"Hello\");\n// l.info(\"Hello\");\n// l.info(\"Different Hello\");\n// }\n//\n// Will produce:\n// [2019-06-25 17:50:56.511] [logger] [info] Hello\n// [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages..\n// [2019-06-25 17:50:56.512] [logger] [info] Different Hello\n\nnamespace spdlog {\nnamespace sinks {\ntemplate \nclass dup_filter_sink : public dist_sink {\npublic:\n template \n explicit dup_filter_sink(std::chrono::duration max_skip_duration)\n : max_skip_duration_{max_skip_duration} {}\n\n template \n explicit dup_filter_sink(std::chrono::duration max_skip_duration, std::vector> sinks)\n : max_skip_duration_{max_skip_duration}\n , dist_sink(std::move(sinks)) {}\n\nprotected:\n std::chrono::microseconds max_skip_duration_;\n log_clock::time_point last_msg_time_;\n std::string last_msg_payload_;\n size_t skip_counter_ = 0;\n level::level_enum skipped_msg_log_level_ = spdlog::level::level_enum::off;\n\n void sink_it_(const details::log_msg &msg) override {\n bool filtered = filter_(msg);\n if (!filtered) {\n skip_counter_ += 1;\n skipped_msg_log_level_ = msg.level;\n return;\n }\n\n // log the \"skipped..\" message\n if (skip_counter_ > 0) {\n char buf[64];\n auto msg_size = ::snprintf(buf, sizeof(buf), \"Skipped %u duplicate messages..\",\n static_cast(skip_counter_));\n if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) {\n details::log_msg skipped_msg{msg.source, msg.logger_name, skipped_msg_log_level_,\n string_view_t{buf, static_cast(msg_size)}};\n dist_sink::sink_it_(skipped_msg);\n }\n }\n\n // log current message\n dist_sink::sink_it_(msg);\n last_msg_time_ = msg.time;\n skip_counter_ = 0;\n last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());\n }\n\n // return whether the log msg should be displayed (true) or skipped (false)\n bool filter_(const details::log_msg &msg) const {\n const auto filter_duration = msg.time - last_msg_time_;\n return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);\n }\n};\n\nusing dup_filter_sink_mt = dup_filter_sink;\nusing dup_filter_sink_st = dup_filter_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/hourly_file_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\n/*\n * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext\n */\nstruct hourly_filename_calculator {\n // Create filename for the form basename.YYYY-MM-DD-H\n static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {\n filename_t basename, ext;\n std::tie(basename, ext) = details::file_helper::split_by_extension(filename);\n return fmt_lib::format(SPDLOG_FILENAME_T(\"{}_{:04d}-{:02d}-{:02d}_{:02d}{}\"), basename,\n now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,\n now_tm.tm_hour, ext);\n }\n};\n\n/*\n * Rotating file sink based on time.\n * If truncate != false , the created file will be truncated.\n * If max_files > 0, retain only the last max_files and delete previous.\n * Note that old log files from previous executions will not be deleted by this class,\n * rotation and deletion is only applied while the program is running.\n */\ntemplate \nclass hourly_file_sink final : public base_sink {\npublic:\n // create hourly file sink which rotates on given time\n hourly_file_sink(filename_t base_filename,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {})\n : base_filename_(std::move(base_filename)),\n file_helper_{event_handlers},\n truncate_(truncate),\n max_files_(max_files),\n filenames_q_() {\n auto now = log_clock::now();\n auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));\n file_helper_.open(filename, truncate_);\n remove_init_file_ = file_helper_.size() == 0;\n rotation_tp_ = next_rotation_tp_();\n\n if (max_files_ > 0) {\n init_filenames_q_();\n }\n }\n\n filename_t filename() {\n std::lock_guard lock(base_sink::mutex_);\n return file_helper_.filename();\n }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n auto time = msg.time;\n bool should_rotate = time >= rotation_tp_;\n if (should_rotate) {\n if (remove_init_file_) {\n file_helper_.close();\n details::os::remove(file_helper_.filename());\n }\n auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));\n file_helper_.open(filename, truncate_);\n rotation_tp_ = next_rotation_tp_();\n }\n remove_init_file_ = false;\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n file_helper_.write(formatted);\n\n // Do the cleaning only at the end because it might throw on failure.\n if (should_rotate && max_files_ > 0) {\n delete_old_();\n }\n }\n\n void flush_() override { file_helper_.flush(); }\n\nprivate:\n void init_filenames_q_() {\n using details::os::path_exists;\n\n filenames_q_ = details::circular_q(static_cast(max_files_));\n std::vector filenames;\n auto now = log_clock::now();\n while (filenames.size() < max_files_) {\n auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));\n if (!path_exists(filename)) {\n break;\n }\n filenames.emplace_back(filename);\n now -= std::chrono::hours(1);\n }\n for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {\n filenames_q_.push_back(std::move(*iter));\n }\n }\n\n tm now_tm(log_clock::time_point tp) {\n time_t tnow = log_clock::to_time_t(tp);\n return spdlog::details::os::localtime(tnow);\n }\n\n log_clock::time_point next_rotation_tp_() {\n auto now = log_clock::now();\n tm date = now_tm(now);\n date.tm_min = 0;\n date.tm_sec = 0;\n auto rotation_time = log_clock::from_time_t(std::mktime(&date));\n if (rotation_time > now) {\n return rotation_time;\n }\n return {rotation_time + std::chrono::hours(1)};\n }\n\n // Delete the file N rotations ago.\n // Throw spdlog_ex on failure to delete the old file.\n void delete_old_() {\n using details::os::filename_to_str;\n using details::os::remove_if_exists;\n\n filename_t current_file = file_helper_.filename();\n if (filenames_q_.full()) {\n auto old_filename = std::move(filenames_q_.front());\n filenames_q_.pop_front();\n bool ok = remove_if_exists(old_filename) == 0;\n if (!ok) {\n filenames_q_.push_back(std::move(current_file));\n SPDLOG_THROW(spdlog_ex(\n \"Failed removing hourly file \" + filename_to_str(old_filename), errno));\n }\n }\n filenames_q_.push_back(std::move(current_file));\n }\n\n filename_t base_filename_;\n log_clock::time_point rotation_tp_;\n details::file_helper file_helper_;\n bool truncate_;\n uint16_t max_files_;\n details::circular_q filenames_q_;\n bool remove_init_file_;\n};\n\nusing hourly_file_sink_mt = hourly_file_sink;\nusing hourly_file_sink_st = hourly_file_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \ninline std::shared_ptr hourly_logger_mt(const std::string &logger_name,\n const filename_t &filename,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, truncate,\n max_files, event_handlers);\n}\n\ntemplate \ninline std::shared_ptr hourly_logger_st(const std::string &logger_name,\n const filename_t &filename,\n bool truncate = false,\n uint16_t max_files = 0,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(logger_name, filename, truncate,\n max_files, event_handlers);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/kafka_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n//\n// Custom sink for kafka\n// Building and using requires librdkafka library.\n// For building librdkafka library check the url below\n// https://github.com/confluentinc/librdkafka\n//\n\n#include \"spdlog/async.h\"\n#include \"spdlog/details/log_msg.h\"\n#include \"spdlog/details/null_mutex.h\"\n#include \"spdlog/details/synchronous_factory.h\"\n#include \"spdlog/sinks/base_sink.h\"\n#include \n#include \n\n// kafka header\n#include \n\nnamespace spdlog {\nnamespace sinks {\n\nstruct kafka_sink_config {\n std::string server_addr;\n std::string produce_topic;\n int32_t flush_timeout_ms = 1000;\n\n kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)\n : server_addr{std::move(addr)},\n produce_topic{std::move(topic)},\n flush_timeout_ms(flush_timeout_ms) {}\n};\n\ntemplate \nclass kafka_sink : public base_sink {\npublic:\n kafka_sink(kafka_sink_config config)\n : config_{std::move(config)} {\n try {\n std::string errstr;\n conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL));\n RdKafka::Conf::ConfResult confRes =\n conf_->set(\"bootstrap.servers\", config_.server_addr, errstr);\n if (confRes != RdKafka::Conf::CONF_OK) {\n throw_spdlog_ex(\n fmt_lib::format(\"conf set bootstrap.servers failed err:{}\", errstr));\n }\n\n tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC));\n if (tconf_ == nullptr) {\n throw_spdlog_ex(fmt_lib::format(\"create topic config failed\"));\n }\n\n producer_.reset(RdKafka::Producer::create(conf_.get(), errstr));\n if (producer_ == nullptr) {\n throw_spdlog_ex(fmt_lib::format(\"create producer failed err:{}\", errstr));\n }\n topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic,\n tconf_.get(), errstr));\n if (topic_ == nullptr) {\n throw_spdlog_ex(fmt_lib::format(\"create topic failed err:{}\", errstr));\n }\n } catch (const std::exception &e) {\n throw_spdlog_ex(fmt_lib::format(\"error create kafka instance: {}\", e.what()));\n }\n }\n\n ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY,\n (void *)msg.payload.data(), msg.payload.size(), NULL, NULL);\n }\n\n void flush_() override { producer_->flush(config_.flush_timeout_ms); }\n\nprivate:\n kafka_sink_config config_;\n std::unique_ptr producer_ = nullptr;\n std::unique_ptr conf_ = nullptr;\n std::unique_ptr tconf_ = nullptr;\n std::unique_ptr topic_ = nullptr;\n};\n\nusing kafka_sink_mt = kafka_sink;\nusing kafka_sink_st = kafka_sink;\n\n} // namespace sinks\n\ntemplate \ninline std::shared_ptr kafka_logger_mt(const std::string &logger_name,\n spdlog::sinks::kafka_sink_config config) {\n return Factory::template create(logger_name, config);\n}\n\ntemplate \ninline std::shared_ptr kafka_logger_st(const std::string &logger_name,\n spdlog::sinks::kafka_sink_config config) {\n return Factory::template create(logger_name, config);\n}\n\ntemplate \ninline std::shared_ptr kafka_logger_async_mt(\n std::string logger_name, spdlog::sinks::kafka_sink_config config) {\n return Factory::template create(logger_name, config);\n}\n\ntemplate \ninline std::shared_ptr kafka_logger_async_st(\n std::string logger_name, spdlog::sinks::kafka_sink_config config) {\n return Factory::template create(logger_name, config);\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/mongo_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n//\n// Custom sink for mongodb\n// Building and using requires mongocxx library.\n// For building mongocxx library check the url below\n// http://mongocxx.org/mongocxx-v3/installation/\n//\n\n#include \"spdlog/common.h\"\n#include \"spdlog/details/log_msg.h\"\n#include \"spdlog/sinks/base_sink.h\"\n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\ntemplate \nclass mongo_sink : public base_sink {\npublic:\n mongo_sink(const std::string &db_name,\n const std::string &collection_name,\n const std::string &uri = \"mongodb://localhost:27017\") try\n : mongo_sink(std::make_shared(), db_name, collection_name, uri) {\n } catch (const std::exception &e) {\n throw_spdlog_ex(fmt_lib::format(\"Error opening database: {}\", e.what()));\n }\n\n mongo_sink(std::shared_ptr instance,\n const std::string &db_name,\n const std::string &collection_name,\n const std::string &uri = \"mongodb://localhost:27017\")\n : instance_(std::move(instance)),\n db_name_(db_name),\n coll_name_(collection_name) {\n try {\n client_ = spdlog::details::make_unique(mongocxx::uri{uri});\n } catch (const std::exception &e) {\n throw_spdlog_ex(fmt_lib::format(\"Error opening database: {}\", e.what()));\n }\n }\n\n ~mongo_sink() { flush_(); }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n using bsoncxx::builder::stream::document;\n using bsoncxx::builder::stream::finalize;\n\n if (client_ != nullptr) {\n auto doc = document{} << \"timestamp\" << bsoncxx::types::b_date(msg.time) << \"level\"\n << level::to_string_view(msg.level).data() << \"level_num\"\n << msg.level << \"message\"\n << std::string(msg.payload.begin(), msg.payload.end())\n << \"logger_name\"\n << std::string(msg.logger_name.begin(), msg.logger_name.end())\n << \"thread_id\" << static_cast(msg.thread_id) << finalize;\n client_->database(db_name_).collection(coll_name_).insert_one(doc.view());\n }\n }\n\n void flush_() override {}\n\nprivate:\n std::shared_ptr instance_;\n std::string db_name_;\n std::string coll_name_;\n std::unique_ptr client_ = nullptr;\n};\n\n#include \"spdlog/details/null_mutex.h\"\n#include \nusing mongo_sink_mt = mongo_sink;\nusing mongo_sink_st = mongo_sink;\n\n} // namespace sinks\n\ntemplate \ninline std::shared_ptr mongo_logger_mt(\n const std::string &logger_name,\n const std::string &db_name,\n const std::string &collection_name,\n const std::string &uri = \"mongodb://localhost:27017\") {\n return Factory::template create(logger_name, db_name, collection_name,\n uri);\n}\n\ntemplate \ninline std::shared_ptr mongo_logger_st(\n const std::string &logger_name,\n const std::string &db_name,\n const std::string &collection_name,\n const std::string &uri = \"mongodb://localhost:27017\") {\n return Factory::template create(logger_name, db_name, collection_name,\n uri);\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/msvc_sink.h", "content": "// Copyright(c) 2016 Alexander Dalshov & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#if defined(_WIN32)\n\n#include \n#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\n#include \n#endif\n#include \n\n#include \n#include \n\n// Avoid including windows.h (https://stackoverflow.com/a/30741042)\n#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\nextern \"C\" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);\n#else\nextern \"C\" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);\n#endif\nextern \"C\" __declspec(dllimport) int __stdcall IsDebuggerPresent();\n\nnamespace spdlog {\nnamespace sinks {\n/*\n * MSVC sink (logging using OutputDebugStringA)\n */\ntemplate \nclass msvc_sink : public base_sink {\npublic:\n msvc_sink() = default;\n msvc_sink(bool check_debugger_present)\n : check_debugger_present_{check_debugger_present} {}\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n if (check_debugger_present_ && !IsDebuggerPresent()) {\n return;\n }\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n formatted.push_back('\\0'); // add a null terminator for OutputDebugString\n#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)\n wmemory_buf_t wformatted;\n details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);\n OutputDebugStringW(wformatted.data());\n#else\n OutputDebugStringA(formatted.data());\n#endif\n }\n\n void flush_() override {}\n\n bool check_debugger_present_ = true;\n};\n\nusing msvc_sink_mt = msvc_sink;\nusing msvc_sink_st = msvc_sink;\n\nusing windebug_sink_mt = msvc_sink_mt;\nusing windebug_sink_st = msvc_sink_st;\n\n} // namespace sinks\n} // namespace spdlog\n\n#endif\n" }, { "path": "include/spdlog/sinks/null_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nclass null_sink final : public base_sink {\nprotected:\n void sink_it_(const details::log_msg &) override {}\n void flush_() override {}\n};\n\nusing null_sink_mt = null_sink;\nusing null_sink_st = null_sink;\n\n} // namespace sinks\n\ntemplate \ninline std::shared_ptr null_logger_mt(const std::string &logger_name) {\n auto null_logger = Factory::template create(logger_name);\n null_logger->set_level(level::off);\n return null_logger;\n}\n\ntemplate \ninline std::shared_ptr null_logger_st(const std::string &logger_name) {\n auto null_logger = Factory::template create(logger_name);\n null_logger->set_level(level::off);\n return null_logger;\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/ostream_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\ntemplate \nclass ostream_sink final : public base_sink {\npublic:\n explicit ostream_sink(std::ostream &os, bool force_flush = false)\n : ostream_(os),\n force_flush_(force_flush) {}\n ostream_sink(const ostream_sink &) = delete;\n ostream_sink &operator=(const ostream_sink &) = delete;\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n ostream_.write(formatted.data(), static_cast(formatted.size()));\n if (force_flush_) {\n ostream_.flush();\n }\n }\n\n void flush_() override { ostream_.flush(); }\n\n std::ostream &ostream_;\n bool force_flush_;\n};\n\nusing ostream_sink_mt = ostream_sink;\nusing ostream_sink_st = ostream_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/qt_sinks.h", "content": "// Copyright(c) 2015-present, Gabi Melman, mguludag and spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n//\n// Custom sink for QPlainTextEdit or QTextEdit and its children (QTextBrowser...\n// etc) Building and using requires Qt library.\n//\n// Warning: the qt_sink won't be notified if the target widget is destroyed.\n// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent\n// QObject, and then use a standard signal/slot.\n//\n\n#include \"spdlog/common.h\"\n#include \"spdlog/details/log_msg.h\"\n#include \"spdlog/details/synchronous_factory.h\"\n#include \"spdlog/sinks/base_sink.h\"\n#include \n\n#include \n#include \n\n//\n// qt_sink class\n//\nnamespace spdlog {\nnamespace sinks {\ntemplate \nclass qt_sink : public base_sink {\npublic:\n qt_sink(QObject *qt_object, std::string meta_method)\n : qt_object_(qt_object),\n meta_method_(std::move(meta_method)) {\n if (!qt_object_) {\n throw_spdlog_ex(\"qt_sink: qt_object is null\");\n }\n }\n\n ~qt_sink() { flush_(); }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n const string_view_t str = string_view_t(formatted.data(), formatted.size());\n QMetaObject::invokeMethod(\n qt_object_, meta_method_.c_str(), Qt::AutoConnection,\n Q_ARG(QString, QString::fromUtf8(str.data(), static_cast(str.size())).trimmed()));\n }\n\n void flush_() override {}\n\nprivate:\n QObject *qt_object_ = nullptr;\n std::string meta_method_;\n};\n\n// Qt color sink to QTextEdit.\n// Color location is determined by the sink log pattern like in the rest of spdlog sinks.\n// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).\n// max_lines is the maximum number of lines that the sink will hold before removing the oldest\n// lines. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8\n// support is needed.\ntemplate \nclass qt_color_sink : public base_sink {\npublic:\n qt_color_sink(QTextEdit *qt_text_edit,\n int max_lines,\n bool dark_colors = false,\n bool is_utf8 = false)\n : qt_text_edit_(qt_text_edit),\n max_lines_(max_lines),\n is_utf8_(is_utf8) {\n if (!qt_text_edit_) {\n throw_spdlog_ex(\"qt_color_text_sink: text_edit is null\");\n }\n\n default_color_ = qt_text_edit_->currentCharFormat();\n // set colors\n QTextCharFormat format;\n // trace\n format.setForeground(dark_colors ? Qt::darkGray : Qt::gray);\n colors_.at(level::trace) = format;\n // debug\n format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan);\n colors_.at(level::debug) = format;\n // info\n format.setForeground(dark_colors ? Qt::darkGreen : Qt::green);\n colors_.at(level::info) = format;\n // warn\n format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow);\n colors_.at(level::warn) = format;\n // err\n format.setForeground(Qt::red);\n colors_.at(level::err) = format;\n // critical\n format.setForeground(Qt::white);\n format.setBackground(Qt::red);\n colors_.at(level::critical) = format;\n }\n\n ~qt_color_sink() { flush_(); }\n\n void set_default_color(QTextCharFormat format) {\n // std::lock_guard lock(base_sink::mutex_);\n default_color_ = format;\n }\n\n void set_level_color(level::level_enum color_level, QTextCharFormat format) {\n // std::lock_guard lock(base_sink::mutex_);\n colors_.at(static_cast(color_level)) = format;\n }\n\n QTextCharFormat &get_level_color(level::level_enum color_level) {\n std::lock_guard lock(base_sink::mutex_);\n return colors_.at(static_cast(color_level));\n }\n\n QTextCharFormat &get_default_color() {\n std::lock_guard lock(base_sink::mutex_);\n return default_color_;\n }\n\nprotected:\n struct invoke_params {\n invoke_params(int max_lines,\n QTextEdit *q_text_edit,\n QString payload,\n QTextCharFormat default_color,\n QTextCharFormat level_color,\n int color_range_start,\n int color_range_end)\n : max_lines(max_lines),\n q_text_edit(q_text_edit),\n payload(std::move(payload)),\n default_color(default_color),\n level_color(level_color),\n color_range_start(color_range_start),\n color_range_end(color_range_end) {}\n int max_lines;\n QTextEdit *q_text_edit;\n QString payload;\n QTextCharFormat default_color;\n QTextCharFormat level_color;\n int color_range_start;\n int color_range_end;\n };\n\n void sink_it_(const details::log_msg &msg) override {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n\n const string_view_t str = string_view_t(formatted.data(), formatted.size());\n // apply the color to the color range in the formatted message.\n QString payload;\n int color_range_start = static_cast(msg.color_range_start);\n int color_range_end = static_cast(msg.color_range_end);\n if (is_utf8_) {\n payload = QString::fromUtf8(str.data(), static_cast(str.size()));\n // convert color ranges from byte index to character index.\n if (msg.color_range_start < msg.color_range_end) {\n color_range_start =\n QString::fromUtf8(str.data(), static_cast(msg.color_range_start))\n .size();\n color_range_end =\n QString::fromUtf8(str.data(), static_cast(msg.color_range_end))\n .size();\n }\n } else {\n payload = QString::fromLatin1(str.data(), static_cast(str.size()));\n }\n\n invoke_params params{max_lines_, // max lines\n qt_text_edit_, // text edit to append to\n std::move(payload), // text to append\n default_color_, // default color\n colors_.at(static_cast(msg.level)), // color to apply\n color_range_start, // color range start\n color_range_end}; // color range end\n\n QMetaObject::invokeMethod(\n qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);\n }\n\n void flush_() override {}\n\n // Add colored text to the text edit widget. This method is invoked in the GUI thread.\n // It is a static method to ensure that it is handled correctly even if the sink is destroyed\n // prematurely before it is invoked.\n\n static void invoke_method_(invoke_params params) {\n auto *document = params.q_text_edit->document();\n QTextCursor cursor(document);\n\n // remove first blocks if number of blocks exceeds max_lines\n while (document->blockCount() > params.max_lines) {\n cursor.select(QTextCursor::BlockUnderCursor);\n cursor.removeSelectedText();\n cursor.deleteChar(); // delete the newline after the block\n }\n\n cursor.movePosition(QTextCursor::End);\n cursor.setCharFormat(params.default_color);\n\n // if color range not specified or not not valid, just append the text with default color\n if (params.color_range_end <= params.color_range_start) {\n cursor.insertText(params.payload);\n return;\n }\n\n // insert the text before the color range\n cursor.insertText(params.payload.left(params.color_range_start));\n\n // insert the colorized text\n cursor.setCharFormat(params.level_color);\n cursor.insertText(params.payload.mid(params.color_range_start,\n params.color_range_end - params.color_range_start));\n\n // insert the text after the color range with default format\n cursor.setCharFormat(params.default_color);\n cursor.insertText(params.payload.mid(params.color_range_end));\n }\n\n QTextEdit *qt_text_edit_;\n int max_lines_;\n bool is_utf8_;\n QTextCharFormat default_color_;\n std::array colors_;\n};\n\n#include \"spdlog/details/null_mutex.h\"\n#include \n\nusing qt_sink_mt = qt_sink;\nusing qt_sink_st = qt_sink;\nusing qt_color_sink_mt = qt_color_sink;\nusing qt_color_sink_st = qt_color_sink;\n} // namespace sinks\n\n//\n// Factory functions\n//\n\n// log to QTextEdit\ntemplate \ninline std::shared_ptr qt_logger_mt(const std::string &logger_name,\n QTextEdit *qt_object,\n const std::string &meta_method = \"append\") {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n\ntemplate \ninline std::shared_ptr qt_logger_st(const std::string &logger_name,\n QTextEdit *qt_object,\n const std::string &meta_method = \"append\") {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n\n// log to QPlainTextEdit\ntemplate \ninline std::shared_ptr qt_logger_mt(const std::string &logger_name,\n QPlainTextEdit *qt_object,\n const std::string &meta_method = \"appendPlainText\") {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n\ntemplate \ninline std::shared_ptr qt_logger_st(const std::string &logger_name,\n QPlainTextEdit *qt_object,\n const std::string &meta_method = \"appendPlainText\") {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n// log to QObject\ntemplate \ninline std::shared_ptr qt_logger_mt(const std::string &logger_name,\n QObject *qt_object,\n const std::string &meta_method) {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n\ntemplate \ninline std::shared_ptr qt_logger_st(const std::string &logger_name,\n QObject *qt_object,\n const std::string &meta_method) {\n return Factory::template create(logger_name, qt_object, meta_method);\n}\n\n// log to QTextEdit with colorized output\ntemplate \ninline std::shared_ptr qt_color_logger_mt(const std::string &logger_name,\n QTextEdit *qt_text_edit,\n int max_lines,\n bool is_utf8 = false) {\n return Factory::template create(logger_name, qt_text_edit, max_lines,\n false, is_utf8);\n}\n\ntemplate \ninline std::shared_ptr qt_color_logger_st(const std::string &logger_name,\n QTextEdit *qt_text_edit,\n int max_lines,\n bool is_utf8 = false) {\n return Factory::template create(logger_name, qt_text_edit, max_lines,\n false, is_utf8);\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/ringbuffer_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \"spdlog/details/circular_q.h\"\n#include \"spdlog/details/log_msg_buffer.h\"\n#include \"spdlog/details/null_mutex.h\"\n#include \"spdlog/sinks/base_sink.h\"\n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n/*\n * Ring buffer sink\n */\ntemplate \nclass ringbuffer_sink final : public base_sink {\npublic:\n explicit ringbuffer_sink(size_t n_items)\n : q_{n_items} {\n if (n_items == 0) {\n throw_spdlog_ex(\"ringbuffer_sink: n_items cannot be zero\");\n }\n }\n\n std::vector last_raw(size_t lim = 0) {\n std::lock_guard lock(base_sink::mutex_);\n auto items_available = q_.size();\n auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;\n std::vector ret;\n ret.reserve(n_items);\n for (size_t i = (items_available - n_items); i < items_available; i++) {\n ret.push_back(q_.at(i));\n }\n return ret;\n }\n\n std::vector last_formatted(size_t lim = 0) {\n std::lock_guard lock(base_sink::mutex_);\n auto items_available = q_.size();\n auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;\n std::vector ret;\n ret.reserve(n_items);\n for (size_t i = (items_available - n_items); i < items_available; i++) {\n memory_buf_t formatted;\n base_sink::formatter_->format(q_.at(i), formatted);\n ret.push_back(SPDLOG_BUF_TO_STRING(formatted));\n }\n return ret;\n }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n q_.push_back(details::log_msg_buffer{msg});\n }\n void flush_() override {}\n\nprivate:\n details::circular_q q_;\n};\n\nusing ringbuffer_sink_mt = ringbuffer_sink;\nusing ringbuffer_sink_st = ringbuffer_sink;\n\n} // namespace sinks\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/rotating_file_sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nSPDLOG_INLINE rotating_file_sink::rotating_file_sink(\n filename_t base_filename,\n std::size_t max_size,\n std::size_t max_files,\n bool rotate_on_open,\n const file_event_handlers &event_handlers)\n : base_filename_(std::move(base_filename)),\n max_size_(max_size),\n max_files_(max_files),\n file_helper_{event_handlers} {\n if (max_size == 0) {\n throw_spdlog_ex(\"rotating sink constructor: max_size arg cannot be zero\");\n }\n\n if (max_files > MaxFiles) {\n throw_spdlog_ex(\"rotating sink constructor: max_files arg cannot exceed MaxFiles\");\n }\n file_helper_.open(calc_filename(base_filename_, 0));\n current_size_ = file_helper_.size(); // expensive. called only once\n if (rotate_on_open && current_size_ > 0) {\n rotate_();\n current_size_ = 0;\n }\n}\n\n// calc filename according to index and file extension if exists.\n// e.g. calc_filename(\"logs/mylog.txt, 3) => \"logs/mylog.3.txt\".\ntemplate \nSPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename,\n std::size_t index) {\n if (index == 0U) {\n return filename;\n }\n\n filename_t basename;\n filename_t ext;\n std::tie(basename, ext) = details::file_helper::split_by_extension(filename);\n return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T(\"{}.{}{}\")), basename, index, ext);\n}\n\ntemplate \nSPDLOG_INLINE filename_t rotating_file_sink::filename() {\n std::lock_guard lock(base_sink::mutex_);\n return file_helper_.filename();\n}\n\ntemplate \nSPDLOG_INLINE void rotating_file_sink::rotate_now() {\n std::lock_guard lock(base_sink::mutex_);\n rotate_();\n}\ntemplate \nSPDLOG_INLINE void rotating_file_sink::set_max_size(std::size_t max_size) {\n std::lock_guard lock(base_sink::mutex_);\n if (max_size == 0) {\n throw_spdlog_ex(\"rotating sink set_max_size: max_size arg cannot be zero\");\n }\n max_size_ = max_size;\n}\n\ntemplate \nSPDLOG_INLINE std::size_t rotating_file_sink::get_max_size() {\n std::lock_guard lock(base_sink::mutex_);\n return max_size_;\n}\n\ntemplate \nSPDLOG_INLINE void rotating_file_sink::set_max_files(std::size_t max_files) {\n std::lock_guard lock(base_sink::mutex_);\n if (max_files > MaxFiles) {\n throw_spdlog_ex(\"rotating sink set_max_files: max_files arg cannot exceed 200000\");\n }\n max_files_ = max_files;\n}\n\ntemplate \nstd::size_t rotating_file_sink::get_max_files() {\n std::lock_guard lock(base_sink::mutex_);\n return max_files_;\n}\n\ntemplate \nSPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n auto new_size = current_size_ + formatted.size();\n\n // rotate if the new estimated file size exceeds max size.\n // rotate only if the real size > 0 to better deal with full disk (see issue #2261).\n // we only check the real size when new_size > max_size_ because it is relatively expensive.\n if (new_size > max_size_) {\n file_helper_.flush();\n if (file_helper_.size() > 0) {\n rotate_();\n new_size = formatted.size();\n }\n }\n file_helper_.write(formatted);\n current_size_ = new_size;\n}\n\ntemplate \nSPDLOG_INLINE void rotating_file_sink::flush_() {\n file_helper_.flush();\n}\n\n// Rotate files:\n// log.txt -> log.1.txt\n// log.1.txt -> log.2.txt\n// log.2.txt -> log.3.txt\n// log.3.txt -> delete\ntemplate \nSPDLOG_INLINE void rotating_file_sink::rotate_() {\n using details::os::filename_to_str;\n using details::os::path_exists;\n\n file_helper_.close();\n for (auto i = max_files_; i > 0; --i) {\n filename_t src = calc_filename(base_filename_, i - 1);\n if (!path_exists(src)) {\n continue;\n }\n filename_t target = calc_filename(base_filename_, i);\n\n if (!rename_file_(src, target)) {\n // if failed try again after a small delay.\n // this is a workaround to a windows issue, where very high rotation\n // rates can cause the rename to fail with permission denied (because of antivirus?).\n details::os::sleep_for_millis(100);\n if (!rename_file_(src, target)) {\n file_helper_.reopen(\n true); // truncate the log file anyway to prevent it to grow beyond its limit!\n current_size_ = 0;\n throw_spdlog_ex(\"rotating_file_sink: failed renaming \" + filename_to_str(src) +\n \" to \" + filename_to_str(target),\n errno);\n }\n }\n }\n file_helper_.reopen(true);\n}\n\n// delete the target if exists, and rename the src file to target\n// return true on success, false otherwise.\ntemplate \nSPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename,\n const filename_t &target_filename) {\n // try to delete the target file in case it already exists.\n (void)details::os::remove(target_filename);\n return details::os::rename(src_filename, target_filename) == 0;\n}\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/rotating_file_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\n//\n// Rotating file sink based on size\n//\ntemplate \nclass rotating_file_sink final : public base_sink {\npublic:\n static constexpr size_t MaxFiles = 200000;\n rotating_file_sink(filename_t base_filename,\n std::size_t max_size,\n std::size_t max_files,\n bool rotate_on_open = false,\n const file_event_handlers &event_handlers = {});\n static filename_t calc_filename(const filename_t &filename, std::size_t index);\n filename_t filename();\n void rotate_now();\n void set_max_size(std::size_t max_size);\n std::size_t get_max_size();\n void set_max_files(std::size_t max_files);\n std::size_t get_max_files();\n\nprotected:\n void sink_it_(const details::log_msg &msg) override;\n void flush_() override;\n\nprivate:\n // Rotate files:\n // log.txt -> log.1.txt\n // log.1.txt -> log.2.txt\n // log.2.txt -> log.3.txt\n // log.3.txt -> delete\n void rotate_();\n\n // delete the target if exists, and rename the src file to target\n // return true on success, false otherwise.\n bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);\n\n filename_t base_filename_;\n std::size_t max_size_;\n std::size_t max_files_;\n std::size_t current_size_;\n details::file_helper file_helper_;\n};\n\nusing rotating_file_sink_mt = rotating_file_sink;\nusing rotating_file_sink_st = rotating_file_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \nstd::shared_ptr rotating_logger_mt(const std::string &logger_name,\n const filename_t &filename,\n size_t max_file_size,\n size_t max_files,\n bool rotate_on_open = false,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(\n logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);\n}\n\ntemplate \nstd::shared_ptr rotating_logger_st(const std::string &logger_name,\n const filename_t &filename,\n size_t max_file_size,\n size_t max_files,\n bool rotate_on_open = false,\n const file_event_handlers &event_handlers = {}) {\n return Factory::template create(\n logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);\n}\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"rotating_file_sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n\nSPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const {\n return msg_level >= level_.load(std::memory_order_relaxed);\n}\n\nSPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) {\n level_.store(log_level, std::memory_order_relaxed);\n}\n\nSPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const {\n return static_cast(level_.load(std::memory_order_relaxed));\n}\n" }, { "path": "include/spdlog/sinks/sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\nnamespace spdlog {\n\nnamespace sinks {\nclass SPDLOG_API sink {\npublic:\n virtual ~sink() = default;\n virtual void log(const details::log_msg &msg) = 0;\n virtual void flush() = 0;\n virtual void set_pattern(const std::string &pattern) = 0;\n virtual void set_formatter(std::unique_ptr sink_formatter) = 0;\n\n void set_level(level::level_enum log_level);\n level::level_enum level() const;\n bool should_log(level::level_enum msg_level) const;\n\nprotected:\n // sink log level - default is all\n level_t level_{level::trace};\n};\n\n} // namespace sinks\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/stdout_color_sinks-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\nnamespace spdlog {\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name,\n color_mode mode) {\n return Factory::template create(logger_name, mode);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name,\n color_mode mode) {\n return Factory::template create(logger_name, mode);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name,\n color_mode mode) {\n return Factory::template create(logger_name, mode);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name,\n color_mode mode) {\n return Factory::template create(logger_name, mode);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/stdout_color_sinks.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n\n#include \n\nnamespace spdlog {\nnamespace sinks {\n#ifdef _WIN32\nusing stdout_color_sink_mt = wincolor_stdout_sink_mt;\nusing stdout_color_sink_st = wincolor_stdout_sink_st;\nusing stderr_color_sink_mt = wincolor_stderr_sink_mt;\nusing stderr_color_sink_st = wincolor_stderr_sink_st;\n#else\nusing stdout_color_sink_mt = ansicolor_stdout_sink_mt;\nusing stdout_color_sink_st = ansicolor_stdout_sink_st;\nusing stderr_color_sink_mt = ansicolor_stderr_sink_mt;\nusing stderr_color_sink_st = ansicolor_stderr_sink_st;\n#endif\n} // namespace sinks\n\ntemplate \nstd::shared_ptr stdout_color_mt(const std::string &logger_name,\n color_mode mode = color_mode::automatic);\n\ntemplate \nstd::shared_ptr stdout_color_st(const std::string &logger_name,\n color_mode mode = color_mode::automatic);\n\ntemplate \nstd::shared_ptr stderr_color_mt(const std::string &logger_name,\n color_mode mode = color_mode::automatic);\n\ntemplate \nstd::shared_ptr stderr_color_st(const std::string &logger_name,\n color_mode mode = color_mode::automatic);\n\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"stdout_color_sinks-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/stdout_sinks-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n#include \n#include \n\n#ifdef _WIN32\n// under windows using fwrite to non-binary stream results in \\r\\r\\n (see issue #1675)\n// so instead we use ::FileWrite\n#include \n\n#ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp\n#include // WriteFile (..)\n#endif\n\n#include // _get_osfhandle(..)\n#include // _fileno(..)\n#endif // _WIN32\n\nnamespace spdlog {\n\nnamespace sinks {\n\ntemplate \nSPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file)\n : mutex_(ConsoleMutex::mutex()),\n file_(file),\n formatter_(details::make_unique()) {\n#ifdef _WIN32\n // get windows handle from the FILE* object\n\n handle_ = reinterpret_cast(::_get_osfhandle(::_fileno(file_)));\n\n // don't throw to support cases where no console is attached,\n // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE).\n // throw only if non stdout/stderr target is requested (probably regular file and not console).\n if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {\n throw_spdlog_ex(\"spdlog::stdout_sink_base: _get_osfhandle() failed\", errno);\n }\n#endif // _WIN32\n}\n\ntemplate \nSPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) {\n#ifdef _WIN32\n if (handle_ == INVALID_HANDLE_VALUE) {\n return;\n }\n std::lock_guard lock(mutex_);\n memory_buf_t formatted;\n formatter_->format(msg, formatted);\n auto size = static_cast(formatted.size());\n DWORD bytes_written = 0;\n bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;\n if (!ok) {\n throw_spdlog_ex(\"stdout_sink_base: WriteFile() failed. GetLastError(): \" +\n std::to_string(::GetLastError()));\n }\n#else\n std::lock_guard lock(mutex_);\n memory_buf_t formatted;\n formatter_->format(msg, formatted);\n details::os::fwrite_bytes(formatted.data(), formatted.size(), file_);\n#endif // _WIN32\n ::fflush(file_); // flush every line to terminal\n}\n\ntemplate \nSPDLOG_INLINE void stdout_sink_base::flush() {\n std::lock_guard lock(mutex_);\n fflush(file_);\n}\n\ntemplate \nSPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) {\n std::lock_guard lock(mutex_);\n formatter_ = std::unique_ptr(new pattern_formatter(pattern));\n}\n\ntemplate \nSPDLOG_INLINE void stdout_sink_base::set_formatter(\n std::unique_ptr sink_formatter) {\n std::lock_guard lock(mutex_);\n formatter_ = std::move(sink_formatter);\n}\n\n// stdout sink\ntemplate \nSPDLOG_INLINE stdout_sink::stdout_sink()\n : stdout_sink_base(stdout) {}\n\n// stderr sink\ntemplate \nSPDLOG_INLINE stderr_sink::stderr_sink()\n : stdout_sink_base(stderr) {}\n\n} // namespace sinks\n\n// factory methods\ntemplate \nSPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) {\n return Factory::template create(logger_name);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) {\n return Factory::template create(logger_name);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) {\n return Factory::template create(logger_name);\n}\n\ntemplate \nSPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) {\n return Factory::template create(logger_name);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/stdout_sinks.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#ifdef _WIN32\n#include \n#endif\n\nnamespace spdlog {\n\nnamespace sinks {\n\ntemplate \nclass stdout_sink_base : public sink {\npublic:\n using mutex_t = typename ConsoleMutex::mutex_t;\n explicit stdout_sink_base(FILE *file);\n ~stdout_sink_base() override = default;\n\n stdout_sink_base(const stdout_sink_base &other) = delete;\n stdout_sink_base(stdout_sink_base &&other) = delete;\n\n stdout_sink_base &operator=(const stdout_sink_base &other) = delete;\n stdout_sink_base &operator=(stdout_sink_base &&other) = delete;\n\n void log(const details::log_msg &msg) override;\n void flush() override;\n void set_pattern(const std::string &pattern) override;\n\n void set_formatter(std::unique_ptr sink_formatter) override;\n\nprotected:\n mutex_t &mutex_;\n FILE *file_;\n std::unique_ptr formatter_;\n#ifdef _WIN32\n HANDLE handle_;\n#endif // WIN32\n};\n\ntemplate \nclass stdout_sink : public stdout_sink_base {\npublic:\n stdout_sink();\n};\n\ntemplate \nclass stderr_sink : public stdout_sink_base {\npublic:\n stderr_sink();\n};\n\nusing stdout_sink_mt = stdout_sink;\nusing stdout_sink_st = stdout_sink;\n\nusing stderr_sink_mt = stderr_sink;\nusing stderr_sink_st = stderr_sink;\n\n} // namespace sinks\n\n// factory methods\ntemplate \nstd::shared_ptr stdout_logger_mt(const std::string &logger_name);\n\ntemplate \nstd::shared_ptr stdout_logger_st(const std::string &logger_name);\n\ntemplate \nstd::shared_ptr stderr_logger_mt(const std::string &logger_name);\n\ntemplate \nstd::shared_ptr stderr_logger_st(const std::string &logger_name);\n\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"stdout_sinks-inl.h\"\n#endif\n" }, { "path": "include/spdlog/sinks/syslog_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n/**\n * Sink that write to syslog using the `syscall()` library call.\n */\ntemplate \nclass syslog_sink : public base_sink {\npublic:\n syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)\n : enable_formatting_{enable_formatting},\n syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,\n /* spdlog::level::debug */ LOG_DEBUG,\n /* spdlog::level::info */ LOG_INFO,\n /* spdlog::level::warn */ LOG_WARNING,\n /* spdlog::level::err */ LOG_ERR,\n /* spdlog::level::critical */ LOG_CRIT,\n /* spdlog::level::off */ LOG_INFO}},\n ident_{std::move(ident)} {\n // set ident to be program name if empty\n ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);\n }\n\n ~syslog_sink() override { ::closelog(); }\n\n syslog_sink(const syslog_sink &) = delete;\n syslog_sink &operator=(const syslog_sink &) = delete;\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n string_view_t payload;\n memory_buf_t formatted;\n if (enable_formatting_) {\n base_sink::formatter_->format(msg, formatted);\n payload = string_view_t(formatted.data(), formatted.size());\n } else {\n payload = msg.payload;\n }\n\n size_t length = payload.size();\n // limit to max int\n if (length > static_cast(std::numeric_limits::max())) {\n length = static_cast(std::numeric_limits::max());\n }\n\n ::syslog(syslog_prio_from_level(msg), \"%.*s\", static_cast(length), payload.data());\n }\n\n void flush_() override {}\n bool enable_formatting_ = false;\n\n //\n // Simply maps spdlog's log level to syslog priority level.\n //\n virtual int syslog_prio_from_level(const details::log_msg &msg) const {\n return syslog_levels_.at(static_cast(msg.level));\n }\n\n using levels_array = std::array;\n levels_array syslog_levels_;\n\nprivate:\n // must store the ident because the man says openlog might use the pointer as\n // is and not a string copy\n const std::string ident_;\n};\n\nusing syslog_sink_mt = syslog_sink;\nusing syslog_sink_st = syslog_sink;\n} // namespace sinks\n\n// Create and register a syslog logger\ntemplate \ninline std::shared_ptr syslog_logger_mt(const std::string &logger_name,\n const std::string &syslog_ident = \"\",\n int syslog_option = 0,\n int syslog_facility = LOG_USER,\n bool enable_formatting = false) {\n return Factory::template create(logger_name, syslog_ident, syslog_option,\n syslog_facility, enable_formatting);\n}\n\ntemplate \ninline std::shared_ptr syslog_logger_st(const std::string &logger_name,\n const std::string &syslog_ident = \"\",\n int syslog_option = 0,\n int syslog_facility = LOG_USER,\n bool enable_formatting = false) {\n return Factory::template create(logger_name, syslog_ident, syslog_option,\n syslog_facility, enable_formatting);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/systemd_sink.h", "content": "// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n#ifndef SD_JOURNAL_SUPPRESS_LOCATION\n#define SD_JOURNAL_SUPPRESS_LOCATION\n#endif\n#include \n\nnamespace spdlog {\nnamespace sinks {\n\n/**\n * Sink that write to systemd journal using the `sd_journal_send()` library call.\n */\ntemplate \nclass systemd_sink : public base_sink {\npublic:\n systemd_sink(std::string ident = \"\", bool enable_formatting = false)\n : ident_{std::move(ident)},\n enable_formatting_{enable_formatting},\n syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,\n /* spdlog::level::debug */ LOG_DEBUG,\n /* spdlog::level::info */ LOG_INFO,\n /* spdlog::level::warn */ LOG_WARNING,\n /* spdlog::level::err */ LOG_ERR,\n /* spdlog::level::critical */ LOG_CRIT,\n /* spdlog::level::off */ LOG_INFO}} {}\n\n ~systemd_sink() override {}\n\n systemd_sink(const systemd_sink &) = delete;\n systemd_sink &operator=(const systemd_sink &) = delete;\n\nprotected:\n const std::string ident_;\n bool enable_formatting_ = false;\n using levels_array = std::array;\n levels_array syslog_levels_;\n\n void sink_it_(const details::log_msg &msg) override {\n int err;\n string_view_t payload;\n memory_buf_t formatted;\n if (enable_formatting_) {\n base_sink::formatter_->format(msg, formatted);\n payload = string_view_t(formatted.data(), formatted.size());\n } else {\n payload = msg.payload;\n }\n\n size_t length = payload.size();\n // limit to max int\n if (length > static_cast(std::numeric_limits::max())) {\n length = static_cast(std::numeric_limits::max());\n }\n\n const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_;\n\n // Do not send source location if not available\n if (msg.source.empty()) {\n // Note: function call inside '()' to avoid macro expansion\n err = (sd_journal_send)(\"MESSAGE=%.*s\", static_cast(length), payload.data(),\n \"PRIORITY=%d\", syslog_level(msg.level),\n#ifndef SPDLOG_NO_THREAD_ID\n \"TID=%zu\", msg.thread_id,\n#endif\n \"SYSLOG_IDENTIFIER=%.*s\",\n static_cast(syslog_identifier.size()),\n syslog_identifier.data(), nullptr);\n } else {\n err = (sd_journal_send)(\"MESSAGE=%.*s\", static_cast(length), payload.data(),\n \"PRIORITY=%d\", syslog_level(msg.level),\n#ifndef SPDLOG_NO_THREAD_ID\n \"TID=%zu\", msg.thread_id,\n#endif\n \"SYSLOG_IDENTIFIER=%.*s\",\n static_cast(syslog_identifier.size()),\n syslog_identifier.data(), \"CODE_FILE=%s\", msg.source.filename,\n \"CODE_LINE=%d\", msg.source.line, \"CODE_FUNC=%s\",\n msg.source.funcname, nullptr);\n }\n\n if (err) {\n throw_spdlog_ex(\"Failed writing to systemd\", errno);\n }\n }\n\n int syslog_level(level::level_enum l) {\n return syslog_levels_.at(static_cast(l));\n }\n\n void flush_() override {}\n};\n\nusing systemd_sink_mt = systemd_sink;\nusing systemd_sink_st = systemd_sink;\n} // namespace sinks\n\n// Create and register a syslog logger\ntemplate \ninline std::shared_ptr systemd_logger_mt(const std::string &logger_name,\n const std::string &ident = \"\",\n bool enable_formatting = false) {\n return Factory::template create(logger_name, ident, enable_formatting);\n}\n\ntemplate \ninline std::shared_ptr systemd_logger_st(const std::string &logger_name,\n const std::string &ident = \"\",\n bool enable_formatting = false) {\n return Factory::template create(logger_name, ident, enable_formatting);\n}\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/tcp_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n\n#include \n#include \n#include \n#include \n\n#pragma once\n\n// Simple tcp client sink\n// Connects to remote address and send the formatted log.\n// Will attempt to reconnect if connection drops.\n// If more complicated behaviour is needed (i.e get responses), you can inherit it and override the\n// sink_it_ method.\n\nnamespace spdlog {\nnamespace sinks {\n\nstruct tcp_sink_config {\n std::string server_host;\n int server_port;\n int timeout_ms =\n 0; // The timeout for all 3 major socket operations that is connect, send, and recv\n bool lazy_connect = false; // if true connect on first log call instead of on construction\n\n tcp_sink_config(std::string host, int port)\n : server_host{std::move(host)},\n server_port{port} {}\n};\n\ntemplate \nclass tcp_sink : public spdlog::sinks::base_sink {\npublic:\n // connect to tcp host/port or throw if failed\n // host can be hostname or ip address\n\n explicit tcp_sink(const std::string &host,\n int port,\n int timeout_ms = 0,\n bool lazy_connect = false)\n : config_{host, port} {\n config_.timeout_ms = timeout_ms;\n config_.lazy_connect = lazy_connect;\n if (!config_.lazy_connect) {\n client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);\n }\n }\n\n explicit tcp_sink(tcp_sink_config sink_config)\n : config_{std::move(sink_config)} {\n if (!config_.lazy_connect) {\n client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);\n }\n }\n\n ~tcp_sink() override = default;\n\nprotected:\n void sink_it_(const spdlog::details::log_msg &msg) override {\n spdlog::memory_buf_t formatted;\n spdlog::sinks::base_sink::formatter_->format(msg, formatted);\n if (!client_.is_connected()) {\n client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);\n }\n client_.send(formatted.data(), formatted.size());\n }\n\n void flush_() override {}\n tcp_sink_config config_;\n details::tcp_client client_;\n};\n\nusing tcp_sink_mt = tcp_sink;\nusing tcp_sink_st = tcp_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/udp_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#ifdef _WIN32\n#include \n#else\n#include \n#endif\n\n#include \n#include \n#include \n#include \n\n// Simple udp client sink\n// Sends formatted log via udp\n\nnamespace spdlog {\nnamespace sinks {\n\nstruct udp_sink_config {\n std::string server_host;\n uint16_t server_port;\n\n udp_sink_config(std::string host, uint16_t port)\n : server_host{std::move(host)},\n server_port{port} {}\n};\n\ntemplate \nclass udp_sink : public spdlog::sinks::base_sink {\npublic:\n // host can be hostname or ip address\n explicit udp_sink(const udp_sink_config& sink_config)\n : client_{sink_config.server_host, sink_config.server_port} {}\n\n ~udp_sink() override = default;\n\nprotected:\n void sink_it_(const spdlog::details::log_msg &msg) override {\n spdlog::memory_buf_t formatted;\n spdlog::sinks::base_sink::formatter_->format(msg, formatted);\n client_.send(formatted.data(), formatted.size());\n }\n\n void flush_() override {}\n details::udp_client client_;\n};\n\nusing udp_sink_mt = udp_sink;\nusing udp_sink_st = udp_sink;\n\n} // namespace sinks\n\n//\n// factory functions\n//\ntemplate \ninline std::shared_ptr udp_logger_mt(const std::string &logger_name,\n sinks::udp_sink_config skin_config) {\n return Factory::template create(logger_name, skin_config);\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/win_eventlog_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n// Writing to Windows Event Log requires the registry entries below to be present, with the\n// following modifications:\n// 1. should be replaced with your log name (e.g. your application name)\n// 2. should be replaced with the specific source name and the key should be\n// duplicated for\n// each source used in the application\n//\n// Since typically modifications of this kind require elevation, it's better to do it as a part of\n// setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of\n// the Windows systems anyway and happens to contain the needed resource.\n//\n// You can also specify a custom message file if needed.\n// Please refer to Event Log functions descriptions in MSDN for more details on custom message\n// files.\n\n/*---------------------------------------------------------------------------------------\n\nWindows Registry Editor Version 5.00\n\n[HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\EventLog\\]\n\n[HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\EventLog\\\\]\n\"TypesSupported\"=dword:00000007\n\"EventMessageFile\"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,\\\n 00,6f,00,74,00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,\\\n 5c,00,6d,00,73,00,63,00,6f,00,72,00,65,00,65,00,2e,00,64,00,6c,00,6c,00,00,\\\n 00\n\n-----------------------------------------------------------------------------------------*/\n\n#pragma once\n\n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\nnamespace win_eventlog {\n\nnamespace internal {\n\nstruct local_alloc_t {\n HLOCAL hlocal_;\n\n SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {}\n\n local_alloc_t(local_alloc_t const &) = delete;\n local_alloc_t &operator=(local_alloc_t const &) = delete;\n\n ~local_alloc_t() SPDLOG_NOEXCEPT {\n if (hlocal_) {\n LocalFree(hlocal_);\n }\n }\n};\n\n/** Windows error */\nstruct win32_error : public spdlog_ex {\n /** Formats an error report line: \"user-message: error-code (system message)\" */\n static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) {\n std::string system_message;\n\n local_alloc_t format_message_result{};\n auto format_message_succeeded =\n ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |\n FORMAT_MESSAGE_IGNORE_INSERTS,\n nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\n (LPSTR)&format_message_result.hlocal_, 0, nullptr);\n\n if (format_message_succeeded && format_message_result.hlocal_) {\n system_message = fmt_lib::format(\" ({})\", (LPSTR)format_message_result.hlocal_);\n }\n\n return fmt_lib::format(\"{}: {}{}\", user_message, error_code, system_message);\n }\n\n explicit win32_error(std::string const &func_name, DWORD error = GetLastError())\n : spdlog_ex(format(func_name, error)) {}\n};\n\n/** Wrapper for security identifiers (SID) on Windows */\nstruct sid_t {\n std::vector buffer_;\n\npublic:\n sid_t() {}\n\n /** creates a wrapped SID copy */\n static sid_t duplicate_sid(PSID psid) {\n if (!::IsValidSid(psid)) {\n throw_spdlog_ex(\"sid_t::sid_t(): invalid SID received\");\n }\n\n auto const sid_length{::GetLengthSid(psid)};\n\n sid_t result;\n result.buffer_.resize(sid_length);\n if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) {\n SPDLOG_THROW(win32_error(\"CopySid\"));\n }\n\n return result;\n }\n\n /** Retrieves pointer to the internal buffer contents as SID* */\n SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); }\n\n /** Get SID for the current user */\n static sid_t get_current_user_sid() {\n /* create and init RAII holder for process token */\n struct process_token_t {\n HANDLE token_handle_ = INVALID_HANDLE_VALUE;\n explicit process_token_t(HANDLE process) {\n if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) {\n SPDLOG_THROW(win32_error(\"OpenProcessToken\"));\n }\n }\n\n ~process_token_t() { ::CloseHandle(token_handle_); }\n\n } current_process_token(\n ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here!\n\n // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return\n // the token size\n DWORD tusize = 0;\n if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0,\n &tusize)) {\n SPDLOG_THROW(win32_error(\"GetTokenInformation should fail\"));\n }\n\n // get user token\n std::vector buffer(static_cast(tusize));\n if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser,\n (LPVOID)buffer.data(), tusize, &tusize)) {\n SPDLOG_THROW(win32_error(\"GetTokenInformation\"));\n }\n\n // create a wrapper of the SID data as stored in the user token\n return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid);\n }\n};\n\nstruct eventlog {\n static WORD get_event_type(details::log_msg const &msg) {\n switch (msg.level) {\n case level::trace:\n case level::debug:\n return EVENTLOG_SUCCESS;\n\n case level::info:\n return EVENTLOG_INFORMATION_TYPE;\n\n case level::warn:\n return EVENTLOG_WARNING_TYPE;\n\n case level::err:\n case level::critical:\n case level::off:\n return EVENTLOG_ERROR_TYPE;\n\n default:\n return EVENTLOG_INFORMATION_TYPE;\n }\n }\n\n static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; }\n};\n\n} // namespace internal\n\n/*\n * Windows Event Log sink\n */\ntemplate \nclass win_eventlog_sink : public base_sink {\nprivate:\n HANDLE hEventLog_{NULL};\n internal::sid_t current_user_sid_;\n std::string source_;\n DWORD event_id_;\n\n HANDLE event_log_handle() {\n if (!hEventLog_) {\n hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str());\n if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) {\n SPDLOG_THROW(internal::win32_error(\"RegisterEventSource\"));\n }\n }\n\n return hEventLog_;\n }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n using namespace internal;\n\n bool succeeded;\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n formatted.push_back('\\0');\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\n wmemory_buf_t buf;\n details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);\n\n LPCWSTR lp_wstr = buf.data();\n succeeded = static_cast(::ReportEventW(\n event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),\n event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));\n#else\n LPCSTR lp_str = formatted.data();\n succeeded = static_cast(::ReportEventA(\n event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),\n event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));\n#endif\n\n if (!succeeded) {\n SPDLOG_THROW(win32_error(\"ReportEvent\"));\n }\n }\n\n void flush_() override {}\n\npublic:\n win_eventlog_sink(std::string const &source,\n DWORD event_id = 1000 /* according to mscoree.dll */)\n : source_(source),\n event_id_(event_id) {\n try {\n current_user_sid_ = internal::sid_t::get_current_user_sid();\n } catch (...) {\n // get_current_user_sid() is unlikely to fail and if it does, we can still proceed\n // without current_user_sid but in the event log the record will have no user name\n }\n }\n\n ~win_eventlog_sink() {\n if (hEventLog_) DeregisterEventSource(hEventLog_);\n }\n};\n\n} // namespace win_eventlog\n\nusing win_eventlog_sink_mt = win_eventlog::win_eventlog_sink;\nusing win_eventlog_sink_st = win_eventlog::win_eventlog_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/wincolor_sink-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\ntemplate \nSPDLOG_INLINE wincolor_sink::wincolor_sink(void *out_handle, color_mode mode)\n : out_handle_(out_handle),\n mutex_(ConsoleMutex::mutex()),\n formatter_(details::make_unique()) {\n set_color_mode_impl(mode);\n // set level colors\n colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white\n colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan\n colors_[level::info] = FOREGROUND_GREEN; // green\n colors_[level::warn] =\n FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow\n colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red\n colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN |\n FOREGROUND_BLUE |\n FOREGROUND_INTENSITY; // intense white on red background\n colors_[level::off] = 0;\n}\n\ntemplate \nSPDLOG_INLINE wincolor_sink::~wincolor_sink() {\n this->flush();\n}\n\n// change the color for the given level\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level,\n std::uint16_t color) {\n std::lock_guard lock(mutex_);\n colors_[static_cast(level)] = color;\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) {\n if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) {\n return;\n }\n\n std::lock_guard lock(mutex_);\n msg.color_range_start = 0;\n msg.color_range_end = 0;\n memory_buf_t formatted;\n formatter_->format(msg, formatted);\n if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {\n // before color range\n print_range_(formatted, 0, msg.color_range_start);\n // in color range\n auto orig_attribs =\n static_cast(set_foreground_color_(colors_[static_cast(msg.level)]));\n print_range_(formatted, msg.color_range_start, msg.color_range_end);\n // reset to orig colors\n ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs);\n print_range_(formatted, msg.color_range_end, formatted.size());\n } else // print without colors if color range is invalid (or color is disabled)\n {\n write_to_file_(formatted);\n }\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::flush() {\n // windows console always flushed?\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) {\n std::lock_guard lock(mutex_);\n formatter_ = std::unique_ptr(new pattern_formatter(pattern));\n}\n\ntemplate \nvoid SPDLOG_INLINE\nwincolor_sink::set_formatter(std::unique_ptr sink_formatter) {\n std::lock_guard lock(mutex_);\n formatter_ = std::move(sink_formatter);\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) {\n std::lock_guard lock(mutex_);\n set_color_mode_impl(mode);\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) {\n if (mode == color_mode::automatic) {\n // should do colors only if out_handle_ points to actual console.\n DWORD console_mode;\n bool in_console = ::GetConsoleMode(static_cast(out_handle_), &console_mode) != 0;\n should_do_colors_ = in_console;\n } else {\n should_do_colors_ = mode == color_mode::always ? true : false;\n }\n}\n\n// set foreground color and return the orig console attributes (for resetting later)\ntemplate \nstd::uint16_t SPDLOG_INLINE\nwincolor_sink::set_foreground_color_(std::uint16_t attribs) {\n CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;\n if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) {\n // just return white if failed getting console info\n return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;\n }\n\n // change only the foreground bits (lowest 4 bits)\n auto new_attribs = static_cast(attribs) | (orig_buffer_info.wAttributes & 0xfff0);\n auto ignored =\n ::SetConsoleTextAttribute(static_cast(out_handle_), static_cast(new_attribs));\n (void)(ignored);\n return static_cast(orig_buffer_info.wAttributes); // return orig attribs\n}\n\n// print a range of formatted message to console\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted,\n size_t start,\n size_t end) {\n if (end > start) {\n#if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE)\n wmemory_buf_t wformatted;\n details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start),\n wformatted);\n auto size = static_cast(wformatted.size());\n auto ignored = ::WriteConsoleW(static_cast(out_handle_), wformatted.data(), size,\n nullptr, nullptr);\n#else\n auto size = static_cast(end - start);\n auto ignored = ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start,\n size, nullptr, nullptr);\n#endif\n (void)(ignored);\n }\n}\n\ntemplate \nvoid SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) {\n auto size = static_cast(formatted.size());\n DWORD bytes_written = 0;\n auto ignored = ::WriteFile(static_cast(out_handle_), formatted.data(), size,\n &bytes_written, nullptr);\n (void)(ignored);\n}\n\n// wincolor_stdout_sink\ntemplate \nSPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode)\n : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {}\n\n// wincolor_stderr_sink\ntemplate \nSPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode)\n : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {}\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "include/spdlog/sinks/wincolor_sink.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n/*\n * Windows color console sink. Uses WriteConsoleA to write to the console with\n * colors\n */\ntemplate \nclass wincolor_sink : public sink {\npublic:\n wincolor_sink(void *out_handle, color_mode mode);\n ~wincolor_sink() override;\n\n wincolor_sink(const wincolor_sink &other) = delete;\n wincolor_sink &operator=(const wincolor_sink &other) = delete;\n\n // change the color for the given level\n void set_color(level::level_enum level, std::uint16_t color);\n void log(const details::log_msg &msg) override;\n void flush() override;\n void set_pattern(const std::string &pattern) override;\n void set_formatter(std::unique_ptr sink_formatter) override;\n void set_color_mode(color_mode mode);\n\nprotected:\n using mutex_t = typename ConsoleMutex::mutex_t;\n void *out_handle_;\n mutex_t &mutex_;\n bool should_do_colors_;\n std::unique_ptr formatter_;\n std::array colors_;\n\n // set foreground color and return the orig console attributes (for resetting later)\n std::uint16_t set_foreground_color_(std::uint16_t attribs);\n\n // print a range of formatted message to console\n void print_range_(const memory_buf_t &formatted, size_t start, size_t end);\n\n // in case we are redirected to file (not in console mode)\n void write_to_file_(const memory_buf_t &formatted);\n\n void set_color_mode_impl(color_mode mode);\n};\n\ntemplate \nclass wincolor_stdout_sink : public wincolor_sink {\npublic:\n explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic);\n};\n\ntemplate \nclass wincolor_stderr_sink : public wincolor_sink {\npublic:\n explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic);\n};\n\nusing wincolor_stdout_sink_mt = wincolor_stdout_sink;\nusing wincolor_stdout_sink_st = wincolor_stdout_sink;\n\nusing wincolor_stderr_sink_mt = wincolor_stderr_sink;\nusing wincolor_stderr_sink_st = wincolor_stderr_sink;\n} // namespace sinks\n} // namespace spdlog\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"wincolor_sink-inl.h\"\n#endif\n" }, { "path": "include/spdlog/spdlog-inl.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#ifndef SPDLOG_HEADER_ONLY\n#include \n#endif\n\n#include \n#include \n\nnamespace spdlog {\n\nSPDLOG_INLINE void initialize_logger(std::shared_ptr logger) {\n details::registry::instance().initialize_logger(std::move(logger));\n}\n\nSPDLOG_INLINE std::shared_ptr get(const std::string &name) {\n return details::registry::instance().get(name);\n}\n\nSPDLOG_INLINE void set_formatter(std::unique_ptr formatter) {\n details::registry::instance().set_formatter(std::move(formatter));\n}\n\nSPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) {\n set_formatter(\n std::unique_ptr(new pattern_formatter(std::move(pattern), time_type)));\n}\n\nSPDLOG_INLINE void enable_backtrace(size_t n_messages) {\n details::registry::instance().enable_backtrace(n_messages);\n}\n\nSPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); }\n\nSPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); }\n\nSPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); }\n\nSPDLOG_INLINE bool should_log(level::level_enum log_level) {\n return default_logger_raw()->should_log(log_level);\n}\n\nSPDLOG_INLINE void set_level(level::level_enum log_level) {\n details::registry::instance().set_level(log_level);\n}\n\nSPDLOG_INLINE void flush_on(level::level_enum log_level) {\n details::registry::instance().flush_on(log_level);\n}\n\nSPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) {\n details::registry::instance().set_error_handler(handler);\n}\n\nSPDLOG_INLINE void register_logger(std::shared_ptr logger) {\n details::registry::instance().register_logger(std::move(logger));\n}\n\nSPDLOG_INLINE void register_or_replace(std::shared_ptr logger) {\n details::registry::instance().register_or_replace(std::move(logger));\n}\n\nSPDLOG_INLINE void apply_all(const std::function)> &fun) {\n details::registry::instance().apply_all(fun);\n}\n\nSPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); }\n\nSPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); }\n\nSPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); }\n\nSPDLOG_INLINE void set_automatic_registration(bool automatic_registration) {\n details::registry::instance().set_automatic_registration(automatic_registration);\n}\n\nSPDLOG_INLINE std::shared_ptr default_logger() {\n return details::registry::instance().default_logger();\n}\n\nSPDLOG_INLINE spdlog::logger *default_logger_raw() {\n return details::registry::instance().get_default_raw();\n}\n\nSPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) {\n details::registry::instance().set_default_logger(std::move(default_logger));\n}\n\nSPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) {\n details::registry::instance().apply_logger_env_levels(std::move(logger));\n}\n\n} // namespace spdlog\n" }, { "path": "include/spdlog/spdlog.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n// spdlog main header file.\n// see example.cpp for usage example\n\n#ifndef SPDLOG_H\n#define SPDLOG_H\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace spdlog {\n\nusing default_factory = synchronous_factory;\n\n// Create and register a logger with a templated sink type\n// The logger's level, formatter and flush level will be set according to the\n// global settings.\n//\n// Example:\n// spdlog::create(\"logger_name\", \"dailylog_filename\", 11, 59);\ntemplate \ninline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) {\n return default_factory::create(std::move(logger_name),\n std::forward(sink_args)...);\n}\n\n// Initialize and register a logger,\n// formatter and flush level will be set according the global settings.\n//\n// Useful for initializing manually created loggers with the global settings.\n//\n// Example:\n// auto mylogger = std::make_shared(\"mylogger\", ...);\n// spdlog::initialize_logger(mylogger);\nSPDLOG_API void initialize_logger(std::shared_ptr logger);\n\n// Return an existing logger or nullptr if a logger with such a name doesn't\n// exist.\n// example: spdlog::get(\"my_logger\")->info(\"hello {}\", \"world\");\nSPDLOG_API std::shared_ptr get(const std::string &name);\n\n// Set global formatter. Each sink in each logger will get a clone of this object\nSPDLOG_API void set_formatter(std::unique_ptr formatter);\n\n// Set global format string.\n// example: spdlog::set_pattern(\"%Y-%m-%d %H:%M:%S.%e %l : %v\");\nSPDLOG_API void set_pattern(std::string pattern,\n pattern_time_type time_type = pattern_time_type::local);\n\n// enable global backtrace support\nSPDLOG_API void enable_backtrace(size_t n_messages);\n\n// disable global backtrace support\nSPDLOG_API void disable_backtrace();\n\n// call dump backtrace on default logger\nSPDLOG_API void dump_backtrace();\n\n// Get global logging level\nSPDLOG_API level::level_enum get_level();\n\n// Set the global logging level\nSPDLOG_API void set_level(level::level_enum log_level);\n\n// Determine whether the default logger should log messages with a certain level\nSPDLOG_API bool should_log(level::level_enum log_level);\n\n// Set a global flush level\nSPDLOG_API void flush_on(level::level_enum log_level);\n\n// Start/Restart a periodic flusher thread\n// Warning: Use only if all your loggers are thread safe!\ntemplate \ninline void flush_every(std::chrono::duration interval) {\n details::registry::instance().flush_every(interval);\n}\n\n// Set global error handler\nSPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));\n\n// Register the given logger with the given name\n// Will throw if a logger with the same name already exists.\nSPDLOG_API void register_logger(std::shared_ptr logger);\n\n// Register the given logger with the given name\n// Will replace any existing logger with the same name.\nSPDLOG_API void register_or_replace(std::shared_ptr logger);\n\n// Apply a user-defined function on all registered loggers\n// Example:\n// spdlog::apply_all([&](std::shared_ptr l) {l->flush();});\nSPDLOG_API void apply_all(const std::function)> &fun);\n\n// Drop the reference to the given logger\nSPDLOG_API void drop(const std::string &name);\n\n// Drop all references from the registry\nSPDLOG_API void drop_all();\n\n// stop any running threads started by spdlog and clean registry loggers\nSPDLOG_API void shutdown();\n\n// Automatic registration of loggers when using spdlog::create() or spdlog::create_async\nSPDLOG_API void set_automatic_registration(bool automatic_registration);\n\n// API for using default logger (stdout_color_mt),\n// e.g.: spdlog::info(\"Message {}\", 1);\n//\n// The default logger object can be accessed using the spdlog::default_logger():\n// For example, to add another sink to it:\n// spdlog::default_logger()->sinks().push_back(some_sink);\n//\n// The default logger can be replaced using spdlog::set_default_logger(new_logger).\n// For example, to replace it with a file logger.\n//\n// IMPORTANT:\n// The default API is thread safe (for _mt loggers), but:\n// set_default_logger() *should not* be used concurrently with the default API.\n// e.g., do not call set_default_logger() from one thread while calling spdlog::info() from another.\n\nSPDLOG_API std::shared_ptr default_logger();\n\nSPDLOG_API spdlog::logger *default_logger_raw();\n\nSPDLOG_API void set_default_logger(std::shared_ptr default_logger);\n\n// Initialize logger level based on environment configs.\n//\n// Useful for applying SPDLOG_LEVEL to manually created loggers.\n//\n// Example:\n// auto mylogger = std::make_shared(\"mylogger\", ...);\n// spdlog::apply_logger_env_levels(mylogger);\nSPDLOG_API void apply_logger_env_levels(std::shared_ptr logger);\n\ntemplate \ninline void log(source_loc source,\n level::level_enum lvl,\n format_string_t fmt,\n Args &&...args) {\n default_logger_raw()->log(source, lvl, fmt, std::forward(args)...);\n}\n\ntemplate \ninline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) {\n default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...);\n}\n\ntemplate \ninline void trace(format_string_t fmt, Args &&...args) {\n default_logger_raw()->trace(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void debug(format_string_t fmt, Args &&...args) {\n default_logger_raw()->debug(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void info(format_string_t fmt, Args &&...args) {\n default_logger_raw()->info(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void warn(format_string_t fmt, Args &&...args) {\n default_logger_raw()->warn(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void error(format_string_t fmt, Args &&...args) {\n default_logger_raw()->error(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void critical(format_string_t fmt, Args &&...args) {\n default_logger_raw()->critical(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void log(source_loc source, level::level_enum lvl, const T &msg) {\n default_logger_raw()->log(source, lvl, msg);\n}\n\ntemplate \ninline void log(level::level_enum lvl, const T &msg) {\n default_logger_raw()->log(lvl, msg);\n}\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\ntemplate \ninline void log(source_loc source,\n level::level_enum lvl,\n wformat_string_t fmt,\n Args &&...args) {\n default_logger_raw()->log(source, lvl, fmt, std::forward(args)...);\n}\n\ntemplate \ninline void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...);\n}\n\ntemplate \ninline void trace(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->trace(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void debug(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->debug(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void info(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->info(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void warn(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->warn(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void error(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->error(fmt, std::forward(args)...);\n}\n\ntemplate \ninline void critical(wformat_string_t fmt, Args &&...args) {\n default_logger_raw()->critical(fmt, std::forward(args)...);\n}\n#endif\n\ntemplate \ninline void trace(const T &msg) {\n default_logger_raw()->trace(msg);\n}\n\ntemplate \ninline void debug(const T &msg) {\n default_logger_raw()->debug(msg);\n}\n\ntemplate \ninline void info(const T &msg) {\n default_logger_raw()->info(msg);\n}\n\ntemplate \ninline void warn(const T &msg) {\n default_logger_raw()->warn(msg);\n}\n\ntemplate \ninline void error(const T &msg) {\n default_logger_raw()->error(msg);\n}\n\ntemplate \ninline void critical(const T &msg) {\n default_logger_raw()->critical(msg);\n}\n\n} // namespace spdlog\n\n//\n// enable/disable log calls at compile time according to global level.\n//\n// define SPDLOG_ACTIVE_LEVEL to one of those (before including spdlog.h):\n// SPDLOG_LEVEL_TRACE,\n// SPDLOG_LEVEL_DEBUG,\n// SPDLOG_LEVEL_INFO,\n// SPDLOG_LEVEL_WARN,\n// SPDLOG_LEVEL_ERROR,\n// SPDLOG_LEVEL_CRITICAL,\n// SPDLOG_LEVEL_OFF\n//\n\n#ifndef SPDLOG_NO_SOURCE_LOC\n#define SPDLOG_LOGGER_CALL(logger, level, ...) \\\n (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_CALL(logger, level, ...) \\\n (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__)\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE\n#define SPDLOG_LOGGER_TRACE(logger, ...) \\\n SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)\n#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0\n#define SPDLOG_TRACE(...) (void)0\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG\n#define SPDLOG_LOGGER_DEBUG(logger, ...) \\\n SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)\n#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0\n#define SPDLOG_DEBUG(...) (void)0\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO\n#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)\n#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_INFO(logger, ...) (void)0\n#define SPDLOG_INFO(...) (void)0\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN\n#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)\n#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_WARN(logger, ...) (void)0\n#define SPDLOG_WARN(...) (void)0\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR\n#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)\n#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0\n#define SPDLOG_ERROR(...) (void)0\n#endif\n\n#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL\n#define SPDLOG_LOGGER_CRITICAL(logger, ...) \\\n SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)\n#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)\n#else\n#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0\n#define SPDLOG_CRITICAL(...) (void)0\n#endif\n\n#ifdef SPDLOG_HEADER_ONLY\n#include \"spdlog-inl.h\"\n#endif\n\n#endif // SPDLOG_H\n" }, { "path": "include/spdlog/stopwatch.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#include \n#include \n\n// Stopwatch support for spdlog (using std::chrono::steady_clock).\n// Displays elapsed seconds since construction as double.\n//\n// Usage:\n//\n// spdlog::stopwatch sw;\n// ...\n// spdlog::debug(\"Elapsed: {} seconds\", sw); => \"Elapsed 0.005116733 seconds\"\n// spdlog::info(\"Elapsed: {:.6} seconds\", sw); => \"Elapsed 0.005163 seconds\"\n//\n//\n// If other units are needed (e.g. millis instead of double), include \"fmt/chrono.h\" and use\n// \"duration_cast<..>(sw.elapsed())\":\n//\n// #include \n//..\n// using std::chrono::duration_cast;\n// using std::chrono::milliseconds;\n// spdlog::info(\"Elapsed {}\", duration_cast(sw.elapsed())); => \"Elapsed 5ms\"\n\nnamespace spdlog {\nclass stopwatch {\n using clock = std::chrono::steady_clock;\n std::chrono::time_point start_tp_;\n\npublic:\n stopwatch()\n : start_tp_{clock::now()} {}\n\n std::chrono::duration elapsed() const {\n return std::chrono::duration(clock::now() - start_tp_);\n }\n\n std::chrono::milliseconds elapsed_ms() const {\n return std::chrono::duration_cast(clock::now() - start_tp_);\n }\n\n void reset() { start_tp_ = clock::now(); }\n};\n} // namespace spdlog\n\n// Support for fmt formatting (e.g. \"{:012.9}\" or just \"{}\")\nnamespace\n#ifdef SPDLOG_USE_STD_FORMAT\n std\n#else\n fmt\n#endif\n{\n\ntemplate <>\nstruct formatter : formatter {\n template \n auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) {\n return formatter::format(sw.elapsed().count(), ctx);\n }\n};\n} // namespace std\n" }, { "path": "include/spdlog/tweakme.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n///////////////////////////////////////////////////////////////////////////////\n//\n// Edit this file to squeeze more performance, and to customize supported\n// features\n//\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.\n// This clock is less accurate - can be off by dozens of millis - depending on\n// the kernel HZ.\n// Uncomment to use it instead of the regular clock.\n//\n// #define SPDLOG_CLOCK_COARSE\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment if source location logging is not needed.\n// This will prevent spdlog from using __FILE__, __LINE__ and SPDLOG_FUNCTION\n//\n// #define SPDLOG_NO_SOURCE_LOC\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern).\n// This will prevent spdlog from querying the thread id on each log call.\n//\n// WARNING: If the log pattern contains thread id (i.e, %t) while this flag is\n// on, zero will be logged as thread id.\n//\n// #define SPDLOG_NO_THREAD_ID\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to prevent spdlog from using thread local storage.\n//\n// WARNING: if your program forks, UNCOMMENT this flag to prevent undefined\n// thread ids in the children logs.\n//\n// #define SPDLOG_NO_TLS\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to avoid spdlog's usage of atomic log levels\n// Use only if your code never modifies a logger's log levels concurrently by\n// different threads.\n//\n// #define SPDLOG_NO_ATOMIC_LEVELS\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to enable usage of wchar_t for file names on Windows.\n//\n// #define SPDLOG_WCHAR_FILENAMES\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to override default eol (\"\\n\" or \"\\r\\n\" under Linux/Windows)\n//\n// #define SPDLOG_EOL \";-)\\n\"\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to override default folder separators (\"/\" or \"\\\\/\" under\n// Linux/Windows). Each character in the string is treated as a different\n// separator.\n//\n// #define SPDLOG_FOLDER_SEPS \"\\\\\"\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to use your own copy of the fmt library instead of spdlog's copy.\n// In this case spdlog will try to include so set your -I flag\n// accordingly.\n//\n// #define SPDLOG_FMT_EXTERNAL\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to use C++20 std::format instead of fmt.\n//\n// #define SPDLOG_USE_STD_FORMAT\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to enable wchar_t support (convert to utf8)\n//\n// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to prevent child processes from inheriting log file descriptors\n//\n// #define SPDLOG_PREVENT_CHILD_FD\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to customize level names (e.g. \"MY TRACE\")\n//\n// #define SPDLOG_LEVEL_NAMES { \"MY TRACE\", \"MY DEBUG\", \"MY INFO\", \"MY WARNING\", \"MY ERROR\", \"MY\n// CRITICAL\", \"OFF\" }\n//\n// For C++17 use string_view_literals:\n//\n// #include \n// using namespace std::string_view_literals;\n// #define SPDLOG_LEVEL_NAMES { \"MY TRACE\"sv, \"MY DEBUG\"sv, \"MY INFO\"sv, \"MY WARNING\"sv, \"MY\n// ERROR\"sv, \"MY CRITICAL\"sv, \"OFF\"sv }\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to customize short level names (e.g. \"MT\")\n// These can be longer than one character.\n//\n// #define SPDLOG_SHORT_LEVEL_NAMES { \"T\", \"D\", \"I\", \"W\", \"E\", \"C\", \"O\" }\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment to disable default logger creation.\n// This might save some (very) small initialization time if no default logger is needed.\n//\n// #define SPDLOG_DISABLE_DEFAULT_LOGGER\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment and set to compile time level with zero cost (default is INFO).\n// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty statements if not enabled\n//\n// #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO\n///////////////////////////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////////////////////////\n// Uncomment (and change if desired) macro to use for function names.\n// This is compiler dependent.\n// __PRETTY_FUNCTION__ might be nicer in clang/gcc, and __FUNCTION__ in msvc.\n// Defaults to __FUNCTION__ (should work on all compilers) if not defined.\n//\n// #ifdef __PRETTY_FUNCTION__\n// # define SPDLOG_FUNCTION __PRETTY_FUNCTION__\n// #else\n// # define SPDLOG_FUNCTION __FUNCTION__\n// #endif\n///////////////////////////////////////////////////////////////////////////////\n" }, { "path": "include/spdlog/version.h", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#pragma once\n\n#define SPDLOG_VER_MAJOR 1\n#define SPDLOG_VER_MINOR 17\n#define SPDLOG_VER_PATCH 0\n\n#define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)\n#define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH)\n" }, { "path": "scripts/ci_setup_clang.sh", "content": "#!/bin/bash\n\nset -ex\n\nVERSION=$1\n\napt-get update\napt-get install -y libc++-${VERSION}-dev libc++abi-${VERSION}-dev\n\nif [[ \"${VERSION}\" -ge 12 ]]; then\n apt-get install -y --no-install-recommends libunwind-${VERSION}-dev\nfi\n" }, { "path": "scripts/extract_version.py", "content": "#!/usr/bin/env python3\n\nimport os\nimport re\n\nbase_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))\nconfig_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')\ndata = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}\nreg = re.compile(r'^\\s*#define\\s+SPDLOG_VER_([A-Z]+)\\s+([0-9]+).*$')\n\nwith open(config_h, 'r') as fp:\n for l in fp:\n m = reg.match(l)\n if m:\n data[m.group(1)] = int(m.group(2))\n\nprint(f\"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}\")\n" }, { "path": "scripts/format.sh", "content": "#!/bin/bash\n\ncd \"$(dirname \"$0\")\"/..\npwd\nfind_sources=\"find include src tests example bench -not ( -path include/spdlog/fmt/bundled -prune ) -type f -name *\\.h -o -name *\\.cpp\"\necho -n \"Running dos2unix \"\n$find_sources | xargs -I {} sh -c \"dos2unix '{}' 2>/dev/null; echo -n '.'\"\necho\necho -n \"Running clang-format \"\n\n$find_sources | xargs -I {} sh -c \"clang-format -i {}; echo -n '.'\"\n\necho\necho -n \"Running cmake-format \"\nfind . -type f -name \"CMakeLists.txt\" -o -name \"*\\.cmake\"|grep -v bundled|grep -v build|xargs -I {} sh -c \"cmake-format --line-width 120 --tab-size 4 --max-subgroups-hwrap 4 -i {}; echo -n '.'\"\necho\n\n\n\n" }, { "path": "src/async.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n#include \n#include \n#include \n" }, { "path": "src/bundled_fmtlib_format.cpp", "content": "// Slightly modified version of fmt lib's format.cc source file.\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)\n\n#include \n\nFMT_BEGIN_NAMESPACE\n\n#if FMT_USE_LOCALE\ntemplate FMT_API locale_ref::locale_ref(const std::locale& loc); // DEPRECATED!\ntemplate FMT_API auto locale_ref::get() const -> std::locale;\n#endif\n\nnamespace detail {\n\ntemplate FMT_API auto dragonbox::to_decimal(float x) noexcept\n -> dragonbox::decimal_fp;\ntemplate FMT_API auto dragonbox::to_decimal(double x) noexcept\n -> dragonbox::decimal_fp;\n\n// Explicit instantiations for char.\n\ntemplate FMT_API auto thousands_sep_impl(locale_ref)\n -> thousands_sep_result;\ntemplate FMT_API auto decimal_point_impl(locale_ref) -> char;\n\n// DEPRECATED!\ntemplate FMT_API void buffer::append(const char*, const char*);\n\n// Explicit instantiations for wchar_t.\n\ntemplate FMT_API auto thousands_sep_impl(locale_ref)\n -> thousands_sep_result;\ntemplate FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;\n\n// DEPRECATED!\ntemplate FMT_API void buffer::append(const wchar_t*, const wchar_t*);\n\n} // namespace detail\nFMT_END_NAMESPACE\n\n#endif // !SPDLOG_FMT_EXTERNAL\n" }, { "path": "src/cfg.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n" }, { "path": "src/color_sinks.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n\n#include \n#include \n//\n// color sinks\n//\n#ifdef _WIN32\n#include \ntemplate class SPDLOG_API spdlog::sinks::wincolor_sink;\ntemplate class SPDLOG_API spdlog::sinks::wincolor_sink;\ntemplate class SPDLOG_API spdlog::sinks::wincolor_stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::wincolor_stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::wincolor_stderr_sink;\ntemplate class SPDLOG_API spdlog::sinks::wincolor_stderr_sink;\n#else\n#include \"spdlog/sinks/ansicolor_sink-inl.h\"\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_sink;\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_sink;\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink;\ntemplate class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink;\n#endif\n\n// factory methods for color loggers\n#include \"spdlog/sinks/stdout_color_sinks-inl.h\"\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stdout_color_mt(const std::string &logger_name,\n color_mode mode);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stdout_color_st(const std::string &logger_name,\n color_mode mode);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stderr_color_mt(const std::string &logger_name,\n color_mode mode);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stderr_color_st(const std::string &logger_name,\n color_mode mode);\n\ntemplate SPDLOG_API std::shared_ptr spdlog::stdout_color_mt(\n const std::string &logger_name, color_mode mode);\ntemplate SPDLOG_API std::shared_ptr spdlog::stdout_color_st(\n const std::string &logger_name, color_mode mode);\ntemplate SPDLOG_API std::shared_ptr spdlog::stderr_color_mt(\n const std::string &logger_name, color_mode mode);\ntemplate SPDLOG_API std::shared_ptr spdlog::stderr_color_st(\n const std::string &logger_name, color_mode mode);\n" }, { "path": "src/file_sinks.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n\ntemplate class SPDLOG_API spdlog::sinks::basic_file_sink;\ntemplate class SPDLOG_API spdlog::sinks::basic_file_sink;\n\n#include \ntemplate class SPDLOG_API spdlog::sinks::rotating_file_sink;\ntemplate class SPDLOG_API spdlog::sinks::rotating_file_sink;\n" }, { "path": "src/spdlog.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n// template instantiate logger constructor with sinks init list\ntemplate SPDLOG_API spdlog::logger::logger(std::string name,\n sinks_init_list::iterator begin,\n sinks_init_list::iterator end);\ntemplate class SPDLOG_API spdlog::sinks::base_sink;\ntemplate class SPDLOG_API spdlog::sinks::base_sink;\n" }, { "path": "src/stdout_sinks.cpp", "content": "// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n#ifndef SPDLOG_COMPILED_LIB\n#error Please define SPDLOG_COMPILED_LIB to compile this file.\n#endif\n\n#include \n\n#include \n#include \n#include \n\ntemplate class SPDLOG_API spdlog::sinks::stdout_sink_base;\ntemplate class SPDLOG_API spdlog::sinks::stdout_sink_base;\ntemplate class SPDLOG_API spdlog::sinks::stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::stdout_sink;\ntemplate class SPDLOG_API spdlog::sinks::stderr_sink;\ntemplate class SPDLOG_API spdlog::sinks::stderr_sink;\n\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stdout_logger_mt(const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stdout_logger_st(const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stderr_logger_mt(const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr\nspdlog::stderr_logger_st(const std::string &logger_name);\n\ntemplate SPDLOG_API std::shared_ptr spdlog::stdout_logger_mt(\n const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr spdlog::stdout_logger_st(\n const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr spdlog::stderr_logger_mt(\n const std::string &logger_name);\ntemplate SPDLOG_API std::shared_ptr spdlog::stderr_logger_st(\n const std::string &logger_name);\n" }, { "path": "tests/CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.11)\nproject(spdlog_utests CXX)\n\nif(NOT TARGET spdlog)\n # Stand-alone build\n find_package(spdlog REQUIRED)\nendif()\n\ninclude(../cmake/utils.cmake)\n\nfind_package(PkgConfig)\nif(PkgConfig_FOUND)\n pkg_check_modules(systemd libsystemd)\nendif()\n\nfind_package(Catch2 3 QUIET)\nif(Catch2_FOUND)\n message(STATUS \"Packaged version of Catch will be used.\")\nelse()\n message(STATUS \"Bundled version of Catch will be downloaded and used.\")\n include(FetchContent)\n FetchContent_Declare(\n Catch2 GIT_REPOSITORY https://github.com/catchorg/Catch2.git\n GIT_TAG 53d0d913a422d356b23dd927547febdf69ee9081 # v3.5.0\n )\n FetchContent_MakeAvailable(Catch2)\nendif()\n\nset(SPDLOG_UTESTS_SOURCES\n test_file_helper.cpp\n test_file_logging.cpp\n test_daily_logger.cpp\n test_misc.cpp\n test_eventlog.cpp\n test_pattern_formatter.cpp\n test_async.cpp\n test_registry.cpp\n test_macros.cpp\n utils.cpp\n main.cpp\n test_mpmc_q.cpp\n test_dup_filter.cpp\n test_fmt_helper.cpp\n test_stdout_api.cpp\n test_backtrace.cpp\n test_create_dir.cpp\n test_custom_callbacks.cpp\n test_cfg.cpp\n test_time_point.cpp\n test_stopwatch.cpp\n test_circular_q.cpp\n test_bin_to_hex.cpp\n test_ringbuffer.cpp\n test_timezone.cpp\n)\n\nif(NOT SPDLOG_NO_EXCEPTIONS)\n list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)\nendif()\n\nif(systemd_FOUND)\n list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp)\nendif()\n\nenable_testing()\n\nfunction(spdlog_prepare_test test_target spdlog_lib)\n add_executable(${test_target} ${SPDLOG_UTESTS_SOURCES})\n spdlog_enable_warnings(${test_target})\n target_link_libraries(${test_target} PRIVATE ${spdlog_lib})\n if(systemd_FOUND)\n target_link_libraries(${test_target} PRIVATE ${systemd_LIBRARIES})\n endif()\n target_link_libraries(${test_target} PRIVATE Catch2::Catch2WithMain)\n if(SPDLOG_SANITIZE_ADDRESS)\n spdlog_enable_addr_sanitizer(${test_target})\n elseif(SPDLOG_SANITIZE_THREAD)\n spdlog_enable_thread_sanitizer(${test_target})\n endif()\n add_test(NAME ${test_target} COMMAND ${test_target} --order decl)\n set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)\nendfunction()\n\n# The compiled library tests\nif(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL)\n spdlog_prepare_test(spdlog-utests spdlog::spdlog)\nendif()\n\n# The header-only library version tests\nif(SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)\n spdlog_prepare_test(spdlog-utests-ho spdlog::spdlog_header_only)\nendif()\n" }, { "path": "tests/includes.h", "content": "#pragma once\n\n#if defined(__GNUC__) && __GNUC__ == 12\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wmaybe-uninitialized\" // Workaround for GCC 12\n#endif\n#include \n#if defined(__GNUC__) && __GNUC__ == 12\n#pragma GCC diagnostic pop\n#endif\n\n#include \"utils.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG\n\n#undef SPDLOG_LEVEL_NAMES\n#undef SPDLOG_SHORT_LEVEL_NAMES\n\n#include \"spdlog/spdlog.h\"\n#include \"spdlog/async.h\"\n#include \"spdlog/details/fmt_helper.h\"\n#include \"spdlog/details/os.h\"\n\n#ifndef SPDLOG_NO_TLS\n#include \"spdlog/mdc.h\"\n#endif\n\n#include \"spdlog/sinks/basic_file_sink.h\"\n#include \"spdlog/sinks/daily_file_sink.h\"\n#include \"spdlog/sinks/null_sink.h\"\n#include \"spdlog/sinks/ostream_sink.h\"\n#include \"spdlog/sinks/rotating_file_sink.h\"\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n#include \"spdlog/sinks/msvc_sink.h\"\n#include \"spdlog/pattern_formatter.h\"\n" }, { "path": "tests/main.cpp", "content": "#if defined(__GNUC__) && __GNUC__ == 12\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wmaybe-uninitialized\" // Workaround for GCC 12\n#endif\n\n#include \n\n#if defined(__GNUC__) && __GNUC__ == 12\n#pragma GCC diagnostic pop\n#endif\n" }, { "path": "tests/test_async.cpp", "content": "#include \"includes.h\"\n#include \"spdlog/async.h\"\n#include \"spdlog/sinks/basic_file_sink.h\"\n#include \"test_sink.h\"\n\n#define TEST_FILENAME \"test_logs/async_test.log\"\n\nTEST_CASE(\"basic async test \", \"[async]\") {\n auto test_sink = std::make_shared();\n size_t overrun_counter = 0;\n size_t queue_size = 128;\n size_t messages = 256;\n {\n auto tp = std::make_shared(queue_size, 1);\n auto logger = std::make_shared(\"as\", test_sink, tp,\n spdlog::async_overflow_policy::block);\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message #{}\", i);\n }\n logger->flush();\n overrun_counter = tp->overrun_counter();\n }\n REQUIRE(test_sink->msg_counter() == messages);\n REQUIRE(test_sink->flush_counter() == 1);\n REQUIRE(overrun_counter == 0);\n}\n\nTEST_CASE(\"discard policy \", \"[async]\") {\n auto test_sink = std::make_shared();\n test_sink->set_delay(std::chrono::milliseconds(1));\n size_t queue_size = 4;\n size_t messages = 1024;\n\n auto tp = std::make_shared(queue_size, 1);\n auto logger = std::make_shared(\n \"as\", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest);\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message\");\n }\n REQUIRE(test_sink->msg_counter() < messages);\n REQUIRE(tp->overrun_counter() > 0);\n}\n\nTEST_CASE(\"discard policy discard_new \", \"[async]\") {\n auto test_sink = std::make_shared();\n test_sink->set_delay(std::chrono::milliseconds(1));\n size_t queue_size = 4;\n size_t messages = 1024;\n\n auto tp = std::make_shared(queue_size, 1);\n auto logger = std::make_shared(\n \"as\", test_sink, tp, spdlog::async_overflow_policy::discard_new);\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message\");\n }\n REQUIRE(test_sink->msg_counter() < messages);\n REQUIRE(tp->discard_counter() > 0);\n}\n\nTEST_CASE(\"discard policy using factory \", \"[async]\") {\n size_t queue_size = 4;\n size_t messages = 1024;\n spdlog::init_thread_pool(queue_size, 1);\n\n auto logger = spdlog::create_async_nb(\"as2\");\n auto test_sink = std::static_pointer_cast(logger->sinks()[0]);\n test_sink->set_delay(std::chrono::milliseconds(3));\n\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message\");\n }\n\n REQUIRE(test_sink->msg_counter() < messages);\n spdlog::drop_all();\n}\n\nTEST_CASE(\"flush\", \"[async]\") {\n auto test_sink = std::make_shared();\n size_t queue_size = 256;\n size_t messages = 256;\n {\n auto tp = std::make_shared(queue_size, 1);\n auto logger = std::make_shared(\"as\", test_sink, tp,\n spdlog::async_overflow_policy::block);\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message #{}\", i);\n }\n\n logger->flush();\n }\n // std::this_thread::sleep_for(std::chrono::milliseconds(250));\n REQUIRE(test_sink->msg_counter() == messages);\n REQUIRE(test_sink->flush_counter() == 1);\n}\n\nTEST_CASE(\"async periodic flush\", \"[async]\") {\n auto logger = spdlog::create_async(\"as\");\n auto test_sink = std::static_pointer_cast(logger->sinks()[0]);\n\n spdlog::flush_every(std::chrono::seconds(1));\n std::this_thread::sleep_for(std::chrono::milliseconds(1700));\n REQUIRE(test_sink->flush_counter() == 1);\n spdlog::flush_every(std::chrono::seconds(0));\n spdlog::drop_all();\n}\n\nTEST_CASE(\"tp->wait_empty() \", \"[async]\") {\n auto test_sink = std::make_shared();\n test_sink->set_delay(std::chrono::milliseconds(5));\n size_t messages = 100;\n\n auto tp = std::make_shared(messages, 2);\n auto logger = std::make_shared(\"as\", test_sink, tp,\n spdlog::async_overflow_policy::block);\n for (size_t i = 0; i < messages; i++) {\n logger->info(\"Hello message #{}\", i);\n }\n logger->flush();\n tp.reset();\n\n REQUIRE(test_sink->msg_counter() == messages);\n REQUIRE(test_sink->flush_counter() == 1);\n}\n\nTEST_CASE(\"multi threads\", \"[async]\") {\n auto test_sink = std::make_shared();\n size_t queue_size = 128;\n size_t messages = 256;\n size_t n_threads = 10;\n {\n auto tp = std::make_shared(queue_size, 1);\n auto logger = std::make_shared(\"as\", test_sink, tp,\n spdlog::async_overflow_policy::block);\n\n std::vector threads;\n for (size_t i = 0; i < n_threads; i++) {\n threads.emplace_back([logger, messages] {\n for (size_t j = 0; j < messages; j++) {\n logger->info(\"Hello message #{}\", j);\n }\n });\n logger->flush();\n }\n\n for (auto &t : threads) {\n t.join();\n }\n }\n\n REQUIRE(test_sink->msg_counter() == messages * n_threads);\n REQUIRE(test_sink->flush_counter() == n_threads);\n}\n\nTEST_CASE(\"to_file\", \"[async]\") {\n prepare_logdir();\n size_t messages = 1024;\n size_t tp_threads = 1;\n spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n {\n auto file_sink = std::make_shared(filename, true);\n auto tp = std::make_shared(messages, tp_threads);\n auto logger =\n std::make_shared(\"as\", std::move(file_sink), std::move(tp));\n\n for (size_t j = 0; j < messages; j++) {\n logger->info(\"Hello message #{}\", j);\n }\n }\n\n require_message_count(TEST_FILENAME, messages);\n auto contents = file_contents(TEST_FILENAME);\n using spdlog::details::os::default_eol;\n REQUIRE(ends_with(contents, spdlog::fmt_lib::format(\"Hello message #1023{}\", default_eol)));\n}\n\nTEST_CASE(\"to_file multi-workers\", \"[async]\") {\n prepare_logdir();\n size_t messages = 1024 * 10;\n size_t tp_threads = 10;\n spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n {\n auto file_sink = std::make_shared(filename, true);\n auto tp = std::make_shared(messages, tp_threads);\n auto logger =\n std::make_shared(\"as\", std::move(file_sink), std::move(tp));\n\n for (size_t j = 0; j < messages; j++) {\n logger->info(\"Hello message #{}\", j);\n }\n }\n require_message_count(TEST_FILENAME, messages);\n}\n\nTEST_CASE(\"bad_tp\", \"[async]\") {\n auto test_sink = std::make_shared();\n std::shared_ptr const empty_tp;\n auto logger = std::make_shared(\"as\", test_sink, empty_tp);\n logger->info(\"Please throw an exception\");\n REQUIRE(test_sink->msg_counter() == 0);\n}\n" }, { "path": "tests/test_backtrace.cpp", "content": "#include \"includes.h\"\n#include \"test_sink.h\"\n#include \"spdlog/async.h\"\n\nTEST_CASE(\"bactrace1\", \"[bactrace]\") {\n using spdlog::sinks::test_sink_st;\n auto test_sink = std::make_shared();\n size_t backtrace_size = 5;\n\n spdlog::logger logger(\"test-backtrace\", test_sink);\n logger.set_pattern(\"%v\");\n logger.enable_backtrace(backtrace_size);\n\n logger.info(\"info message\");\n for (int i = 0; i < 100; i++) logger.debug(\"debug message {}\", i);\n\n REQUIRE(test_sink->lines().size() == 1);\n REQUIRE(test_sink->lines()[0] == \"info message\");\n\n logger.dump_backtrace();\n REQUIRE(test_sink->lines().size() == backtrace_size + 3);\n REQUIRE(test_sink->lines()[1] == \"****************** Backtrace Start ******************\");\n REQUIRE(test_sink->lines()[2] == \"debug message 95\");\n REQUIRE(test_sink->lines()[3] == \"debug message 96\");\n REQUIRE(test_sink->lines()[4] == \"debug message 97\");\n REQUIRE(test_sink->lines()[5] == \"debug message 98\");\n REQUIRE(test_sink->lines()[6] == \"debug message 99\");\n REQUIRE(test_sink->lines()[7] == \"****************** Backtrace End ********************\");\n}\n\nTEST_CASE(\"bactrace-empty\", \"[bactrace]\") {\n using spdlog::sinks::test_sink_st;\n auto test_sink = std::make_shared();\n size_t backtrace_size = 5;\n\n spdlog::logger logger(\"test-backtrace\", test_sink);\n logger.set_pattern(\"%v\");\n logger.enable_backtrace(backtrace_size);\n logger.dump_backtrace();\n REQUIRE(test_sink->lines().size() == 0);\n}\n\nTEST_CASE(\"bactrace-async\", \"[bactrace]\") {\n using spdlog::sinks::test_sink_mt;\n auto test_sink = std::make_shared();\n using spdlog::details::os::sleep_for_millis;\n\n size_t backtrace_size = 5;\n\n spdlog::init_thread_pool(120, 1);\n auto logger = std::make_shared(\"test-bactrace-async\", test_sink,\n spdlog::thread_pool());\n logger->set_pattern(\"%v\");\n logger->enable_backtrace(backtrace_size);\n\n logger->info(\"info message\");\n for (int i = 0; i < 100; i++) logger->debug(\"debug message {}\", i);\n\n sleep_for_millis(100);\n REQUIRE(test_sink->lines().size() == 1);\n REQUIRE(test_sink->lines()[0] == \"info message\");\n\n logger->dump_backtrace();\n sleep_for_millis(100); // give time for the async dump to complete\n REQUIRE(test_sink->lines().size() == backtrace_size + 3);\n REQUIRE(test_sink->lines()[1] == \"****************** Backtrace Start ******************\");\n REQUIRE(test_sink->lines()[2] == \"debug message 95\");\n REQUIRE(test_sink->lines()[3] == \"debug message 96\");\n REQUIRE(test_sink->lines()[4] == \"debug message 97\");\n REQUIRE(test_sink->lines()[5] == \"debug message 98\");\n REQUIRE(test_sink->lines()[6] == \"debug message 99\");\n REQUIRE(test_sink->lines()[7] == \"****************** Backtrace End ********************\");\n}\n" }, { "path": "tests/test_bin_to_hex.cpp", "content": "#include \"includes.h\"\n#include \"test_sink.h\"\n#include \"spdlog/fmt/bin_to_hex.h\"\n\nTEST_CASE(\"to_hex\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0xc, 0xff, 0xff};\n oss_logger.info(\"{}\", spdlog::to_hex(v));\n\n auto output = oss.str();\n REQUIRE(ends_with(output,\n \"0000: 09 0a 0b 0c ff ff\" + std::string(spdlog::details::os::default_eol)));\n}\n\nTEST_CASE(\"to_hex_upper\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0xc, 0xff, 0xff};\n oss_logger.info(\"{:X}\", spdlog::to_hex(v));\n\n auto output = oss.str();\n REQUIRE(ends_with(output,\n \"0000: 09 0A 0B 0C FF FF\" + std::string(spdlog::details::os::default_eol)));\n}\n\nTEST_CASE(\"to_hex_no_delimiter\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0xc, 0xff, 0xff};\n oss_logger.info(\"{:sX}\", spdlog::to_hex(v));\n\n auto output = oss.str();\n REQUIRE(\n ends_with(output, \"0000: 090A0B0CFFFF\" + std::string(spdlog::details::os::default_eol)));\n}\n\nTEST_CASE(\"to_hex_show_ascii\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};\n oss_logger.info(\"{:Xsa}\", spdlog::to_hex(v, 8));\n\n REQUIRE(ends_with(oss.str(), \"0000: 090A0B410C4BFFFF ...A.K..\" +\n std::string(spdlog::details::os::default_eol)));\n}\n\nTEST_CASE(\"to_hex_different_size_per_line\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};\n\n oss_logger.info(\"{:Xsa}\", spdlog::to_hex(v, 10));\n REQUIRE(ends_with(oss.str(), \"0000: 090A0B410C4BFFFF ...A.K..\" +\n std::string(spdlog::details::os::default_eol)));\n\n oss_logger.info(\"{:Xs}\", spdlog::to_hex(v, 10));\n REQUIRE(ends_with(oss.str(),\n \"0000: 090A0B410C4BFFFF\" + std::string(spdlog::details::os::default_eol)));\n\n oss_logger.info(\"{:Xsa}\", spdlog::to_hex(v, 6));\n REQUIRE(ends_with(\n oss.str(), \"0000: 090A0B410C4B ...A.K\" + std::string(spdlog::details::os::default_eol) +\n \"0006: FFFF ..\" + std::string(spdlog::details::os::default_eol)));\n\n oss_logger.info(\"{:Xs}\", spdlog::to_hex(v, 6));\n REQUIRE(ends_with(oss.str(), \"0000: 090A0B410C4B\" +\n std::string(spdlog::details::os::default_eol) + \"0006: FFFF\" +\n std::string(spdlog::details::os::default_eol)));\n}\n\nTEST_CASE(\"to_hex_no_ascii\", \"[to_hex]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"oss\", oss_sink);\n\n std::vector v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};\n oss_logger.info(\"{:Xs}\", spdlog::to_hex(v, 8));\n\n REQUIRE(ends_with(oss.str(),\n \"0000: 090A0B410C4BFFFF\" + std::string(spdlog::details::os::default_eol)));\n\n oss_logger.info(\"{:Xsna}\", spdlog::to_hex(v, 8));\n\n REQUIRE(\n ends_with(oss.str(), \"090A0B410C4BFFFF\" + std::string(spdlog::details::os::default_eol)));\n}\n" }, { "path": "tests/test_cfg.cpp", "content": "\n#include \"includes.h\"\n#include \"test_sink.h\"\n\n#include \n#include \n\nusing spdlog::cfg::load_argv_levels;\nusing spdlog::cfg::load_env_levels;\nusing spdlog::sinks::test_sink_st;\n\nTEST_CASE(\"env\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n auto l1 = spdlog::create(\"l1\");\n#ifdef CATCH_PLATFORM_WINDOWS\n _putenv_s(\"SPDLOG_LEVEL\", \"l1=warn\");\n#else\n setenv(\"SPDLOG_LEVEL\", \"l1=warn\", 1);\n#endif\n load_env_levels();\n REQUIRE(l1->level() == spdlog::level::warn);\n\n#ifdef CATCH_PLATFORM_WINDOWS\n _putenv_s(\"MYAPP_LEVEL\", \"l1=trace\");\n#else\n setenv(\"MYAPP_LEVEL\", \"l1=trace\", 1);\n#endif\n load_env_levels(\"MYAPP_LEVEL\");\n REQUIRE(l1->level() == spdlog::level::trace);\n\n spdlog::set_default_logger(spdlog::create(\"cfg-default\"));\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"argv1\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=warn\"};\n load_argv_levels(2, argv);\n auto l1 = spdlog::create(\"l1\");\n REQUIRE(l1->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"argv2\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=warn,trace\"};\n load_argv_levels(2, argv);\n auto l1 = spdlog::create(\"l1\");\n REQUIRE(l1->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);\n}\n\nTEST_CASE(\"argv3\", \"[cfg]\") {\n spdlog::set_level(spdlog::level::trace);\n\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=junk_name=warn\"};\n load_argv_levels(2, argv);\n auto l1 = spdlog::create(\"l1\");\n REQUIRE(l1->level() == spdlog::level::trace);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);\n}\n\nTEST_CASE(\"argv4\", \"[cfg]\") {\n spdlog::set_level(spdlog::level::info);\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=junk\"};\n load_argv_levels(2, argv);\n auto l1 = spdlog::create(\"l1\");\n REQUIRE(l1->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"argv5\", \"[cfg]\") {\n spdlog::set_level(spdlog::level::info);\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"ignore\", \"SPDLOG_LEVEL=l1=warn,trace\"};\n load_argv_levels(3, argv);\n auto l1 = spdlog::create(\"l1\");\n REQUIRE(l1->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);\n spdlog::set_level(spdlog::level::info);\n}\n\nTEST_CASE(\"argv6\", \"[cfg]\") {\n spdlog::set_level(spdlog::level::err);\n const char *argv[] = {\"\"};\n load_argv_levels(1, argv);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);\n spdlog::set_level(spdlog::level::info);\n}\n\nTEST_CASE(\"argv7\", \"[cfg]\") {\n spdlog::set_level(spdlog::level::err);\n const char *argv[] = {\"\"};\n load_argv_levels(0, argv);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);\n spdlog::set_level(spdlog::level::info);\n}\n\nTEST_CASE(\"level-not-set-test1\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n const char *argv[] = {\"ignore\", \"\"};\n load_argv_levels(2, argv);\n auto l1 = spdlog::create(\"l1\");\n l1->set_level(spdlog::level::trace);\n REQUIRE(l1->level() == spdlog::level::trace);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"level-not-set-test2\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=trace\"};\n\n auto l1 = spdlog::create(\"l1\");\n l1->set_level(spdlog::level::warn);\n auto l2 = spdlog::create(\"l2\");\n l2->set_level(spdlog::level::warn);\n\n load_argv_levels(2, argv);\n\n REQUIRE(l1->level() == spdlog::level::trace);\n REQUIRE(l2->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"level-not-set-test3\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=trace\"};\n\n load_argv_levels(2, argv);\n\n auto l1 = spdlog::create(\"l1\");\n auto l2 = spdlog::create(\"l2\");\n\n REQUIRE(l1->level() == spdlog::level::trace);\n REQUIRE(l2->level() == spdlog::level::info);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"level-not-set-test4\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=trace,warn\"};\n\n load_argv_levels(2, argv);\n\n auto l1 = spdlog::create(\"l1\");\n auto l2 = spdlog::create(\"l2\");\n\n REQUIRE(l1->level() == spdlog::level::trace);\n REQUIRE(l2->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);\n}\n\nTEST_CASE(\"level-not-set-test5\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l1=junk,warn\"};\n\n load_argv_levels(2, argv);\n\n auto l1 = spdlog::create(\"l1\");\n auto l2 = spdlog::create(\"l2\");\n\n REQUIRE(l1->level() == spdlog::level::warn);\n REQUIRE(l2->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);\n}\n\nTEST_CASE(\"restore-to-default\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=info\"};\n load_argv_levels(2, argv);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n}\n\nTEST_CASE(\"uppercase-level-names\", \"[cfg]\") {\n spdlog::drop(\"l1\");\n spdlog::drop(\"l2\");\n \n#ifdef CATCH_PLATFORM_WINDOWS\n _putenv_s(\"SPDLOG_LEVEL\", \"l1=DEBUG,INFO\");\n#else\n setenv(\"SPDLOG_LEVEL\", \"l1=DEBUG,INFO\", 1);\n#endif\n load_env_levels();\n auto l1 = spdlog::create(\"l1\");\n auto l2 = spdlog::create(\"l2\");\n \n REQUIRE(l1->level() == spdlog::level::debug);\n REQUIRE(l2->level() == spdlog::level::info);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);\n \n // Test with argv\n spdlog::drop(\"l3\");\n const char *argv[] = {\"ignore\", \"SPDLOG_LEVEL=l3=WARN,ERROR\"};\n load_argv_levels(2, argv);\n auto l3 = spdlog::create(\"l3\");\n \n REQUIRE(l3->level() == spdlog::level::warn);\n REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);\n \n // Reset to info\n spdlog::set_level(spdlog::level::info);\n}\n" }, { "path": "tests/test_circular_q.cpp", "content": "#include \"includes.h\"\n#include \"spdlog/details/circular_q.h\"\n\nusing q_type = spdlog::details::circular_q;\nTEST_CASE(\"test_size\", \"[circular_q]\") {\n const size_t q_size = 4;\n q_type q(q_size);\n REQUIRE(q.size() == 0);\n REQUIRE(q.empty() == true);\n for (size_t i = 0; i < q_size; i++) {\n q.push_back(std::move(i));\n }\n REQUIRE(q.size() == q_size);\n q.push_back(999);\n REQUIRE(q.size() == q_size);\n}\n\nTEST_CASE(\"test_rolling\", \"[circular_q]\") {\n const size_t q_size = 4;\n q_type q(q_size);\n\n for (size_t i = 0; i < q_size + 2; i++) {\n q.push_back(std::move(i));\n }\n\n REQUIRE(q.size() == q_size);\n\n REQUIRE(q.front() == 2);\n q.pop_front();\n\n REQUIRE(q.front() == 3);\n q.pop_front();\n\n REQUIRE(q.front() == 4);\n q.pop_front();\n\n REQUIRE(q.front() == 5);\n q.pop_front();\n\n REQUIRE(q.empty());\n\n q.push_back(6);\n REQUIRE(q.front() == 6);\n}\n\nTEST_CASE(\"test_empty\", \"[circular_q]\") {\n q_type q(0);\n q.push_back(1);\n REQUIRE(q.empty());\n}" }, { "path": "tests/test_create_dir.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n\nusing spdlog::details::os::create_dir;\nusing spdlog::details::os::path_exists;\n\nbool try_create_dir(const spdlog::filename_t &path, const spdlog::filename_t &normalized_path) {\n auto rv = create_dir(path);\n REQUIRE(rv == true);\n return path_exists(normalized_path);\n}\n\nTEST_CASE(\"create_dir\", \"[create_dir]\") {\n prepare_logdir();\n\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs/dir1/dir1\"),\n SPDLOG_FILENAME_T(\"test_logs/dir1/dir1\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs/dir1/dir1\"),\n SPDLOG_FILENAME_T(\"test_logs/dir1/dir1\"))); // test existing\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs/dir1///dir2//\"),\n SPDLOG_FILENAME_T(\"test_logs/dir1/dir2\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"./test_logs/dir1/dir3\"),\n SPDLOG_FILENAME_T(\"test_logs/dir1/dir3\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs/../test_logs/dir1/dir4\"),\n SPDLOG_FILENAME_T(\"test_logs/dir1/dir4\")));\n\n#ifdef WIN32\n // test backslash folder separator\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir222\"),\n SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir222\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir223\\\\\"),\n SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir223\\\\\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\".\\\\test_logs\\\\dir1\\\\dir2\\\\dir99\\\\..\\\\dir23\"),\n SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir2\\\\dir23\")));\n REQUIRE(try_create_dir(SPDLOG_FILENAME_T(\"test_logs\\\\..\\\\test_logs\\\\dir1\\\\dir5\"),\n SPDLOG_FILENAME_T(\"test_logs\\\\dir1\\\\dir5\")));\n#endif\n}\n\nTEST_CASE(\"create_invalid_dir\", \"[create_dir]\") {\n REQUIRE(create_dir(SPDLOG_FILENAME_T(\"\")) == false);\n REQUIRE(create_dir(spdlog::filename_t{}) == false);\n#ifdef __linux__\n REQUIRE(create_dir(\"/proc/spdlog-utest\") == false);\n#endif\n}\n\nTEST_CASE(\"dir_name\", \"[create_dir]\") {\n using spdlog::details::os::dir_name;\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"\")).empty());\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir\")).empty());\n\n#ifdef WIN32\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir\\)\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir\\\\\\)\")) == SPDLOG_FILENAME_T(R\"(dir\\\\)\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir\\file)\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir/file)\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir\\file.txt)\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir/file)\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(dir\\file.txt\\)\")) ==\n SPDLOG_FILENAME_T(R\"(dir\\file.txt)\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(\\dir\\file.txt)\")) == SPDLOG_FILENAME_T(R\"(\\dir)\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(\\\\dir\\file.txt)\")) == SPDLOG_FILENAME_T(R\"(\\\\dir)\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(..\\file.txt)\")) == SPDLOG_FILENAME_T(\"..\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(.\\file.txt)\")) == SPDLOG_FILENAME_T(\".\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(c:\\\\a\\b\\c\\d\\file.txt)\")) ==\n SPDLOG_FILENAME_T(R\"(c:\\\\a\\b\\c\\d)\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(R\"(c://a/b/c/d/file.txt)\")) ==\n SPDLOG_FILENAME_T(R\"(c://a/b/c/d)\"));\n#endif\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir/\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir///\")) == SPDLOG_FILENAME_T(\"dir//\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir/file\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir/file.txt\")) == SPDLOG_FILENAME_T(\"dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"dir/file.txt/\")) == SPDLOG_FILENAME_T(\"dir/file.txt\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"/dir/file.txt\")) == SPDLOG_FILENAME_T(\"/dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"//dir/file.txt\")) == SPDLOG_FILENAME_T(\"//dir\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"../file.txt\")) == SPDLOG_FILENAME_T(\"..\"));\n REQUIRE(dir_name(SPDLOG_FILENAME_T(\"./file.txt\")) == SPDLOG_FILENAME_T(\".\"));\n}\n\n#ifdef _WIN32\n\n//\n// test windows cases when drive letter is given e.g. C:\\\\some-folder\n//\n#include \n#include \n\nstd::string get_full_path(const std::string &relative_folder_path) {\n char full_path[MAX_PATH];\n\n DWORD result = ::GetFullPathNameA(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr);\n // Return an empty string if failed to get full path\n return result > 0 && result < MAX_PATH ? std::string(full_path) : std::string();\n}\n\nstd::wstring get_full_path(const std::wstring &relative_folder_path) {\n wchar_t full_path[MAX_PATH];\n DWORD result = ::GetFullPathNameW(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr);\n return result > 0 && result < MAX_PATH ? std::wstring(full_path) : std::wstring();\n}\n\nspdlog::filename_t::value_type find_non_existing_drive() {\n for (char drive = 'A'; drive <= 'Z'; ++drive) {\n std::string root_path = std::string(1, drive) + \":\\\\\";\n UINT drive_type = GetDriveTypeA(root_path.c_str());\n if (drive_type == DRIVE_NO_ROOT_DIR) {\n return static_cast(drive);\n }\n }\n return '\\0'; // No available drive found\n}\n\nTEST_CASE(\"create_abs_path1\", \"[create_dir]\") {\n prepare_logdir();\n auto abs_path = get_full_path(SPDLOG_FILENAME_T(\"test_logs\\\\logdir1\"));\n REQUIRE(!abs_path.empty());\n REQUIRE(create_dir(abs_path) == true);\n}\n\nTEST_CASE(\"create_abs_path2\", \"[create_dir]\") {\n prepare_logdir();\n auto abs_path = get_full_path(SPDLOG_FILENAME_T(\"test_logs/logdir2\"));\n REQUIRE(!abs_path.empty());\n REQUIRE(create_dir(abs_path) == true);\n}\n\nTEST_CASE(\"non_existing_drive\", \"[create_dir]\") {\n prepare_logdir();\n spdlog::filename_t path;\n\n auto non_existing_drive = find_non_existing_drive();\n path += non_existing_drive;\n path += SPDLOG_FILENAME_T(\":\\\\\");\n REQUIRE(create_dir(path) == false);\n path += SPDLOG_FILENAME_T(\"subdir\");\n REQUIRE(create_dir(path) == false);\n}\n// #endif // SPDLOG_WCHAR_FILENAMES\n#endif // _WIN32\n" }, { "path": "tests/test_custom_callbacks.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n#include \"test_sink.h\"\n#include \"spdlog/sinks/callback_sink.h\"\n#include \"spdlog/async.h\"\n#include \"spdlog/common.h\"\n\nTEST_CASE(\"custom_callback_logger\", \"[custom_callback_logger]\") {\n std::vector lines;\n spdlog::pattern_formatter formatter;\n auto callback_logger =\n std::make_shared([&](const spdlog::details::log_msg &msg) {\n spdlog::memory_buf_t formatted;\n formatter.format(msg, formatted);\n auto eol_len = strlen(spdlog::details::os::default_eol);\n using diff_t =\n typename std::iterator_traits::difference_type;\n lines.emplace_back(formatted.begin(), formatted.end() - static_cast(eol_len));\n });\n std::shared_ptr test_sink(new spdlog::sinks::test_sink_st);\n\n spdlog::logger logger(\"test-callback\", {callback_logger, test_sink});\n\n logger.info(\"test message 1\");\n logger.info(\"test message 2\");\n logger.info(\"test message 3\");\n\n std::vector ref_lines = test_sink->lines();\n\n REQUIRE(lines[0] == ref_lines[0]);\n REQUIRE(lines[1] == ref_lines[1]);\n REQUIRE(lines[2] == ref_lines[2]);\n spdlog::drop_all();\n}\n" }, { "path": "tests/test_daily_logger.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n\n#ifdef SPDLOG_USE_STD_FORMAT\nusing filename_memory_buf_t = std::basic_string;\n#else\nusing filename_memory_buf_t = fmt::basic_memory_buffer;\n#endif\n\n#ifdef SPDLOG_WCHAR_FILENAMES\nstd::string filename_buf_to_utf8string(const filename_memory_buf_t &w) {\n spdlog::memory_buf_t buf;\n spdlog::details::os::wstr_to_utf8buf(spdlog::wstring_view_t(w.data(), w.size()), buf);\n return SPDLOG_BUF_TO_STRING(buf);\n}\n#else\nstd::string filename_buf_to_utf8string(const filename_memory_buf_t &w) {\n return SPDLOG_BUF_TO_STRING(w);\n}\n#endif\n\nTEST_CASE(\"daily_logger with dateonly calculator\", \"[daily_logger]\") {\n using sink_type =\n spdlog::sinks::daily_file_sink;\n\n prepare_logdir();\n\n // calculate filename (time based)\n spdlog::filename_t basename = SPDLOG_FILENAME_T(\"test_logs/daily_dateonly\");\n std::tm tm = spdlog::details::os::localtime();\n filename_memory_buf_t w;\n spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T(\"{}_{:04d}-{:02d}-{:02d}\"),\n basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);\n\n auto logger = spdlog::create(\"logger\", basename, 0, 0);\n for (int i = 0; i < 10; ++i) {\n logger->info(\"Test message {}\", i);\n }\n logger->flush();\n\n require_message_count(filename_buf_to_utf8string(w), 10);\n}\n\nstruct custom_daily_file_name_calculator {\n static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) {\n return spdlog::fmt_lib::format(SPDLOG_FILENAME_T(\"{}{:04d}{:02d}{:02d}\"), basename,\n now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday);\n }\n};\n\nTEST_CASE(\"daily_logger with custom calculator\", \"[daily_logger]\") {\n using sink_type = spdlog::sinks::daily_file_sink;\n\n prepare_logdir();\n\n // calculate filename (time based)\n spdlog::filename_t basename = SPDLOG_FILENAME_T(\"test_logs/daily_dateonly\");\n std::tm tm = spdlog::details::os::localtime();\n filename_memory_buf_t w;\n spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T(\"{}{:04d}{:02d}{:02d}\"),\n basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);\n\n auto logger = spdlog::create(\"logger\", basename, 0, 0);\n for (int i = 0; i < 10; ++i) {\n logger->info(\"Test message {}\", i);\n }\n\n logger->flush();\n\n require_message_count(filename_buf_to_utf8string(w), 10);\n}\n\n/*\n * File name calculations\n */\n\nTEST_CASE(\"rotating_file_sink::calc_filename1\", \"[rotating_file_sink]\") {\n auto filename =\n spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T(\"rotated.txt\"), 3);\n REQUIRE(filename == SPDLOG_FILENAME_T(\"rotated.3.txt\"));\n}\n\nTEST_CASE(\"rotating_file_sink::calc_filename2\", \"[rotating_file_sink]\") {\n auto filename =\n spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T(\"rotated\"), 3);\n REQUIRE(filename == SPDLOG_FILENAME_T(\"rotated.3\"));\n}\n\nTEST_CASE(\"rotating_file_sink::calc_filename3\", \"[rotating_file_sink]\") {\n auto filename =\n spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T(\"rotated.txt\"), 0);\n REQUIRE(filename == SPDLOG_FILENAME_T(\"rotated.txt\"));\n}\n\n// regex supported only from gcc 4.9 and above\n#if defined(_MSC_VER) || !(__GNUC__ <= 4 && __GNUC_MINOR__ < 9)\n\n#include \n\nTEST_CASE(\"daily_file_sink::daily_filename_calculator\", \"[daily_file_sink]\") {\n // daily_YYYY-MM-DD_hh-mm.txt\n auto filename = spdlog::sinks::daily_filename_calculator::calc_filename(\n SPDLOG_FILENAME_T(\"daily.txt\"), spdlog::details::os::localtime());\n // date regex based on https://www.regular-expressions.info/dates.html\n std::basic_regex re(\n SPDLOG_FILENAME_T(R\"(^daily_(19|20)\\d\\d-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])\\.txt$)\"));\n std::match_results match;\n REQUIRE(std::regex_match(filename, match, re));\n}\n#endif\n\nTEST_CASE(\"daily_file_sink::daily_filename_format_calculator\", \"[daily_file_sink]\") {\n std::tm tm = spdlog::details::os::localtime();\n // example-YYYY-MM-DD.log\n auto filename = spdlog::sinks::daily_filename_format_calculator::calc_filename(\n SPDLOG_FILENAME_T(\"example-%Y-%m-%d.log\"), tm);\n\n REQUIRE(filename ==\n spdlog::fmt_lib::format(SPDLOG_FILENAME_T(\"example-{:04d}-{:02d}-{:02d}.log\"),\n tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday));\n}\n\n/* Test removal of old files */\nstatic spdlog::details::log_msg create_msg(std::chrono::seconds offset) {\n using spdlog::log_clock;\n spdlog::details::log_msg msg{\"test\", spdlog::level::info, \"Hello Message\"};\n msg.time = log_clock::now() + offset;\n return msg;\n}\n\nstatic void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_files) {\n using spdlog::log_clock;\n using spdlog::details::log_msg;\n using spdlog::sinks::daily_file_sink_st;\n\n prepare_logdir();\n\n spdlog::filename_t basename = SPDLOG_FILENAME_T(\"test_logs/daily_rotate.txt\");\n daily_file_sink_st sink{basename, 2, 30, true, max_days};\n\n // simulate messages with 24 intervals\n\n for (int i = 0; i < days_to_run; i++) {\n auto offset = std::chrono::seconds{24 * 3600 * i};\n sink.log(create_msg(offset));\n }\n\n REQUIRE(count_files(\"test_logs\") == static_cast(expected_n_files));\n}\n\nTEST_CASE(\"daily_logger rotate\", \"[daily_file_sink]\") {\n int days_to_run = 1;\n test_rotate(days_to_run, 0, 1);\n test_rotate(days_to_run, 1, 1);\n test_rotate(days_to_run, 3, 1);\n test_rotate(days_to_run, 10, 1);\n\n days_to_run = 10;\n test_rotate(days_to_run, 0, 10);\n test_rotate(days_to_run, 1, 1);\n test_rotate(days_to_run, 3, 3);\n test_rotate(days_to_run, 9, 9);\n test_rotate(days_to_run, 10, 10);\n test_rotate(days_to_run, 11, 10);\n test_rotate(days_to_run, 20, 10);\n}\n" }, { "path": "tests/test_dup_filter.cpp", "content": "#include \"includes.h\"\n#include \"spdlog/sinks/dup_filter_sink.h\"\n#include \"test_sink.h\"\n\nTEST_CASE(\"dup_filter_test1\", \"[dup_filter_sink]\") {\n using spdlog::sinks::dup_filter_sink_st;\n using spdlog::sinks::test_sink_mt;\n\n dup_filter_sink_st dup_sink{std::chrono::seconds{5}};\n auto test_sink = std::make_shared();\n dup_sink.add_sink(test_sink);\n\n for (int i = 0; i < 10; i++) {\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n }\n\n REQUIRE(test_sink->msg_counter() == 1);\n}\n\nTEST_CASE(\"dup_filter_test2\", \"[dup_filter_sink]\") {\n using spdlog::sinks::dup_filter_sink_st;\n using spdlog::sinks::test_sink_mt;\n\n dup_filter_sink_st dup_sink{std::chrono::seconds{0}};\n auto test_sink = std::make_shared();\n dup_sink.add_sink(test_sink);\n\n for (int i = 0; i < 10; i++) {\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n std::this_thread::sleep_for(std::chrono::milliseconds(5));\n }\n\n REQUIRE(test_sink->msg_counter() == 10);\n}\n\nTEST_CASE(\"dup_filter_test3\", \"[dup_filter_sink]\") {\n using spdlog::sinks::dup_filter_sink_st;\n using spdlog::sinks::test_sink_mt;\n\n dup_filter_sink_st dup_sink{std::chrono::seconds{1}};\n auto test_sink = std::make_shared();\n dup_sink.add_sink(test_sink);\n\n for (int i = 0; i < 10; i++) {\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message2\"});\n }\n\n REQUIRE(test_sink->msg_counter() == 20);\n}\n\nTEST_CASE(\"dup_filter_test4\", \"[dup_filter_sink]\") {\n using spdlog::sinks::dup_filter_sink_mt;\n using spdlog::sinks::test_sink_mt;\n\n dup_filter_sink_mt dup_sink{std::chrono::milliseconds{10}};\n auto test_sink = std::make_shared();\n dup_sink.add_sink(test_sink);\n\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message\"});\n std::this_thread::sleep_for(std::chrono::milliseconds(50));\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message\"});\n REQUIRE(test_sink->msg_counter() == 2);\n}\n\nTEST_CASE(\"dup_filter_test5\", \"[dup_filter_sink]\") {\n using spdlog::sinks::dup_filter_sink_mt;\n using spdlog::sinks::test_sink_mt;\n\n dup_filter_sink_mt dup_sink{std::chrono::seconds{5}};\n auto test_sink = std::make_shared();\n test_sink->set_pattern(\"%v\");\n dup_sink.add_sink(test_sink);\n\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message1\"});\n dup_sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"message2\"});\n\n REQUIRE(test_sink->msg_counter() ==\n 3); // skip 2 messages but log the \"skipped..\" message before message2\n REQUIRE(test_sink->lines()[1] == \"Skipped 2 duplicate messages..\");\n}\n" }, { "path": "tests/test_errors.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n\n#include \n\n#define SIMPLE_LOG \"test_logs/simple_log.txt\"\n#define SIMPLE_ASYNC_LOG \"test_logs/simple_async_log.txt\"\n\nclass failing_sink : public spdlog::sinks::base_sink {\nprotected:\n void sink_it_(const spdlog::details::log_msg &) final {\n throw std::runtime_error(\"some error happened during log\");\n }\n\n void flush_() final { throw std::runtime_error(\"some error happened during flush\"); }\n};\nstruct custom_ex {};\n\n#if !defined(SPDLOG_USE_STD_FORMAT) // std format doesn't fully support runtime strings\nTEST_CASE(\"default_error_handler\", \"[errors]\") {\n prepare_logdir();\n spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);\n\n auto logger = spdlog::create(\"test-error\", filename, true);\n logger->set_pattern(\"%v\");\n logger->info(SPDLOG_FMT_RUNTIME(\"Test message {} {}\"), 1);\n logger->info(\"Test message {}\", 2);\n logger->flush();\n using spdlog::details::os::default_eol;\n REQUIRE(file_contents(SIMPLE_LOG) == spdlog::fmt_lib::format(\"Test message 2{}\", default_eol));\n REQUIRE(count_lines(SIMPLE_LOG) == 1);\n}\n\nTEST_CASE(\"custom_error_handler\", \"[errors]\") {\n prepare_logdir();\n spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);\n auto logger = spdlog::create(\"logger\", filename, true);\n logger->flush_on(spdlog::level::info);\n logger->set_error_handler([=](const std::string &) { throw custom_ex(); });\n logger->info(\"Good message #1\");\n\n REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME(\"Bad format msg {} {}\"), \"xxx\"), custom_ex);\n logger->info(\"Good message #2\");\n require_message_count(SIMPLE_LOG, 2);\n}\n#endif\n\nTEST_CASE(\"default_error_handler2\", \"[errors]\") {\n spdlog::drop_all();\n auto logger = spdlog::create(\"failed_logger\");\n logger->set_error_handler([=](const std::string &) { throw custom_ex(); });\n REQUIRE_THROWS_AS(logger->info(\"Some message\"), custom_ex);\n}\n\nTEST_CASE(\"flush_error_handler\", \"[errors]\") {\n spdlog::drop_all();\n auto logger = spdlog::create(\"failed_logger\");\n logger->set_error_handler([=](const std::string &) { throw custom_ex(); });\n REQUIRE_THROWS_AS(logger->flush(), custom_ex);\n}\n\n#if !defined(SPDLOG_USE_STD_FORMAT)\nTEST_CASE(\"async_error_handler\", \"[errors]\") {\n prepare_logdir();\n std::string err_msg(\"log failed with some msg\");\n\n spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG);\n {\n spdlog::init_thread_pool(128, 1);\n auto logger =\n spdlog::create_async(\"logger\", filename, true);\n logger->set_error_handler([=](const std::string &) {\n std::ofstream ofs(\"test_logs/custom_err.txt\");\n if (!ofs) {\n throw std::runtime_error(\"Failed open test_logs/custom_err.txt\");\n }\n ofs << err_msg;\n });\n logger->info(\"Good message #1\");\n logger->info(SPDLOG_FMT_RUNTIME(\"Bad format msg {} {}\"), \"xxx\");\n logger->info(\"Good message #2\");\n spdlog::drop(\"logger\"); // force logger to drain the queue and shutdown\n }\n spdlog::init_thread_pool(128, 1);\n require_message_count(SIMPLE_ASYNC_LOG, 2);\n REQUIRE(file_contents(\"test_logs/custom_err.txt\") == err_msg);\n}\n#endif\n\n// Make sure async error handler is executed\nTEST_CASE(\"async_error_handler2\", \"[errors]\") {\n prepare_logdir();\n std::string err_msg(\"This is async handler error message\");\n {\n spdlog::details::os::create_dir(SPDLOG_FILENAME_T(\"test_logs\"));\n spdlog::init_thread_pool(128, 1);\n auto logger = spdlog::create_async(\"failed_logger\");\n logger->set_error_handler([=](const std::string &) {\n std::ofstream ofs(\"test_logs/custom_err2.txt\");\n if (!ofs) throw std::runtime_error(\"Failed open test_logs/custom_err2.txt\");\n ofs << err_msg;\n });\n logger->info(\"Hello failure\");\n spdlog::drop(\"failed_logger\"); // force logger to drain the queue and shutdown\n }\n\n spdlog::init_thread_pool(128, 1);\n REQUIRE(file_contents(\"test_logs/custom_err2.txt\") == err_msg);\n}\n" }, { "path": "tests/test_eventlog.cpp", "content": "#if _WIN32\n\n#include \"includes.h\"\n#include \"test_sink.h\"\n\n#include \"spdlog/sinks/win_eventlog_sink.h\"\n\nstatic const LPCSTR TEST_SOURCE = \"spdlog_test\";\n\nstatic void test_single_print(std::function do_log,\n std::string const &expected_contents,\n WORD expected_ev_type) {\n using namespace std::chrono;\n do_log(expected_contents);\n const auto expected_time_generated =\n duration_cast(system_clock::now().time_since_epoch()).count();\n\n struct handle_t {\n HANDLE handle_;\n\n ~handle_t() {\n if (handle_) {\n REQUIRE(CloseEventLog(handle_));\n }\n }\n } event_log{::OpenEventLogA(nullptr, TEST_SOURCE)};\n\n REQUIRE(event_log.handle_);\n\n DWORD read_bytes{}, size_needed{};\n auto ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,\n 0, &read_bytes, 0, &read_bytes, &size_needed);\n REQUIRE(!ok);\n REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER);\n\n std::vector record_buffer(size_needed);\n PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data();\n\n ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0,\n record, size_needed, &read_bytes, &size_needed);\n REQUIRE(ok);\n\n REQUIRE(record->NumStrings == 1);\n REQUIRE(record->EventType == expected_ev_type);\n REQUIRE((expected_time_generated - record->TimeGenerated) <= 3u);\n\n std::string message_in_log(((char *)record + record->StringOffset));\n REQUIRE(message_in_log == expected_contents + spdlog::details::os::default_eol);\n}\n\nTEST_CASE(\"eventlog\", \"[eventlog]\") {\n using namespace spdlog;\n\n auto test_sink = std::make_shared(TEST_SOURCE);\n\n spdlog::logger test_logger(\"eventlog\", test_sink);\n test_logger.set_level(level::trace);\n\n test_sink->set_pattern(\"%v\");\n\n test_single_print([&test_logger](std::string const &msg) { test_logger.trace(msg); },\n \"my trace message\", EVENTLOG_SUCCESS);\n test_single_print([&test_logger](std::string const &msg) { test_logger.debug(msg); },\n \"my debug message\", EVENTLOG_SUCCESS);\n test_single_print([&test_logger](std::string const &msg) { test_logger.info(msg); },\n \"my info message\", EVENTLOG_INFORMATION_TYPE);\n test_single_print([&test_logger](std::string const &msg) { test_logger.warn(msg); },\n \"my warn message\", EVENTLOG_WARNING_TYPE);\n test_single_print([&test_logger](std::string const &msg) { test_logger.error(msg); },\n \"my error message\", EVENTLOG_ERROR_TYPE);\n test_single_print([&test_logger](std::string const &msg) { test_logger.critical(msg); },\n \"my critical message\", EVENTLOG_ERROR_TYPE);\n}\n\n#endif //_WIN32\n" }, { "path": "tests/test_file_helper.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n\n#define TEST_FILENAME \"test_logs/file_helper_test.txt\"\n\nusing spdlog::details::file_helper;\n\nstatic void write_with_helper(file_helper &helper, size_t howmany) {\n spdlog::memory_buf_t formatted;\n spdlog::fmt_lib::format_to(std::back_inserter(formatted), \"{}\", std::string(howmany, '1'));\n helper.write(formatted);\n helper.flush();\n}\n\nTEST_CASE(\"file_helper_filename\", \"[file_helper::filename()]\") {\n prepare_logdir();\n\n file_helper helper;\n spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n helper.open(target_filename);\n REQUIRE(helper.filename() == target_filename);\n}\n\nTEST_CASE(\"file_helper_size\", \"[file_helper::size()]\") {\n prepare_logdir();\n spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n size_t expected_size = 123;\n {\n file_helper helper;\n helper.open(target_filename);\n write_with_helper(helper, expected_size);\n REQUIRE(static_cast(helper.size()) == expected_size);\n }\n REQUIRE(get_filesize(TEST_FILENAME) == expected_size);\n}\n\nTEST_CASE(\"file_helper_reopen\", \"[file_helper::reopen()]\") {\n prepare_logdir();\n spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n file_helper helper;\n helper.open(target_filename);\n write_with_helper(helper, 12);\n REQUIRE(helper.size() == 12);\n helper.reopen(true);\n REQUIRE(helper.size() == 0);\n}\n\nTEST_CASE(\"file_helper_reopen2\", \"[file_helper::reopen(false)]\") {\n prepare_logdir();\n spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n size_t expected_size = 14;\n file_helper helper;\n helper.open(target_filename);\n write_with_helper(helper, expected_size);\n REQUIRE(helper.size() == expected_size);\n helper.reopen(false);\n REQUIRE(helper.size() == expected_size);\n}\n\nstatic void test_split_ext(const spdlog::filename_t::value_type *fname,\n const spdlog::filename_t::value_type *expect_base,\n const spdlog::filename_t::value_type *expect_ext) {\n spdlog::filename_t filename(fname);\n spdlog::filename_t expected_base(expect_base);\n spdlog::filename_t expected_ext(expect_ext);\n\n spdlog::filename_t basename;\n spdlog::filename_t ext;\n std::tie(basename, ext) = file_helper::split_by_extension(filename);\n REQUIRE(basename == expected_base);\n REQUIRE(ext == expected_ext);\n}\n\nTEST_CASE(\"file_helper_split_by_extension\", \"[file_helper::split_by_extension()]\") {\n test_split_ext(SPDLOG_FILENAME_T(\"mylog.txt\"), SPDLOG_FILENAME_T(\"mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\".mylog.txt\"), SPDLOG_FILENAME_T(\".mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\".mylog\"), SPDLOG_FILENAME_T(\".mylog\"), SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"/aaa/bb.d/mylog\"), SPDLOG_FILENAME_T(\"/aaa/bb.d/mylog\"),\n SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"/aaa/bb.d/mylog.txt\"), SPDLOG_FILENAME_T(\"/aaa/bb.d/mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"aaa/bbb/ccc/mylog.txt\"),\n SPDLOG_FILENAME_T(\"aaa/bbb/ccc/mylog\"), SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"aaa/bbb/ccc/mylog.\"), SPDLOG_FILENAME_T(\"aaa/bbb/ccc/mylog.\"),\n SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"aaa/bbb/ccc/.mylog.txt\"),\n SPDLOG_FILENAME_T(\"aaa/bbb/ccc/.mylog\"), SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"/aaa/bbb/ccc/mylog.txt\"),\n SPDLOG_FILENAME_T(\"/aaa/bbb/ccc/mylog\"), SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"/aaa/bbb/ccc/.mylog\"),\n SPDLOG_FILENAME_T(\"/aaa/bbb/ccc/.mylog\"), SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"../mylog.txt\"), SPDLOG_FILENAME_T(\"../mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\".././mylog.txt\"), SPDLOG_FILENAME_T(\".././mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\".././mylog.txt/xxx\"), SPDLOG_FILENAME_T(\".././mylog.txt/xxx\"),\n SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"/mylog.txt\"), SPDLOG_FILENAME_T(\"/mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"//mylog.txt\"), SPDLOG_FILENAME_T(\"//mylog\"),\n SPDLOG_FILENAME_T(\".txt\"));\n test_split_ext(SPDLOG_FILENAME_T(\"\"), SPDLOG_FILENAME_T(\"\"), SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\".\"), SPDLOG_FILENAME_T(\".\"), SPDLOG_FILENAME_T(\"\"));\n test_split_ext(SPDLOG_FILENAME_T(\"..txt\"), SPDLOG_FILENAME_T(\".\"), SPDLOG_FILENAME_T(\".txt\"));\n}\n\nTEST_CASE(\"file_event_handlers\", \"[file_helper]\") {\n enum class flags { before_open, after_open, before_close, after_close };\n prepare_logdir();\n\n spdlog::filename_t test_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n // define event handles that update vector of flags when called\n std::vector events;\n spdlog::file_event_handlers handlers;\n handlers.before_open = [&](spdlog::filename_t filename) {\n REQUIRE(filename == test_filename);\n events.push_back(flags::before_open);\n };\n handlers.after_open = [&](spdlog::filename_t filename, std::FILE *fstream) {\n REQUIRE(filename == test_filename);\n REQUIRE(fstream);\n fputs(\"after_open\\n\", fstream);\n events.push_back(flags::after_open);\n };\n handlers.before_close = [&](spdlog::filename_t filename, std::FILE *fstream) {\n REQUIRE(filename == test_filename);\n REQUIRE(fstream);\n fputs(\"before_close\\n\", fstream);\n events.push_back(flags::before_close);\n };\n handlers.after_close = [&](spdlog::filename_t filename) {\n REQUIRE(filename == test_filename);\n events.push_back(flags::after_close);\n };\n {\n spdlog::details::file_helper helper{handlers};\n REQUIRE(events.empty());\n\n helper.open(test_filename);\n REQUIRE(events == std::vector{flags::before_open, flags::after_open});\n\n events.clear();\n helper.close();\n REQUIRE(events == std::vector{flags::before_close, flags::after_close});\n REQUIRE(file_contents(TEST_FILENAME) == \"after_open\\nbefore_close\\n\");\n\n helper.reopen(true);\n events.clear();\n }\n // make sure that the file_helper destructor calls the close callbacks if needed\n REQUIRE(events == std::vector{flags::before_close, flags::after_close});\n REQUIRE(file_contents(TEST_FILENAME) == \"after_open\\nbefore_close\\n\");\n}\n\nTEST_CASE(\"file_helper_open\", \"[file_helper]\") {\n prepare_logdir();\n spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n file_helper helper;\n helper.open(target_filename);\n helper.close();\n\n target_filename += SPDLOG_FILENAME_T(\"/invalid\");\n REQUIRE_THROWS_AS(helper.open(target_filename), spdlog::spdlog_ex);\n}\n" }, { "path": "tests/test_file_logging.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n\n#define SIMPLE_LOG \"test_logs/simple_log\"\n#define ROTATING_LOG \"test_logs/rotating_log\"\n\nTEST_CASE(\"simple_file_logger\", \"[simple_logger]\") {\n prepare_logdir();\n spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);\n\n auto logger = spdlog::create(\"logger\", filename);\n logger->set_pattern(\"%v\");\n\n logger->info(\"Test message {}\", 1);\n logger->info(\"Test message {}\", 2);\n\n logger->flush();\n require_message_count(SIMPLE_LOG, 2);\n using spdlog::details::os::default_eol;\n REQUIRE(file_contents(SIMPLE_LOG) ==\n spdlog::fmt_lib::format(\"Test message 1{}Test message 2{}\", default_eol, default_eol));\n}\n\nTEST_CASE(\"flush_on\", \"[flush_on]\") {\n prepare_logdir();\n spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);\n\n auto logger = spdlog::create(\"logger\", filename);\n logger->set_pattern(\"%v\");\n logger->set_level(spdlog::level::trace);\n logger->flush_on(spdlog::level::info);\n logger->trace(\"Should not be flushed\");\n REQUIRE(count_lines(SIMPLE_LOG) == 0);\n\n logger->info(\"Test message {}\", 1);\n logger->info(\"Test message {}\", 2);\n\n require_message_count(SIMPLE_LOG, 3);\n using spdlog::details::os::default_eol;\n REQUIRE(file_contents(SIMPLE_LOG) ==\n spdlog::fmt_lib::format(\"Should not be flushed{}Test message 1{}Test message 2{}\",\n default_eol, default_eol, default_eol));\n}\n\nTEST_CASE(\"simple_file_logger\", \"[truncate]\") {\n prepare_logdir();\n const spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);\n const bool truncate = true;\n const auto sink = std::make_shared(filename, truncate);\n const auto logger = std::make_shared(\"simple_file_logger\", sink);\n\n logger->info(\"Test message {}\", 3.14);\n logger->info(\"Test message {}\", 2.71);\n logger->flush();\n REQUIRE(count_lines(SIMPLE_LOG) == 2);\n\n sink->truncate();\n REQUIRE(count_lines(SIMPLE_LOG) == 0);\n\n logger->info(\"Test message {}\", 6.28);\n logger->flush();\n REQUIRE(count_lines(SIMPLE_LOG) == 1);\n}\n\nTEST_CASE(\"rotating_file_logger1\", \"[rotating_logger]\") {\n prepare_logdir();\n size_t max_size = 1024 * 10;\n spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);\n auto logger = spdlog::rotating_logger_mt(\"logger\", basename, max_size, 0);\n\n for (int i = 0; i < 10; ++i) {\n logger->info(\"Test message {}\", i);\n }\n\n logger->flush();\n require_message_count(ROTATING_LOG, 10);\n}\n\nTEST_CASE(\"rotating_file_logger2\", \"[rotating_logger]\") {\n prepare_logdir();\n size_t max_size = 1024 * 10;\n spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);\n\n {\n // make an initial logger to create the first output file\n auto logger = spdlog::rotating_logger_mt(\"logger\", basename, max_size, 2, true);\n for (int i = 0; i < 10; ++i) {\n logger->info(\"Test message {}\", i);\n }\n // drop causes the logger destructor to be called, which is required so the\n // next logger can rename the first output file.\n spdlog::drop(logger->name());\n }\n auto logger = spdlog::rotating_logger_mt(\"logger\", basename, max_size, 2, true);\n for (int i = 0; i < 10; ++i) {\n logger->info(\"Test message {}\", i);\n }\n logger->flush();\n require_message_count(ROTATING_LOG, 10);\n\n for (int i = 0; i < 1000; i++) {\n logger->info(\"Test message {}\", i);\n }\n\n logger->flush();\n REQUIRE(get_filesize(ROTATING_LOG) <= max_size);\n REQUIRE(get_filesize(ROTATING_LOG \".1\") <= max_size);\n}\n\n// test that passing max_size=0 throws\nTEST_CASE(\"rotating_file_logger3\", \"[rotating_logger]\") {\n prepare_logdir();\n size_t max_size = 0;\n spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);\n REQUIRE_THROWS_AS(spdlog::rotating_logger_mt(\"logger\", basename, max_size, 0),\n spdlog::spdlog_ex);\n}\n\n// test on-demand rotation of logs\nTEST_CASE(\"rotating_file_logger4\", \"[rotating_logger]\") {\n prepare_logdir();\n size_t max_size = 1024 * 10;\n spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);\n auto sink = std::make_shared(basename, max_size, 2);\n auto logger = std::make_shared(\"rotating_sink_logger\", sink);\n\n logger->info(\"Test message - pre-rotation\");\n logger->flush();\n\n sink->rotate_now();\n\n logger->info(\"Test message - post-rotation\");\n logger->flush();\n\n REQUIRE(get_filesize(ROTATING_LOG) > 0);\n REQUIRE(get_filesize(ROTATING_LOG \".1\") > 0);\n}\n\n// test changing the max size of the rotating file sink\nTEST_CASE(\"rotating_file_logger5\", \"[rotating_logger]\") {\n prepare_logdir();\n size_t max_size = 5 * 1024;\n size_t max_files = 2;\n spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);\n auto sink =\n std::make_shared(basename, max_size, max_files);\n auto logger = std::make_shared(\"rotating_sink_logger\", sink);\n logger->set_pattern(\"%v\");\n\n REQUIRE(sink->get_max_size() == max_size);\n REQUIRE(sink->get_max_files() == max_files);\n max_size = 7 * 1024;\n max_files = 3;\n\n sink->set_max_size(max_size);\n sink->set_max_files(max_files);\n REQUIRE(sink->get_max_size() == max_size);\n REQUIRE(sink->get_max_files() == max_files);\n\n const auto message = std::string(200, 'x');\n assert(message.size() < max_size);\n const auto n_messages = max_files * max_size / message.size();\n for (size_t i = 0; i < n_messages; ++i) {\n logger->info(message);\n }\n logger.reset(); // force flush and close the file\n\n // validate that the files were rotated correctly with the new max size and max files\n for (size_t i = 0; i <= max_files; i++) {\n // calc filenames\n // e.g. rotating_log, rotating_log.0 rotating_log.1, rotating_log.2, etc.\n std::ostringstream oss;\n oss << ROTATING_LOG;\n if (i > 0) {\n oss << '.' << i;\n }\n const auto filename = oss.str();\n const auto filesize = get_filesize(filename);\n REQUIRE(filesize <= max_size);\n if (i > 0) {\n REQUIRE(filesize >= max_size - message.size() - 2);\n }\n }\n}\n" }, { "path": "tests/test_fmt_helper.cpp", "content": "\n#include \"includes.h\"\n\nusing spdlog::memory_buf_t;\n\nSPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)\n SPDLOG_NOEXCEPT {\n return spdlog::string_view_t{buf.data(), buf.size()};\n}\n\nvoid test_pad2(int n, const char *expected) {\n memory_buf_t buf;\n spdlog::details::fmt_helper::pad2(n, buf);\n\n REQUIRE(to_string_view(buf) == expected);\n}\n\nvoid test_pad3(uint32_t n, const char *expected) {\n memory_buf_t buf;\n spdlog::details::fmt_helper::pad3(n, buf);\n\n REQUIRE(to_string_view(buf) == expected);\n}\n\nvoid test_pad6(std::size_t n, const char *expected) {\n memory_buf_t buf;\n spdlog::details::fmt_helper::pad6(n, buf);\n\n REQUIRE(to_string_view(buf) == expected);\n}\n\nvoid test_pad9(std::size_t n, const char *expected) {\n memory_buf_t buf;\n spdlog::details::fmt_helper::pad9(n, buf);\n\n REQUIRE(to_string_view(buf) == expected);\n}\n\nTEST_CASE(\"pad2\", \"[fmt_helper]\") {\n test_pad2(0, \"00\");\n test_pad2(3, \"03\");\n test_pad2(10, \"10\");\n test_pad2(23, \"23\");\n test_pad2(99, \"99\");\n test_pad2(100, \"100\");\n test_pad2(123, \"123\");\n test_pad2(1234, \"1234\");\n test_pad2(-5, \"-5\");\n}\n\nTEST_CASE(\"pad3\", \"[fmt_helper]\") {\n test_pad3(0, \"000\");\n test_pad3(3, \"003\");\n test_pad3(10, \"010\");\n test_pad3(23, \"023\");\n test_pad3(99, \"099\");\n test_pad3(100, \"100\");\n test_pad3(123, \"123\");\n test_pad3(999, \"999\");\n test_pad3(1000, \"1000\");\n test_pad3(1234, \"1234\");\n}\n\nTEST_CASE(\"pad6\", \"[fmt_helper]\") {\n test_pad6(0, \"000000\");\n test_pad6(3, \"000003\");\n test_pad6(23, \"000023\");\n test_pad6(123, \"000123\");\n test_pad6(1234, \"001234\");\n test_pad6(12345, \"012345\");\n test_pad6(123456, \"123456\");\n}\n\nTEST_CASE(\"pad9\", \"[fmt_helper]\") {\n test_pad9(0, \"000000000\");\n test_pad9(3, \"000000003\");\n test_pad9(23, \"000000023\");\n test_pad9(123, \"000000123\");\n test_pad9(1234, \"000001234\");\n test_pad9(12345, \"000012345\");\n test_pad9(123456, \"000123456\");\n test_pad9(1234567, \"001234567\");\n test_pad9(12345678, \"012345678\");\n test_pad9(123456789, \"123456789\");\n test_pad9(1234567891, \"1234567891\");\n}\n" }, { "path": "tests/test_macros.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n\n#include \"includes.h\"\n\n#if SPDLOG_ACTIVE_LEVEL != SPDLOG_LEVEL_DEBUG\n#error \"Invalid SPDLOG_ACTIVE_LEVEL in test. Should be SPDLOG_LEVEL_DEBUG\"\n#endif\n\n#define TEST_FILENAME \"test_logs/simple_log\"\n\nTEST_CASE(\"debug and trace w/o format string\", \"[macros]\") {\n prepare_logdir();\n spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);\n\n auto logger = spdlog::create(\"logger\", filename);\n logger->set_pattern(\"%v\");\n logger->set_level(spdlog::level::trace);\n\n SPDLOG_LOGGER_TRACE(logger, \"Test message 1\");\n SPDLOG_LOGGER_DEBUG(logger, \"Test message 2\");\n logger->flush();\n\n using spdlog::details::os::default_eol;\n REQUIRE(ends_with(file_contents(TEST_FILENAME),\n spdlog::fmt_lib::format(\"Test message 2{}\", default_eol)));\n REQUIRE(count_lines(TEST_FILENAME) == 1);\n\n auto orig_default_logger = spdlog::default_logger();\n spdlog::set_default_logger(logger);\n\n SPDLOG_TRACE(\"Test message 3\");\n SPDLOG_DEBUG(\"Test message {}\", 4);\n logger->flush();\n\n require_message_count(TEST_FILENAME, 2);\n REQUIRE(ends_with(file_contents(TEST_FILENAME),\n spdlog::fmt_lib::format(\"Test message 4{}\", default_eol)));\n spdlog::set_default_logger(std::move(orig_default_logger));\n}\n\nTEST_CASE(\"disable param evaluation\", \"[macros]\") {\n SPDLOG_TRACE(\"Test message {}\", throw std::runtime_error(\"Should not be evaluated\"));\n}\n\nTEST_CASE(\"pass logger pointer\", \"[macros]\") {\n auto logger = spdlog::create(\"refmacro\");\n auto &ref = *logger;\n SPDLOG_LOGGER_TRACE(&ref, \"Test message 1\");\n SPDLOG_LOGGER_DEBUG(&ref, \"Test message 2\");\n}\n" }, { "path": "tests/test_misc.cpp", "content": "#ifdef _WIN32 // to prevent fopen warning on windows\n#define _CRT_SECURE_NO_WARNINGS\n#endif\n\n#include \"includes.h\"\n#include \"test_sink.h\"\n\ntemplate \nstd::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info) {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n\n spdlog::logger oss_logger(\"oss\", oss_sink);\n oss_logger.set_level(logger_level);\n oss_logger.set_pattern(\"%v\");\n oss_logger.info(what);\n\n return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));\n}\n\nTEST_CASE(\"basic_logging \", \"[basic_logging]\") {\n // const char\n REQUIRE(log_info(\"Hello\") == \"Hello\");\n REQUIRE(log_info(\"\").empty());\n\n // std::string\n REQUIRE(log_info(std::string(\"Hello\")) == \"Hello\");\n REQUIRE(log_info(std::string()).empty());\n\n // Numbers\n REQUIRE(log_info(5) == \"5\");\n REQUIRE(log_info(5.6) == \"5.6\");\n\n // User defined class\n // REQUIRE(log_info(some_logged_class(\"some_val\")) == \"some_val\");\n}\n\nTEST_CASE(\"log_levels\", \"[log_levels]\") {\n REQUIRE(log_info(\"Hello\", spdlog::level::err).empty());\n REQUIRE(log_info(\"Hello\", spdlog::level::critical).empty());\n REQUIRE(log_info(\"Hello\", spdlog::level::info) == \"Hello\");\n REQUIRE(log_info(\"Hello\", spdlog::level::debug) == \"Hello\");\n REQUIRE(log_info(\"Hello\", spdlog::level::trace) == \"Hello\");\n}\n\nTEST_CASE(\"level_to_string_view\", \"[convert_to_string_view]\") {\n REQUIRE(spdlog::level::to_string_view(spdlog::level::trace) == \"trace\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::debug) == \"debug\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::info) == \"info\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::warn) == \"warning\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::err) == \"error\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::critical) == \"critical\");\n REQUIRE(spdlog::level::to_string_view(spdlog::level::off) == \"off\");\n}\n\nTEST_CASE(\"to_short_c_str\", \"[convert_to_short_c_str]\") {\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::trace)) == \"T\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::debug)) == \"D\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::info)) == \"I\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::warn)) == \"W\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::err)) == \"E\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::critical)) == \"C\");\n REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::off)) == \"O\");\n}\n\nTEST_CASE(\"to_level_enum\", \"[convert_to_level_enum]\") {\n REQUIRE(spdlog::level::from_str(\"trace\") == spdlog::level::trace);\n REQUIRE(spdlog::level::from_str(\"debug\") == spdlog::level::debug);\n REQUIRE(spdlog::level::from_str(\"info\") == spdlog::level::info);\n REQUIRE(spdlog::level::from_str(\"warning\") == spdlog::level::warn);\n REQUIRE(spdlog::level::from_str(\"warn\") == spdlog::level::warn);\n REQUIRE(spdlog::level::from_str(\"error\") == spdlog::level::err);\n REQUIRE(spdlog::level::from_str(\"critical\") == spdlog::level::critical);\n REQUIRE(spdlog::level::from_str(\"off\") == spdlog::level::off);\n REQUIRE(spdlog::level::from_str(\"null\") == spdlog::level::off);\n REQUIRE(spdlog::level::from_str(\"TRACE\") == spdlog::level::trace);\n REQUIRE(spdlog::level::from_str(\"DEBUG\") == spdlog::level::debug);\n REQUIRE(spdlog::level::from_str(\"INFO\") == spdlog::level::info);\n REQUIRE(spdlog::level::from_str(\"WARNING\") == spdlog::level::warn);\n REQUIRE(spdlog::level::from_str(\"WARN\") == spdlog::level::warn);\n REQUIRE(spdlog::level::from_str(\"ERROR\") == spdlog::level::err);\n REQUIRE(spdlog::level::from_str(\"ERR\") == spdlog::level::err);\n REQUIRE(spdlog::level::from_str(\"CRITICAL\") == spdlog::level::critical);\n REQUIRE(spdlog::level::from_str(\"OFF\") == spdlog::level::off);\n REQUIRE(spdlog::level::from_str(\"TrAcE\") == spdlog::level::trace);\n REQUIRE(spdlog::level::from_str(\"DeBuG\") == spdlog::level::debug);\n}\n\nTEST_CASE(\"periodic flush\", \"[periodic_flush]\") {\n using spdlog::sinks::test_sink_mt;\n auto logger = spdlog::create(\"periodic_flush\");\n auto test_sink = std::static_pointer_cast(logger->sinks()[0]);\n\n spdlog::flush_every(std::chrono::seconds(1));\n std::this_thread::sleep_for(std::chrono::milliseconds(1250));\n REQUIRE(test_sink->flush_counter() == 1);\n spdlog::flush_every(std::chrono::seconds(0));\n spdlog::drop_all();\n}\n\nTEST_CASE(\"clone-logger\", \"[clone]\") {\n using spdlog::sinks::test_sink_mt;\n auto test_sink = std::make_shared();\n auto logger = std::make_shared(\"orig\", test_sink);\n logger->set_pattern(\"%v\");\n auto cloned = logger->clone(\"clone\");\n\n REQUIRE(cloned->name() == \"clone\");\n REQUIRE(logger->sinks() == cloned->sinks());\n REQUIRE(logger->level() == cloned->level());\n REQUIRE(logger->flush_level() == cloned->flush_level());\n logger->info(\"Some message 1\");\n cloned->info(\"Some message 2\");\n\n REQUIRE(test_sink->lines().size() == 2);\n REQUIRE(test_sink->lines()[0] == \"Some message 1\");\n REQUIRE(test_sink->lines()[1] == \"Some message 2\");\n\n spdlog::drop_all();\n}\n\nTEST_CASE(\"clone async\", \"[clone]\") {\n using spdlog::sinks::test_sink_mt;\n spdlog::init_thread_pool(4, 1);\n auto test_sink = std::make_shared();\n auto logger = std::make_shared(\"orig\", test_sink, spdlog::thread_pool());\n logger->set_pattern(\"%v\");\n auto cloned = logger->clone(\"clone\");\n\n REQUIRE(cloned->name() == \"clone\");\n REQUIRE(logger->sinks() == cloned->sinks());\n REQUIRE(logger->level() == cloned->level());\n REQUIRE(logger->flush_level() == cloned->flush_level());\n\n logger->info(\"Some message 1\");\n cloned->info(\"Some message 2\");\n\n spdlog::details::os::sleep_for_millis(100);\n\n REQUIRE(test_sink->lines().size() == 2);\n REQUIRE(test_sink->lines()[0] == \"Some message 1\");\n REQUIRE(test_sink->lines()[1] == \"Some message 2\");\n\n spdlog::drop_all();\n}\n\nTEST_CASE(\"default logger API\", \"[default logger]\") {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n\n spdlog::set_default_logger(std::make_shared(\"oss\", oss_sink));\n spdlog::set_pattern(\"*** %v\");\n\n spdlog::default_logger()->set_level(spdlog::level::trace);\n spdlog::trace(\"hello trace\");\n REQUIRE(oss.str() == \"*** hello trace\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::debug(\"hello debug\");\n REQUIRE(oss.str() == \"*** hello debug\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::info(\"Hello\");\n REQUIRE(oss.str() == \"*** Hello\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::warn(\"Hello again {}\", 2);\n REQUIRE(oss.str() == \"*** Hello again 2\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::error(123);\n REQUIRE(oss.str() == \"*** 123\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::critical(std::string(\"some string\"));\n REQUIRE(oss.str() == \"*** some string\" + std::string(spdlog::details::os::default_eol));\n\n oss.str(\"\");\n spdlog::set_level(spdlog::level::info);\n spdlog::debug(\"should not be logged\");\n REQUIRE(oss.str().empty());\n spdlog::drop_all();\n spdlog::set_pattern(\"%v\");\n}\n\n#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)\nTEST_CASE(\"utf8 to utf16 conversion using windows api\", \"[windows utf]\") {\n spdlog::wmemory_buf_t buffer;\n\n spdlog::details::os::utf8_to_wstrbuf(\"\", buffer);\n REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L\"\"));\n\n spdlog::details::os::utf8_to_wstrbuf(\"abc\", buffer);\n REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L\"abc\"));\n\n spdlog::details::os::utf8_to_wstrbuf(\"\\xc3\\x28\", buffer); // Invalid UTF-8 sequence.\n REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L\"\\xfffd(\"));\n\n spdlog::details::os::utf8_to_wstrbuf(\"\\xe3\\x81\\xad\\xe3\\x81\\x93\",\n buffer); // \"Neko\" in hiragana.\n REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L\"\\x306d\\x3053\"));\n}\n#endif\n\nstruct auto_closer {\n FILE* fp = nullptr;\n explicit auto_closer(FILE* f)\n : fp(f) {}\n auto_closer(const auto_closer&) = delete;\n auto_closer& operator=(const auto_closer&) = delete;\n ~auto_closer() {\n if (fp != nullptr) (void)std::fclose(fp);\n }\n};\n\nTEST_CASE(\"os::fwrite_bytes\", \"[os]\") {\n using spdlog::details::os::create_dir;\n using spdlog::details::os::fwrite_bytes;\n const char* filename = \"log_tests/test_fwrite_bytes.txt\";\n const char* msg = \"hello\";\n prepare_logdir();\n REQUIRE(create_dir(SPDLOG_FILENAME_T(\"log_tests\")) == true);\n {\n auto_closer closer(std::fopen(filename, \"wb\"));\n REQUIRE(closer.fp != nullptr);\n REQUIRE(fwrite_bytes(msg, std::strlen(msg), closer.fp) == true);\n REQUIRE(fwrite_bytes(msg, 0, closer.fp) == true);\n std::fflush(closer.fp);\n REQUIRE(spdlog::details::os::filesize(closer.fp) == 5);\n }\n // fwrite_bytes should return false on write failure\n auto_closer closer(std::fopen(filename, \"r\"));\n REQUIRE(closer.fp != nullptr);\n REQUIRE_FALSE(fwrite_bytes(\"Hello\", 5, closer.fp));\n}\n" }, { "path": "tests/test_mpmc_q.cpp", "content": "#include \"includes.h\"\n\nusing std::chrono::milliseconds;\nusing test_clock = std::chrono::high_resolution_clock;\n\nstatic milliseconds millis_from(const test_clock::time_point &tp0) {\n return std::chrono::duration_cast(test_clock::now() - tp0);\n}\nTEST_CASE(\"dequeue-empty-nowait\", \"[mpmc_blocking_q]\") {\n size_t q_size = 100;\n milliseconds tolerance_wait(20);\n spdlog::details::mpmc_blocking_queue q(q_size);\n int popped_item = 0;\n\n auto start = test_clock::now();\n auto rv = q.dequeue_for(popped_item, milliseconds::zero());\n auto delta_ms = millis_from(start);\n\n REQUIRE(rv == false);\n INFO(\"Delta \" << delta_ms.count() << \" millis\");\n REQUIRE(delta_ms <= tolerance_wait);\n}\n\nTEST_CASE(\"dequeue-empty-wait\", \"[mpmc_blocking_q]\") {\n size_t q_size = 100;\n milliseconds wait_ms(250);\n milliseconds tolerance_wait(250);\n\n spdlog::details::mpmc_blocking_queue q(q_size);\n int popped_item = 0;\n auto start = test_clock::now();\n auto rv = q.dequeue_for(popped_item, wait_ms);\n auto delta_ms = millis_from(start);\n\n REQUIRE(rv == false);\n\n INFO(\"Delta \" << delta_ms.count() << \" millis\");\n REQUIRE(delta_ms >= wait_ms - tolerance_wait);\n REQUIRE(delta_ms <= wait_ms + tolerance_wait);\n}\n\nTEST_CASE(\"dequeue-full-nowait\", \"[mpmc_blocking_q]\") {\n spdlog::details::mpmc_blocking_queue q(1);\n q.enqueue(42);\n\n int item = 0;\n q.dequeue_for(item, milliseconds::zero());\n REQUIRE(item == 42);\n}\n\nTEST_CASE(\"dequeue-full-wait\", \"[mpmc_blocking_q]\") {\n spdlog::details::mpmc_blocking_queue q(1);\n q.enqueue(42);\n\n int item = 0;\n q.dequeue(item);\n REQUIRE(item == 42);\n}\n\nTEST_CASE(\"enqueue_nowait\", \"[mpmc_blocking_q]\") {\n size_t q_size = 1;\n spdlog::details::mpmc_blocking_queue q(q_size);\n milliseconds tolerance_wait(10);\n\n q.enqueue(1);\n REQUIRE(q.overrun_counter() == 0);\n\n auto start = test_clock::now();\n q.enqueue_nowait(2);\n auto delta_ms = millis_from(start);\n\n INFO(\"Delta \" << delta_ms.count() << \" millis\");\n REQUIRE(delta_ms <= tolerance_wait);\n REQUIRE(q.overrun_counter() == 1);\n}\n\nTEST_CASE(\"bad_queue\", \"[mpmc_blocking_q]\") {\n size_t q_size = 0;\n spdlog::details::mpmc_blocking_queue q(q_size);\n q.enqueue_nowait(1);\n REQUIRE(q.overrun_counter() == 1);\n int i = 0;\n REQUIRE(q.dequeue_for(i, milliseconds(0)) == false);\n}\n\nTEST_CASE(\"empty_queue\", \"[mpmc_blocking_q]\") {\n size_t q_size = 10;\n spdlog::details::mpmc_blocking_queue q(q_size);\n int i = 0;\n REQUIRE(q.dequeue_for(i, milliseconds(10)) == false);\n}\n\nTEST_CASE(\"full_queue\", \"[mpmc_blocking_q]\") {\n size_t q_size = 100;\n spdlog::details::mpmc_blocking_queue q(q_size);\n for (int i = 0; i < static_cast(q_size); i++) {\n q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we\n // std::move(i) instead\n }\n\n q.enqueue_nowait(123456);\n REQUIRE(q.overrun_counter() == 1);\n\n for (int i = 1; i < static_cast(q_size); i++) {\n int item = -1;\n q.dequeue(item);\n REQUIRE(item == i);\n }\n\n // last item pushed has overridden the oldest.\n int item = -1;\n q.dequeue(item);\n REQUIRE(item == 123456);\n}\n" }, { "path": "tests/test_pattern_formatter.cpp", "content": "#include \"includes.h\"\n#include \"test_sink.h\"\n#include \n#include \n\nusing spdlog::memory_buf_t;\n\nSPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)\n SPDLOG_NOEXCEPT {\n return spdlog::string_view_t{buf.data(), buf.size()};\n}\n\n// log to str and return it\ntemplate \nstatic std::string log_to_str(const std::string &msg, const Args &...args) {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"pattern_tester\", oss_sink);\n oss_logger.set_level(spdlog::level::info);\n\n oss_logger.set_formatter(\n std::unique_ptr(new spdlog::pattern_formatter(args...)));\n\n oss_logger.info(msg);\n return oss.str();\n}\n\n// log to str and return it with time\ntemplate \nstatic std::string log_to_str_with_time(spdlog::log_clock::time_point log_time,\n const std::string &msg,\n const Args &...args) {\n std::ostringstream oss;\n auto oss_sink = std::make_shared(oss);\n spdlog::logger oss_logger(\"pattern_tester\", oss_sink);\n oss_logger.set_level(spdlog::level::info);\n\n oss_logger.set_formatter(\n std::unique_ptr(new spdlog::pattern_formatter(args...)));\n\n oss_logger.log(log_time, {}, spdlog::level::info, msg);\n return oss.str();\n}\n\nTEST_CASE(\"custom eol\", \"[pattern_formatter]\") {\n std::string msg = \"Hello custom eol test\";\n std::string eol = \";)\";\n REQUIRE(log_to_str(msg, \"%v\", spdlog::pattern_time_type::local, \";)\") == msg + eol);\n}\n\nTEST_CASE(\"empty format\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"\", spdlog::pattern_time_type::local, \"\").empty());\n}\n\nTEST_CASE(\"empty format2\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"\", spdlog::pattern_time_type::local, \"\\n\") == \"\\n\");\n}\n\nTEST_CASE(\"level\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[info] Some message\\n\");\n}\n\nTEST_CASE(\"short level\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[I] Some message\\n\");\n}\n\nTEST_CASE(\"name\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester] Some message\\n\");\n}\n\nTEST_CASE(\"date MM/DD/YY \", \"[pattern_formatter]\") {\n auto now_tm = spdlog::details::os::localtime();\n std::stringstream oss;\n oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << \"/\" << std::setw(2)\n << now_tm.tm_mday << \"/\" << std::setw(2) << (now_tm.tm_year + 1900) % 1000\n << \" Some message\\n\";\n REQUIRE(log_to_str(\"Some message\", \"%D %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n oss.str());\n}\n\n// see test_timezone.cpp for actual UTC offset calculation tests\nTEST_CASE(\"UTC offset\", \"[pattern_formatter]\") {\n using namespace std::chrono_literals;\n const auto now = std::chrono::system_clock::now();\n std::string result =\n log_to_str_with_time(now, \"Some message\", \"%z\", spdlog::pattern_time_type::local, \"\\n\");\n\n#ifndef SPDLOG_NO_TZ_OFFSET\n // Match format: +HH:MM or -HH:MM\n std::regex re(R\"([+-]\\d{2}:[0-5]\\d\\n)\");\n REQUIRE(std::regex_match(result, re));\n#else\n REQUIRE(result == \"+??:??\\n\");\n#endif\n}\n\nTEST_CASE(\"color range test1\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared(\n \"%^%v%$\", spdlog::pattern_time_type::local, \"\\n\");\n\n memory_buf_t buf;\n spdlog::fmt_lib::format_to(std::back_inserter(buf), \"Hello\");\n memory_buf_t formatted;\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info,\n spdlog::string_view_t(buf.data(), buf.size()));\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 0);\n REQUIRE(msg.color_range_end == 5);\n REQUIRE(log_to_str(\"hello\", \"%^%v%$\", spdlog::pattern_time_type::local, \"\\n\") == \"hello\\n\");\n}\n\nTEST_CASE(\"color range test2\", \"[pattern_formatter]\") {\n auto formatter =\n std::make_shared(\"%^%$\", spdlog::pattern_time_type::local, \"\\n\");\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 0);\n REQUIRE(msg.color_range_end == 0);\n REQUIRE(log_to_str(\"\", \"%^%$\", spdlog::pattern_time_type::local, \"\\n\") == \"\\n\");\n}\n\nTEST_CASE(\"color range test3\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared(\"%^***%$\");\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"ignored\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 0);\n REQUIRE(msg.color_range_end == 3);\n}\n\nTEST_CASE(\"color range test4\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared(\n \"XX%^YYY%$\", spdlog::pattern_time_type::local, \"\\n\");\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"ignored\");\n\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 2);\n REQUIRE(msg.color_range_end == 5);\n REQUIRE(log_to_str(\"ignored\", \"XX%^YYY%$\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"XXYYY\\n\");\n}\n\nTEST_CASE(\"color range test5\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared(\"**%^\");\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"ignored\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 2);\n REQUIRE(msg.color_range_end == 0);\n}\n\nTEST_CASE(\"color range test6\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared(\"**%$\");\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"ignored\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n REQUIRE(msg.color_range_start == 0);\n REQUIRE(msg.color_range_end == 2);\n}\n\n//\n// Test padding\n//\n\nTEST_CASE(\"level_left_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%8l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ info] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%8!l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ info] Some message\\n\");\n}\n\nTEST_CASE(\"level_right_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%-8l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[info ] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%-8!l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[info ] Some message\\n\");\n}\n\nTEST_CASE(\"level_center_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%=8l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ info ] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%=8!l] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ info ] Some message\\n\");\n}\n\nTEST_CASE(\"short level_left_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%3L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ I] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%3!L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ I] Some message\\n\");\n}\n\nTEST_CASE(\"short level_right_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%-3L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[I ] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%-3!L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[I ] Some message\\n\");\n}\n\nTEST_CASE(\"short level_center_padded\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%=3L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ I ] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%=3!L] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[ I ] Some message\\n\");\n}\n\nTEST_CASE(\"left_padded_short\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%3n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%3!n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pat] Some message\\n\");\n}\n\nTEST_CASE(\"right_padded_short\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%-3n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%-3!n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pat] Some message\\n\");\n}\n\nTEST_CASE(\"center_padded_short\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%=3n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester] Some message\\n\");\n REQUIRE(log_to_str(\"Some message\", \"[%=3!n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pat] Some message\\n\");\n}\n\nTEST_CASE(\"left_padded_huge\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%-300n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester ] Some message\\n\");\n\n REQUIRE(log_to_str(\"Some message\", \"[%-300!n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester ] Some message\\n\");\n}\n\nTEST_CASE(\"left_padded_max\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"Some message\", \"[%-64n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester ] Some message\\n\");\n\n REQUIRE(log_to_str(\"Some message\", \"[%-64!n] %v\", spdlog::pattern_time_type::local, \"\\n\") ==\n \"[pattern_tester ] Some message\\n\");\n}\n\n// Test padding + truncate flag\n\nTEST_CASE(\"paddinng_truncate\", \"[pattern_formatter]\") {\n REQUIRE(log_to_str(\"123456\", \"%6!v\", spdlog::pattern_time_type::local, \"\\n\") == \"123456\\n\");\n REQUIRE(log_to_str(\"123456\", \"%5!v\", spdlog::pattern_time_type::local, \"\\n\") == \"12345\\n\");\n REQUIRE(log_to_str(\"123456\", \"%7!v\", spdlog::pattern_time_type::local, \"\\n\") == \" 123456\\n\");\n\n REQUIRE(log_to_str(\"123456\", \"%-6!v\", spdlog::pattern_time_type::local, \"\\n\") == \"123456\\n\");\n REQUIRE(log_to_str(\"123456\", \"%-5!v\", spdlog::pattern_time_type::local, \"\\n\") == \"12345\\n\");\n REQUIRE(log_to_str(\"123456\", \"%-7!v\", spdlog::pattern_time_type::local, \"\\n\") == \"123456 \\n\");\n\n REQUIRE(log_to_str(\"123456\", \"%=6!v\", spdlog::pattern_time_type::local, \"\\n\") == \"123456\\n\");\n REQUIRE(log_to_str(\"123456\", \"%=5!v\", spdlog::pattern_time_type::local, \"\\n\") == \"12345\\n\");\n REQUIRE(log_to_str(\"123456\", \"%=7!v\", spdlog::pattern_time_type::local, \"\\n\") == \"123456 \\n\");\n\n REQUIRE(log_to_str(\"123456\", \"%0!v\", spdlog::pattern_time_type::local, \"\\n\") == \"\\n\");\n}\n\nTEST_CASE(\"padding_truncate_funcname\", \"[pattern_formatter]\") {\n spdlog::sinks::test_sink_st test_sink;\n\n const char *pattern = \"%v [%5!!]\";\n auto formatter = std::unique_ptr(new spdlog::pattern_formatter(pattern));\n test_sink.set_formatter(std::move(formatter));\n\n spdlog::details::log_msg msg1{spdlog::source_loc{\"ignored\", 1, \"func\"}, \"test_logger\",\n spdlog::level::info, \"message\"};\n test_sink.log(msg1);\n REQUIRE(test_sink.lines()[0] == \"message [ func]\");\n\n spdlog::details::log_msg msg2{spdlog::source_loc{\"ignored\", 1, \"function\"}, \"test_logger\",\n spdlog::level::info, \"message\"};\n test_sink.log(msg2);\n REQUIRE(test_sink.lines()[1] == \"message [funct]\");\n}\n\nTEST_CASE(\"padding_funcname\", \"[pattern_formatter]\") {\n spdlog::sinks::test_sink_st test_sink;\n\n const char *pattern = \"%v [%10!]\";\n auto formatter = std::unique_ptr(new spdlog::pattern_formatter(pattern));\n test_sink.set_formatter(std::move(formatter));\n\n spdlog::details::log_msg msg1{spdlog::source_loc{\"ignored\", 1, \"func\"}, \"test_logger\",\n spdlog::level::info, \"message\"};\n test_sink.log(msg1);\n REQUIRE(test_sink.lines()[0] == \"message [ func]\");\n\n spdlog::details::log_msg msg2{spdlog::source_loc{\"ignored\", 1, \"func567890123\"}, \"test_logger\",\n spdlog::level::info, \"message\"};\n test_sink.log(msg2);\n REQUIRE(test_sink.lines()[1] == \"message [func567890123]\");\n}\n\nTEST_CASE(\"clone-default-formatter\", \"[pattern_formatter]\") {\n auto formatter_1 = std::make_shared();\n auto formatter_2 = formatter_1->clone();\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"some message\");\n\n memory_buf_t formatted_1;\n memory_buf_t formatted_2;\n formatter_1->format(msg, formatted_1);\n formatter_2->format(msg, formatted_2);\n\n REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));\n}\n\nTEST_CASE(\"clone-default-formatter2\", \"[pattern_formatter]\") {\n auto formatter_1 = std::make_shared(\"%+\");\n auto formatter_2 = formatter_1->clone();\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"some message\");\n\n memory_buf_t formatted_1;\n memory_buf_t formatted_2;\n formatter_1->format(msg, formatted_1);\n formatter_2->format(msg, formatted_2);\n\n REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));\n}\n\nTEST_CASE(\"clone-formatter\", \"[pattern_formatter]\") {\n auto formatter_1 = std::make_shared(\"%D %X [%] [%n] %v\");\n auto formatter_2 = formatter_1->clone();\n std::string logger_name = \"test\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"some message\");\n\n memory_buf_t formatted_1;\n memory_buf_t formatted_2;\n formatter_1->format(msg, formatted_1);\n formatter_2->format(msg, formatted_2);\n\n REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));\n}\n\nTEST_CASE(\"clone-formatter-2\", \"[pattern_formatter]\") {\n using spdlog::pattern_time_type;\n auto formatter_1 = std::make_shared(\n \"%D %X [%] [%n] %v\", pattern_time_type::utc, \"xxxxxx\\n\");\n auto formatter_2 = formatter_1->clone();\n std::string logger_name = \"test2\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"some message\");\n\n memory_buf_t formatted_1;\n memory_buf_t formatted_2;\n formatter_1->format(msg, formatted_1);\n formatter_2->format(msg, formatted_2);\n\n REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));\n}\n\nclass custom_test_flag : public spdlog::custom_flag_formatter {\npublic:\n explicit custom_test_flag(std::string txt)\n : some_txt{std::move(txt)} {}\n\n void format(const spdlog::details::log_msg &,\n const std::tm &tm,\n spdlog::memory_buf_t &dest) override {\n if (some_txt == \"throw_me\") {\n throw spdlog::spdlog_ex(\"custom_flag_exception_test\");\n } else if (some_txt == \"time\") {\n auto formatted = spdlog::fmt_lib::format(\"{:d}:{:02d}{:s}\", tm.tm_hour % 12, tm.tm_min,\n tm.tm_hour / 12 ? \"PM\" : \"AM\");\n dest.append(formatted.data(), formatted.data() + formatted.size());\n return;\n }\n some_txt = std::string(padinfo_.width_, ' ') + some_txt;\n dest.append(some_txt.data(), some_txt.data() + some_txt.size());\n }\n spdlog::details::padding_info get_padding_info() { return padinfo_; }\n\n std::string some_txt;\n\n std::unique_ptr clone() const override {\n return spdlog::details::make_unique(some_txt);\n }\n};\n// test clone with custom flag formatters\nTEST_CASE(\"clone-custom_formatter\", \"[pattern_formatter]\") {\n auto formatter_1 = std::make_shared();\n formatter_1->add_flag('t', \"custom_output\").set_pattern(\"[%n] [%t] %v\");\n auto formatter_2 = formatter_1->clone();\n std::string logger_name = \"logger-name\";\n spdlog::details::log_msg msg(logger_name, spdlog::level::info, \"some message\");\n\n memory_buf_t formatted_1;\n memory_buf_t formatted_2;\n formatter_1->format(msg, formatted_1);\n formatter_2->format(msg, formatted_2);\n\n auto expected = spdlog::fmt_lib::format(\"[logger-name] [custom_output] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted_1) == expected);\n REQUIRE(to_string_view(formatted_2) == expected);\n}\n\n//\n// Test source location formatting\n//\n\n#ifdef _WIN32\nstatic const char *const test_path = \"\\\\a\\\\b\\\\c/myfile.cpp\";\n#else\nstatic const char *const test_path = \"/a/b//myfile.cpp\";\n#endif\n\nTEST_CASE(\"short filename formatter-1\", \"[pattern_formatter]\") {\n spdlog::pattern_formatter formatter(\"%s\", spdlog::pattern_time_type::local, \"\");\n memory_buf_t formatted;\n std::string logger_name = \"logger-name\";\n spdlog::source_loc source_loc{test_path, 123, \"some_func()\"};\n spdlog::details::log_msg msg(source_loc, \"logger-name\", spdlog::level::info, \"Hello\");\n formatter.format(msg, formatted);\n\n REQUIRE(to_string_view(formatted) == \"myfile.cpp\");\n}\n\nTEST_CASE(\"short filename formatter-2\", \"[pattern_formatter]\") {\n spdlog::pattern_formatter formatter(\"%s:%#\", spdlog::pattern_time_type::local, \"\");\n memory_buf_t formatted;\n std::string logger_name = \"logger-name\";\n spdlog::source_loc source_loc{\"myfile.cpp\", 123, \"some_func()\"};\n spdlog::details::log_msg msg(source_loc, \"logger-name\", spdlog::level::info, \"Hello\");\n formatter.format(msg, formatted);\n\n REQUIRE(to_string_view(formatted) == \"myfile.cpp:123\");\n}\n\nTEST_CASE(\"short filename formatter-3\", \"[pattern_formatter]\") {\n spdlog::pattern_formatter formatter(\"%s %v\", spdlog::pattern_time_type::local, \"\");\n memory_buf_t formatted;\n std::string logger_name = \"logger-name\";\n spdlog::source_loc source_loc{\"\", 123, \"some_func()\"};\n spdlog::details::log_msg msg(source_loc, \"logger-name\", spdlog::level::info, \"Hello\");\n formatter.format(msg, formatted);\n\n REQUIRE(to_string_view(formatted) == \" Hello\");\n}\n\nTEST_CASE(\"full filename formatter\", \"[pattern_formatter]\") {\n spdlog::pattern_formatter formatter(\"%g\", spdlog::pattern_time_type::local, \"\");\n memory_buf_t formatted;\n std::string logger_name = \"logger-name\";\n spdlog::source_loc source_loc{test_path, 123, \"some_func()\"};\n spdlog::details::log_msg msg(source_loc, \"logger-name\", spdlog::level::info, \"Hello\");\n formatter.format(msg, formatted);\n\n REQUIRE(to_string_view(formatted) == test_path);\n}\n\nTEST_CASE(\"custom flags\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared();\n formatter->add_flag('t', \"custom1\")\n .add_flag('u', \"custom2\")\n .set_pattern(\"[%n] [%t] [%u] %v\");\n\n memory_buf_t formatted;\n\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n auto expected = spdlog::fmt_lib::format(\"[logger-name] [custom1] [custom2] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted) == expected);\n}\n\nTEST_CASE(\"custom flags-padding\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared();\n formatter->add_flag('t', \"custom1\")\n .add_flag('u', \"custom2\")\n .set_pattern(\"[%n] [%t] [%5u] %v\");\n\n memory_buf_t formatted;\n\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n auto expected = spdlog::fmt_lib::format(\"[logger-name] [custom1] [ custom2] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted) == expected);\n}\n\nTEST_CASE(\"custom flags-exception\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared();\n formatter->add_flag('t', \"throw_me\")\n .add_flag('u', \"custom2\")\n .set_pattern(\"[%n] [%t] [%u] %v\");\n\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n CHECK_THROWS_AS(formatter->format(msg, formatted), spdlog::spdlog_ex);\n}\n\nTEST_CASE(\"override need_localtime\", \"[pattern_formatter]\") {\n auto formatter =\n std::make_shared(spdlog::pattern_time_type::local, \"\\n\");\n formatter->add_flag('t', \"time\").set_pattern(\"%t> %v\");\n\n {\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n REQUIRE(to_string_view(formatted) == \"0:00AM> some message\\n\");\n }\n\n {\n formatter->need_localtime();\n\n auto now_tm = spdlog::details::os::localtime();\n std::stringstream oss;\n oss << (now_tm.tm_hour % 12) << \":\" << std::setfill('0') << std::setw(2) << now_tm.tm_min\n << (now_tm.tm_hour / 12 ? \"PM\" : \"AM\") << \"> some message\\n\";\n\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n REQUIRE(to_string_view(formatted) == oss.str());\n }\n}\n\n#ifndef SPDLOG_NO_TLS\nTEST_CASE(\"mdc formatter test-1\", \"[pattern_formatter]\") {\n spdlog::mdc::put(\"mdc_key_1\", \"mdc_value_1\");\n spdlog::mdc::put(\"mdc_key_2\", \"mdc_value_2\");\n\n auto formatter = std::make_shared();\n formatter->set_pattern(\"[%n] [%l] [%&] %v\");\n\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n\n auto expected = spdlog::fmt_lib::format(\n \"[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}\",\n spdlog::details::os::default_eol);\n REQUIRE(to_string_view(formatted) == expected);\n\n SECTION(\"Tear down\") { spdlog::mdc::clear(); }\n}\n\nTEST_CASE(\"mdc formatter value update\", \"[pattern_formatter]\") {\n spdlog::mdc::put(\"mdc_key_1\", \"mdc_value_1\");\n spdlog::mdc::put(\"mdc_key_2\", \"mdc_value_2\");\n\n auto formatter = std::make_shared();\n formatter->set_pattern(\"[%n] [%l] [%&] %v\");\n\n memory_buf_t formatted_1;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted_1);\n\n auto expected = spdlog::fmt_lib::format(\n \"[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted_1) == expected);\n\n spdlog::mdc::put(\"mdc_key_1\", \"new_mdc_value_1\");\n memory_buf_t formatted_2;\n formatter->format(msg, formatted_2);\n expected = spdlog::fmt_lib::format(\n \"[logger-name] [info] [mdc_key_1:new_mdc_value_1 mdc_key_2:mdc_value_2] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted_2) == expected);\n\n SECTION(\"Tear down\") { spdlog::mdc::clear(); }\n}\n\nTEST_CASE(\"mdc different threads\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared();\n formatter->set_pattern(\"[%n] [%l] [%&] %v\");\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n\n memory_buf_t formatted_2;\n\n auto lambda_1 = [formatter, msg]() {\n spdlog::mdc::put(\"mdc_key\", \"thread_1_id\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n\n auto expected =\n spdlog::fmt_lib::format(\"[logger-name] [info] [mdc_key:thread_1_id] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted) == expected);\n };\n\n auto lambda_2 = [formatter, msg]() {\n spdlog::mdc::put(\"mdc_key\", \"thread_2_id\");\n memory_buf_t formatted;\n formatter->format(msg, formatted);\n\n auto expected =\n spdlog::fmt_lib::format(\"[logger-name] [info] [mdc_key:thread_2_id] some message{}\",\n spdlog::details::os::default_eol);\n\n REQUIRE(to_string_view(formatted) == expected);\n };\n\n std::thread thread_1(lambda_1);\n std::thread thread_2(lambda_2);\n\n thread_1.join();\n thread_2.join();\n\n SECTION(\"Tear down\") { spdlog::mdc::clear(); }\n}\n\nTEST_CASE(\"mdc remove key\", \"[pattern_formatter]\") {\n spdlog::mdc::put(\"mdc_key_1\", \"mdc_value_1\");\n spdlog::mdc::put(\"mdc_key_2\", \"mdc_value_2\");\n spdlog::mdc::remove(\"mdc_key_1\");\n\n auto formatter = std::make_shared();\n formatter->set_pattern(\"[%n] [%l] [%&] %v\");\n\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n\n auto expected =\n spdlog::fmt_lib::format(\"[logger-name] [info] [mdc_key_2:mdc_value_2] some message{}\",\n spdlog::details::os::default_eol);\n REQUIRE(to_string_view(formatted) == expected);\n\n SECTION(\"Tear down\") { spdlog::mdc::clear(); }\n}\n\nTEST_CASE(\"mdc empty\", \"[pattern_formatter]\") {\n auto formatter = std::make_shared();\n formatter->set_pattern(\"[%n] [%l] [%&] %v\");\n\n memory_buf_t formatted;\n spdlog::details::log_msg msg(spdlog::source_loc{}, \"logger-name\", spdlog::level::info,\n \"some message\");\n formatter->format(msg, formatted);\n\n auto expected = spdlog::fmt_lib::format(\"[logger-name] [info] [] some message{}\",\n spdlog::details::os::default_eol);\n REQUIRE(to_string_view(formatted) == expected);\n\n SECTION(\"Tear down\") { spdlog::mdc::clear(); }\n}\n#endif\n" }, { "path": "tests/test_registry.cpp", "content": "#include \"includes.h\"\n\nstatic const char *const tested_logger_name = \"null_logger\";\nstatic const char *const tested_logger_name2 = \"null_logger2\";\n\n#ifndef SPDLOG_NO_EXCEPTIONS\nTEST_CASE(\"register_drop\", \"[registry]\") {\n spdlog::drop_all();\n spdlog::create(tested_logger_name);\n REQUIRE(spdlog::get(tested_logger_name) != nullptr);\n // Throw if registering existing name\n REQUIRE_THROWS_AS(spdlog::create(tested_logger_name),\n spdlog::spdlog_ex);\n}\n\nTEST_CASE(\"explicit register\", \"[registry]\") {\n spdlog::drop_all();\n auto logger = std::make_shared(tested_logger_name,\n std::make_shared());\n spdlog::register_logger(logger);\n REQUIRE(spdlog::get(tested_logger_name) != nullptr);\n // Throw if registering existing name\n REQUIRE_THROWS_AS(spdlog::create(tested_logger_name),\n spdlog::spdlog_ex);\n}\n#endif\n\nTEST_CASE(\"register_or_replace\", \"[registry]\") {\n spdlog::drop_all();\n auto logger1 = std::make_shared(\n tested_logger_name, std::make_shared());\n spdlog::register_logger(logger1);\n REQUIRE(spdlog::get(tested_logger_name) == logger1);\n\n auto logger2 = std::make_shared(\n tested_logger_name, std::make_shared());\n spdlog::register_or_replace(logger2);\n REQUIRE(spdlog::get(tested_logger_name) == logger2);\n}\n\nTEST_CASE(\"apply_all\", \"[registry]\") {\n spdlog::drop_all();\n auto logger = std::make_shared(tested_logger_name,\n std::make_shared());\n spdlog::register_logger(logger);\n auto logger2 = std::make_shared(\n tested_logger_name2, std::make_shared());\n spdlog::register_logger(logger2);\n\n int counter = 0;\n spdlog::apply_all([&counter](std::shared_ptr) { counter++; });\n REQUIRE(counter == 2);\n\n counter = 0;\n spdlog::drop(tested_logger_name2);\n spdlog::apply_all([&counter](std::shared_ptr l) {\n REQUIRE(l->name() == tested_logger_name);\n counter++;\n });\n REQUIRE(counter == 1);\n}\n\nTEST_CASE(\"drop\", \"[registry]\") {\n spdlog::drop_all();\n spdlog::create(tested_logger_name);\n spdlog::drop(tested_logger_name);\n REQUIRE_FALSE(spdlog::get(tested_logger_name));\n}\n\nTEST_CASE(\"drop-default\", \"[registry]\") {\n spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));\n spdlog::drop(tested_logger_name);\n REQUIRE_FALSE(spdlog::default_logger());\n REQUIRE_FALSE(spdlog::get(tested_logger_name));\n}\n\nTEST_CASE(\"drop_all\", \"[registry]\") {\n spdlog::drop_all();\n spdlog::create(tested_logger_name);\n spdlog::create(tested_logger_name2);\n spdlog::drop_all();\n REQUIRE_FALSE(spdlog::get(tested_logger_name));\n REQUIRE_FALSE(spdlog::get(tested_logger_name2));\n REQUIRE_FALSE(spdlog::default_logger());\n}\n\nTEST_CASE(\"drop non existing\", \"[registry]\") {\n spdlog::drop_all();\n spdlog::create(tested_logger_name);\n spdlog::drop(\"some_name\");\n REQUIRE_FALSE(spdlog::get(\"some_name\"));\n REQUIRE(spdlog::get(tested_logger_name));\n spdlog::drop_all();\n}\n\nTEST_CASE(\"default logger\", \"[registry]\") {\n spdlog::drop_all();\n spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));\n REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger());\n spdlog::drop_all();\n}\n\nTEST_CASE(\"set_default_logger(nullptr)\", \"[registry]\") {\n spdlog::set_default_logger(nullptr);\n REQUIRE_FALSE(spdlog::default_logger());\n}\n\nTEST_CASE(\"disable automatic registration\", \"[registry]\") {\n // set some global parameters\n spdlog::level::level_enum log_level = spdlog::level::level_enum::warn;\n spdlog::set_level(log_level);\n // but disable automatic registration\n spdlog::set_automatic_registration(false);\n auto logger1 = spdlog::create(\n tested_logger_name, SPDLOG_FILENAME_T(\"filename\"), 11, 59);\n auto logger2 = spdlog::create_async(tested_logger_name2);\n // loggers should not be part of the registry\n REQUIRE_FALSE(spdlog::get(tested_logger_name));\n REQUIRE_FALSE(spdlog::get(tested_logger_name2));\n // but make sure they are still initialized according to global defaults\n REQUIRE(logger1->level() == log_level);\n REQUIRE(logger2->level() == log_level);\n spdlog::set_level(spdlog::level::info);\n spdlog::set_automatic_registration(true);\n}\n" }, { "path": "tests/test_ringbuffer.cpp", "content": "#include \"includes.h\"\n#include \"spdlog/sinks/ringbuffer_sink.h\"\n\nTEST_CASE(\"ringbuffer invalid size\", \"[ringbuffer]\") {\n REQUIRE_THROWS_AS(spdlog::sinks::ringbuffer_sink_mt(0), spdlog::spdlog_ex);\n}\n\nTEST_CASE(\"ringbuffer stores formatted messages\", \"[ringbuffer]\") {\n spdlog::sinks::ringbuffer_sink_st sink(3);\n sink.set_pattern(\"%v\");\n\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"msg1\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"msg2\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"msg3\"});\n\n auto formatted = sink.last_formatted();\n REQUIRE(formatted.size() == 3);\n using spdlog::details::os::default_eol;\n REQUIRE(formatted[0] == spdlog::fmt_lib::format(\"msg1{}\", default_eol));\n REQUIRE(formatted[1] == spdlog::fmt_lib::format(\"msg2{}\", default_eol));\n REQUIRE(formatted[2] == spdlog::fmt_lib::format(\"msg3{}\", default_eol));\n}\n\nTEST_CASE(\"ringbuffer overrun keeps last items\", \"[ringbuffer]\") {\n spdlog::sinks::ringbuffer_sink_st sink(2);\n sink.set_pattern(\"%v\");\n\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"first\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"second\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"third\"});\n\n auto formatted = sink.last_formatted();\n REQUIRE(formatted.size() == 2);\n using spdlog::details::os::default_eol;\n REQUIRE(formatted[0] == spdlog::fmt_lib::format(\"second{}\", default_eol));\n REQUIRE(formatted[1] == spdlog::fmt_lib::format(\"third{}\", default_eol));\n}\n\nTEST_CASE(\"ringbuffer retrieval limit\", \"[ringbuffer]\") {\n spdlog::sinks::ringbuffer_sink_st sink(3);\n sink.set_pattern(\"%v\");\n\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"A\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"B\"});\n sink.log(spdlog::details::log_msg{\"test\", spdlog::level::info, \"C\"});\n\n auto formatted = sink.last_formatted(2);\n REQUIRE(formatted.size() == 2);\n using spdlog::details::os::default_eol;\n REQUIRE(formatted[0] == spdlog::fmt_lib::format(\"B{}\", default_eol));\n REQUIRE(formatted[1] == spdlog::fmt_lib::format(\"C{}\", default_eol));\n}\n" }, { "path": "tests/test_sink.h", "content": "//\n// Copyright(c) 2018 Gabi Melman.\n// Distributed under the MIT License (http://opensource.org/licenses/MIT)\n//\n\n#pragma once\n\n#include \"spdlog/details/null_mutex.h\"\n#include \"spdlog/sinks/base_sink.h\"\n#include \"spdlog/fmt/fmt.h\"\n#include \n#include \n#include \n\nnamespace spdlog {\nnamespace sinks {\n\ntemplate \nclass test_sink : public base_sink {\n const size_t lines_to_save = 100;\n\npublic:\n size_t msg_counter() {\n std::lock_guard lock(base_sink::mutex_);\n return msg_counter_;\n }\n\n size_t flush_counter() {\n std::lock_guard lock(base_sink::mutex_);\n return flush_counter_;\n }\n\n void set_delay(std::chrono::milliseconds delay) {\n std::lock_guard lock(base_sink::mutex_);\n delay_ = delay;\n }\n\n // return last output without the eol\n std::vector lines() {\n std::lock_guard lock(base_sink::mutex_);\n return lines_;\n }\n\nprotected:\n void sink_it_(const details::log_msg &msg) override {\n memory_buf_t formatted;\n base_sink::formatter_->format(msg, formatted);\n // save the line without the eol\n auto eol_len = strlen(details::os::default_eol);\n using diff_t = typename std::iterator_traits::difference_type;\n if (lines_.size() < lines_to_save) {\n lines_.emplace_back(formatted.begin(), formatted.end() - static_cast(eol_len));\n }\n msg_counter_++;\n std::this_thread::sleep_for(delay_);\n }\n\n void flush_() override { flush_counter_++; }\n\n size_t msg_counter_{0};\n size_t flush_counter_{0};\n std::chrono::milliseconds delay_{std::chrono::milliseconds::zero()};\n std::vector lines_;\n};\n\nusing test_sink_mt = test_sink;\nusing test_sink_st = test_sink;\n\n} // namespace sinks\n} // namespace spdlog\n" }, { "path": "tests/test_stdout_api.cpp", "content": "/*\n * This content is released under the MIT License as specified in\n * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE\n */\n#include \"includes.h\"\n#include \"spdlog/sinks/stdout_sinks.h\"\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n\nTEST_CASE(\"stdout_st\", \"[stdout]\") {\n auto l = spdlog::stdout_logger_st(\"test\");\n l->set_pattern(\"%+\");\n l->set_level(spdlog::level::trace);\n l->trace(\"Test stdout_st\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stdout_mt\", \"[stdout]\") {\n auto l = spdlog::stdout_logger_mt(\"test\");\n l->set_pattern(\"%+\");\n l->set_level(spdlog::level::debug);\n l->debug(\"Test stdout_mt\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stderr_st\", \"[stderr]\") {\n auto l = spdlog::stderr_logger_st(\"test\");\n l->set_pattern(\"%+\");\n l->info(\"Test stderr_st\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stderr_mt\", \"[stderr]\") {\n auto l = spdlog::stderr_logger_mt(\"test\");\n l->set_pattern(\"%+\");\n l->info(\"Test stderr_mt\");\n l->warn(\"Test stderr_mt\");\n l->error(\"Test stderr_mt\");\n l->critical(\"Test stderr_mt\");\n spdlog::drop_all();\n}\n\n// color loggers\nTEST_CASE(\"stdout_color_st\", \"[stdout]\") {\n auto l = spdlog::stdout_color_st(\"test\");\n l->set_pattern(\"%+\");\n l->info(\"Test stdout_color_st\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stdout_color_mt\", \"[stdout]\") {\n auto l = spdlog::stdout_color_mt(\"test\");\n l->set_pattern(\"%+\");\n l->set_level(spdlog::level::trace);\n l->trace(\"Test stdout_color_mt\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stderr_color_st\", \"[stderr]\") {\n auto l = spdlog::stderr_color_st(\"test\");\n l->set_pattern(\"%+\");\n l->set_level(spdlog::level::debug);\n l->debug(\"Test stderr_color_st\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"stderr_color_mt\", \"[stderr]\") {\n auto l = spdlog::stderr_color_mt(\"test\");\n l->set_pattern(\"%+\");\n l->info(\"Test stderr_color_mt\");\n l->warn(\"Test stderr_color_mt\");\n l->error(\"Test stderr_color_mt\");\n l->critical(\"Test stderr_color_mt\");\n spdlog::drop_all();\n}\n\nTEST_CASE(\"show_utc_offset\", \"[stdout]\") {\n auto l = spdlog::stdout_color_mt(\"test\");\n l->set_pattern(\"[%c %z] [%n] [%^%l%$] %v\");\n l->info(\"Full date\");\n spdlog::drop_all();\n}\n\n#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT\nTEST_CASE(\"wchar_api\", \"[stdout]\") {\n auto l = spdlog::stdout_logger_st(\"wchar_logger\");\n l->set_pattern(\"%+\");\n l->set_level(spdlog::level::trace);\n l->trace(L\"Test wchar_api\");\n l->trace(L\"Test wchar_api {}\", L\"param\");\n l->trace(L\"Test wchar_api {}\", 1);\n l->trace(L\"Test wchar_api {}\", std::wstring{L\"wstring param\"});\n l->trace(std::wstring{L\"Test wchar_api wstring\"});\n SPDLOG_LOGGER_DEBUG(l, L\"Test SPDLOG_LOGGER_DEBUG {}\", L\"param\");\n spdlog::drop_all();\n}\n#endif\n" }, { "path": "tests/test_stopwatch.cpp", "content": "#include \"includes.h\"\n#include \"test_sink.h\"\n#include \"spdlog/stopwatch.h\"\n\nTEST_CASE(\"stopwatch1\", \"[stopwatch]\") {\n using std::chrono::milliseconds;\n using clock = std::chrono::steady_clock;\n milliseconds wait_ms(500);\n milliseconds tolerance_ms(250);\n auto start = clock::now();\n spdlog::stopwatch sw;\n std::this_thread::sleep_for(wait_ms);\n auto stop = clock::now();\n auto diff_ms = std::chrono::duration_cast(stop - start);\n REQUIRE(sw.elapsed() >= diff_ms);\n REQUIRE(sw.elapsed() <= diff_ms + tolerance_ms);\n}\n\nTEST_CASE(\"stopwatch2\", \"[stopwatch]\") {\n using spdlog::sinks::test_sink_st;\n using std::chrono::duration_cast;\n using std::chrono::milliseconds;\n using clock = std::chrono::steady_clock;\n\n clock::duration wait_duration(milliseconds(500));\n clock::duration tolerance_duration(milliseconds(250));\n\n auto test_sink = std::make_shared();\n\n auto start = clock::now();\n spdlog::stopwatch sw;\n spdlog::logger logger(\"test-stopwatch\", test_sink);\n logger.set_pattern(\"%v\");\n std::this_thread::sleep_for(wait_duration);\n auto stop = clock::now();\n logger.info(\"{}\", sw);\n auto val = std::stod(test_sink->lines()[0]);\n auto diff_duration = duration_cast>(stop - start);\n\n REQUIRE(val >= (diff_duration).count() - 0.001);\n REQUIRE(val <= (diff_duration + tolerance_duration).count());\n}\n" }, { "path": "tests/test_systemd.cpp", "content": "#include \"includes.h\"\n#include \"spdlog/sinks/systemd_sink.h\"\n\nTEST_CASE(\"systemd\", \"[all]\") {\n auto systemd_sink = std::make_shared();\n spdlog::logger logger(\"spdlog_systemd_test\", systemd_sink);\n logger.set_level(spdlog::level::trace);\n logger.trace(\"test spdlog trace\");\n logger.debug(\"test spdlog debug\");\n SPDLOG_LOGGER_INFO((&logger), \"test spdlog info\");\n SPDLOG_LOGGER_WARN((&logger), \"test spdlog warn\");\n SPDLOG_LOGGER_ERROR((&logger), \"test spdlog error\");\n SPDLOG_LOGGER_CRITICAL((&logger), \"test spdlog critical\");\n}\n" }, { "path": "tests/test_time_point.cpp", "content": "#include \"includes.h\"\n#include \"test_sink.h\"\n#include \"spdlog/async.h\"\n\nTEST_CASE(\"time_point1\", \"[time_point log_msg]\") {\n std::shared_ptr test_sink(new spdlog::sinks::test_sink_st);\n spdlog::logger logger(\"test-time_point\", test_sink);\n\n spdlog::source_loc source{};\n std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()};\n test_sink->set_pattern(\"%T.%F\"); // interested in the time_point\n\n // all the following should have the same time\n test_sink->set_delay(std::chrono::milliseconds(10));\n for (int i = 0; i < 5; i++) {\n spdlog::details::log_msg msg{tp, source, \"test_logger\", spdlog::level::info, \"message\"};\n test_sink->log(msg);\n }\n\n logger.log(tp, source, spdlog::level::info, \"formatted message\");\n logger.log(tp, source, spdlog::level::info, \"formatted message\");\n logger.log(tp, source, spdlog::level::info, \"formatted message\");\n logger.log(tp, source, spdlog::level::info, \"formatted message\");\n logger.log(source, spdlog::level::info,\n \"formatted message\"); // last line has different time_point\n\n // now the real test... that the times are the same.\n std::vector lines = test_sink->lines();\n REQUIRE(lines[0] == lines[1]);\n REQUIRE(lines[2] == lines[3]);\n REQUIRE(lines[4] == lines[5]);\n REQUIRE(lines[6] == lines[7]);\n REQUIRE(lines[8] != lines[9]);\n spdlog::drop_all();\n}\n" }, { "path": "tests/test_timezone.cpp", "content": "#ifndef SPDLOG_NO_TZ_OFFSET\n\n#include \"includes.h\"\n#include \n#include \n#include \n\n// Helper to construct a simple std::tm from components\nstd::tm make_tm(int year, int month, int day, int hour, int minute) {\n std::tm t;\n std::memset(&t, 0, sizeof(t));\n t.tm_year = year - 1900;\n t.tm_mon = month - 1;\n t.tm_mday = day;\n t.tm_hour = hour;\n t.tm_min = minute;\n t.tm_sec = 0;\n t.tm_isdst = -1;\n std::mktime(&t);\n return t;\n}\n\n// Cross-platform RAII Helper to safely set/restore process timezone\nclass ScopedTZ {\n std::string original_tz_;\n bool has_original_ = false;\n\npublic:\n explicit ScopedTZ(const std::string& tz_name) {\n // save current TZ\n#ifdef _WIN32\n char* buf = nullptr;\n size_t len = 0;\n if (_dupenv_s(&buf, &len, \"TZ\") == 0 && buf != nullptr) {\n original_tz_ = std::string(buf);\n has_original_ = true;\n free(buf);\n }\n#else\n const char* tz = std::getenv(\"TZ\");\n if (tz) {\n original_tz_ = tz;\n has_original_ = true;\n }\n#endif\n\n // set new TZ\n#ifdef _WIN32\n _putenv_s(\"TZ\", tz_name.c_str());\n _tzset();\n#else\n setenv(\"TZ\", tz_name.c_str(), 1);\n tzset();\n#endif\n }\n\n ~ScopedTZ() {\n // restore original TZ\n#ifdef _WIN32\n if (has_original_) {\n _putenv_s(\"TZ\", original_tz_.c_str());\n } else {\n _putenv_s(\"TZ\", \"\");\n }\n _tzset();\n#else\n if (has_original_) {\n setenv(\"TZ\", original_tz_.c_str(), 1);\n } else {\n unsetenv(\"TZ\");\n }\n tzset();\n#endif\n }\n};\n\nusing spdlog::details::os::utc_minutes_offset;\n\n/*\n * POSIX 2024 defines three formats for the TZ environment variable,\n *\n * 1. Implementation defined format which always starts with a colon:\n * \":characters\".\n * 2. A specifier which fully describes the timezone rule in format\n * \"stdoffset[dst[offset][,start[/time],end[/time]]]\". Note the\n * offset and start/end part could be omitted, in which case one hour\n * is implied, or it's considered implementation-defined when changing\n * to and from Daylight Saving Time occurs.\n * 3. Geographical or special timezone from an implementation-defined\n * timezone database.\n *\n * On POSIX-compilant systems, we prefer format 2, and explicitly specify the\n * DST rules to avoid implementation-defined behavior.\n *\n * See also IEEE 1003.1-2024 8.3 Other Environment Variables.\n */\n#ifndef _WIN32\n/*\n * Standard time is UTC-5 (\"EST\"), DST time is UTC-4 (\"EDT\"). DST is active\n * from 2:00 on the 2nd Sunday in March, to 2:00 on 1st Sunday in November.\n */\n#define EST5EDT \"EST5EDT,M3.2.0,M11.1.0\"\n/*\n * Standard time is UTC+2 (\"IST\"), DST time is UTC+3 (\"IDT\"). DST is active\n * from 2:00 on following day of the 4th Thursday in March, to 2:00 on the\n * last Sunday in October.\n */\n#define IST_MINUS2_IDT \"IST-2IDT,M3.4.4/26,M10.5.0\"\n#else\n/*\n * However, Windows doesn't follow the POSIX rules and only accept a TZ\n * environment variable in format\n *\n * tzn [+|-]hh[:mm[:ss] ][dzn]\n *\n * thus we couldn't specify the DST rules. Luckily, Windows C runtime library\n * assumes the United State's rules for implementing the calculation of DST,\n * which is fine for our test cases.\n *\n * See also https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/tzset?view=msvc-170\n */\n#define EST5EDT \"EST5EDT\"\n#define IST_MINUS2_IDT \"IST-2IDT\"\n#endif\n\nTEST_CASE(\"UTC Offset - Western Hemisphere (USA - Standard Time)\", \"[timezone][west]\") {\n // EST5EDT: Eastern Standard Time (UTC-5)\n ScopedTZ tz(EST5EDT);\n\n // Jan 15th (Winter)\n auto tm = make_tm(2023, 1, 15, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == -300);\n}\n\nTEST_CASE(\"UTC Offset - Eastern Hemisphere (Europe/Israel - Standard Time)\", \"[timezone][east]\") {\n // IST-2IDT: Israel Standard Time (UTC+2)\n ScopedTZ tz(IST_MINUS2_IDT);\n\n // Jan 15th (Winter)\n auto tm = make_tm(2023, 1, 15, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == 120);\n}\n\nTEST_CASE(\"UTC Offset - Zero Offset (UTC/GMT)\", \"[timezone][utc]\") {\n ScopedTZ tz(\"GMT0\");\n\n // Check Winter\n auto tm_winter = make_tm(2023, 1, 15, 12, 0);\n REQUIRE(utc_minutes_offset(tm_winter) == 0);\n\n // Check Summer (GMT never shifts, so this should also be 0)\n auto tm_summer = make_tm(2023, 7, 15, 12, 0);\n REQUIRE(utc_minutes_offset(tm_summer) == 0);\n}\n\nTEST_CASE(\"UTC Offset - Non-Integer Hour Offsets (India)\", \"[timezone][partial]\") {\n // IST-5:30: India Standard Time (UTC+5:30)\n ScopedTZ tz(\"IST-5:30\");\n\n auto tm = make_tm(2023, 1, 15, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == 330);\n}\n\nTEST_CASE(\"UTC Offset - Edge Case: Negative Offset Crossing Midnight\", \"[timezone][edge]\") {\n ScopedTZ tz(EST5EDT);\n // Late night Dec 31st, 2023\n auto tm = make_tm(2023, 12, 31, 23, 59);\n REQUIRE(utc_minutes_offset(tm) == -300);\n}\n\nTEST_CASE(\"UTC Offset - Edge Case: Leap Year\", \"[timezone][edge]\") {\n ScopedTZ tz(EST5EDT);\n // Feb 29, 2024 (Leap Day) - Winter\n auto tm = make_tm(2024, 2, 29, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == -300);\n}\n\nTEST_CASE(\"UTC Offset - Edge Case: Invalid Date (Pre-Epoch)\", \"[timezone][edge]\") {\n#ifdef _WIN32\n // Windows mktime returns -1 for dates before 1970.\n // We expect the function to safely return 0 (fallback).\n auto tm = make_tm(1960, 1, 1, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == 0);\n#else\n // Unix mktime handles pre-1970 dates correctly.\n // We expect the actual historical offset (EST was UTC-5 in 1960).\n ScopedTZ tz(EST5EDT);\n auto tm = make_tm(1960, 1, 1, 12, 0);\n REQUIRE(utc_minutes_offset(tm) == -300);\n#endif\n}\n\n#endif // !SPDLOG_NO_TZ_OFFSET\n" }, { "path": "tests/utils.cpp", "content": "#include \"includes.h\"\n\n#ifdef _WIN32\n#include \n#else\n#include \n#include \n#endif\n\nvoid prepare_logdir() {\n spdlog::drop_all();\n#ifdef _WIN32\n system(\"rmdir /S /Q test_logs\");\n#else\n auto rv = system(\"rm -rf test_logs\");\n if (rv != 0) {\n throw std::runtime_error(\"Failed to rm -rf test_logs\");\n }\n#endif\n}\n\nstd::string file_contents(const std::string &filename) {\n std::ifstream ifs(filename, std::ios_base::binary);\n if (!ifs) {\n throw std::runtime_error(\"Failed open file \");\n }\n return std::string((std::istreambuf_iterator(ifs)), (std::istreambuf_iterator()));\n}\n\nstd::size_t count_lines(const std::string &filename) {\n std::ifstream ifs(filename);\n if (!ifs) {\n throw std::runtime_error(\"Failed open file \");\n }\n\n std::string line;\n size_t counter = 0;\n while (std::getline(ifs, line)) counter++;\n return counter;\n}\n\nvoid require_message_count(const std::string &filename, const std::size_t messages) {\n if (strlen(spdlog::details::os::default_eol) == 0) {\n REQUIRE(count_lines(filename) == 1);\n } else {\n REQUIRE(count_lines(filename) == messages);\n }\n}\n\nstd::size_t get_filesize(const std::string &filename) {\n std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);\n if (!ifs) {\n throw std::runtime_error(\"Failed open file \" + filename);\n }\n return static_cast(ifs.tellg());\n}\n\n// source: https://stackoverflow.com/a/2072890/192001\nbool ends_with(std::string const &value, std::string const &ending) {\n if (ending.size() > value.size()) {\n return false;\n }\n return std::equal(ending.rbegin(), ending.rend(), value.rbegin());\n}\n\n#ifdef _WIN32\n// Based on: https://stackoverflow.com/a/37416569/192001\nstd::size_t count_files(const std::string &folder) {\n size_t counter = 0;\n WIN32_FIND_DATAA ffd;\n\n // Start iterating over the files in the folder directory.\n HANDLE hFind = ::FindFirstFileA((folder + \"\\\\*\").c_str(), &ffd);\n if (hFind != INVALID_HANDLE_VALUE) {\n do // Managed to locate and create an handle to that folder.\n {\n if (ffd.cFileName[0] != '.') counter++;\n } while (::FindNextFileA(hFind, &ffd) != 0);\n ::FindClose(hFind);\n } else {\n throw std::runtime_error(\"Failed open folder \" + folder);\n }\n\n return counter;\n}\n#else\n// Based on: https://stackoverflow.com/a/2802255/192001\nstd::size_t count_files(const std::string &folder) {\n size_t counter = 0;\n DIR *dp = opendir(folder.c_str());\n if (dp == nullptr) {\n throw std::runtime_error(\"Failed open folder \" + folder);\n }\n\n struct dirent *ep = nullptr;\n while ((ep = readdir(dp)) != nullptr) {\n if (ep->d_name[0] != '.') counter++;\n }\n (void)closedir(dp);\n return counter;\n}\n#endif\n" }, { "path": "tests/utils.h", "content": "#pragma once\n\n#include \n#include \n\nstd::size_t count_files(const std::string &folder);\n\nvoid prepare_logdir();\n\nstd::string file_contents(const std::string &filename);\n\nstd::size_t count_lines(const std::string &filename);\n\nvoid require_message_count(const std::string &filename, const std::size_t messages);\n\nstd::size_t get_filesize(const std::string &filename);\n\nbool ends_with(std::string const &value, std::string const &ending);" } ]