├── .gitignore
├── docs
    ├── terminal_colors.png
    └── index.html
├── glog_example
    ├── build_and_run.sh
    ├── main.cpp
    ├── glog_example.hpp
    └── CMakeLists.txt
├── loguru_example
    ├── build_and_run.sh
    ├── main.cpp
    ├── loguru_example.hpp
    └── CMakeLists.txt
├── glog_bench
    ├── build_and_run.sh
    ├── CMakeLists.txt
    └── glog_bench.cpp
├── loguru_bench
    ├── build_and_run.sh
    ├── CMakeLists.txt
    └── loguru_bench.cpp
├── appveyor.yml
├── cmake
    ├── loguru-config.cmake.in
    ├── loguru.pc.in
    ├── utilities.cmake
    └── loguru-cpack.cmake
├── test
    ├── build.sh
    ├── fail_test_wrapper.cmake
    ├── build_and_run.sh
    ├── build_and_run.cmake
    ├── appveyor.cmake
    ├── CMakeLists.txt
    └── loguru_test.cpp
├── lnav_format_loguru_cpp.json
├── LICENSE
├── loguru_cmake_example
    └── CMakeLists.txt
├── README.md
├── CMakeLists.txt
└── loguru.hpp


/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | *.sublime-workspace
3 | 


--------------------------------------------------------------------------------
/docs/terminal_colors.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/emilk/loguru/HEAD/docs/terminal_colors.png


--------------------------------------------------------------------------------
/glog_example/build_and_run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | cd "$ROOT_DIR"
 7 | mkdir -p build
 8 | cd build
 9 | cmake ..
10 | make
11 | 
12 | ./glog_example $@
13 | 


--------------------------------------------------------------------------------
/loguru_example/build_and_run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | cd "$ROOT_DIR"
 7 | mkdir -p build
 8 | cd build
 9 | cmake ..
10 | make
11 | 
12 | ./loguru_example $@
13 | 


--------------------------------------------------------------------------------
/glog_bench/build_and_run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | cd "$ROOT_DIR"
 7 | mkdir -p build
 8 | cd build
 9 | cmake ..
10 | make
11 | 
12 | ./glog_bench $@ 2>/dev/null
13 | 


--------------------------------------------------------------------------------
/loguru_bench/build_and_run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | cd "$ROOT_DIR"
 7 | mkdir -p build
 8 | cd build
 9 | cmake ..
10 | make
11 | 
12 | ./loguru_bench $@ 2>/dev/null
13 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | version: 0.1.{build}-{branch}
 2 | pull_requests:
 3 |   do_not_increment_build_number: true
 4 | 
 5 | image:
 6 |   - Ubuntu
 7 |   - Visual Studio 2017
 8 | 
 9 | # loguru is header-only
10 | build: off
11 | 
12 | test_script: cmake -P test/appveyor.cmake
13 | 


--------------------------------------------------------------------------------
/loguru_example/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include "loguru_example.hpp"
 4 | 
 5 | #include "../loguru.cpp"
 6 | 
 7 | int main(int argc, char* argv[])
 8 | {
 9 |     loguru::init(argc, argv);
10 |     LOG_F(INFO, "Hello from main.cpp!");
11 |     complex_calculation();
12 |     LOG_F(INFO, "main function about to end!");
13 | }
14 | 


--------------------------------------------------------------------------------
/cmake/loguru-config.cmake.in:
--------------------------------------------------------------------------------
 1 | @PACKAGE_INIT@
 2 | 
 3 | include(${CMAKE_CURRENT_LIST_DIR}/@_targets_export_name@.cmake)
 4 | check_required_components(loguru)
 5 | 
 6 | if (NOT TARGET Threads::Threads)
 7 |   find_package(Threads REQUIRED)
 8 | endif()
 9 | 
10 | # LOGURU_USE_FMTLIB
11 | if ( "@LOGURU_USE_FMTLIB@" AND NOT TARGET fmt::fmt )
12 |   find_package(fmt CONFIG REQUIRED)
13 | endif()
14 | 


--------------------------------------------------------------------------------
/cmake/loguru.pc.in:
--------------------------------------------------------------------------------
 1 | prefix=@CMAKE_INSTALL_PREFIX@
 2 | exec_prefix=${prefix}
 3 | libdir=@_pkgconfig_libdir@
 4 | includedir=@_pkgconfig_includedir@
 5 | 
 6 | Name: @PROJECT_NAME@
 7 | Description: @LOGURU_PACKAGE_DESCRIPTION_SUMMARY@
 8 | URL: @LOGURU_PACKAGE_URL@
 9 | Version: @LOGURU_VERSION@
10 | Libs: -L${libdir} -lloguru
11 | Libs.private: @CMAKE_THREAD_LIBS_INIT@ @_lib_dl_linkflag@
12 | Cflags: -I${includedir}
13 | 


--------------------------------------------------------------------------------
/glog_example/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "glog_example.hpp"
 3 | 
 4 | int main(int argc, char* argv[])
 5 | {
 6 |     FLAGS_alsologtostderr = true;
 7 |     FLAGS_colorlogtostderr = true;
 8 |     google::ParseCommandLineFlags(&argc, &argv, true);
 9 |     google::InitGoogleLogging(argv[0]);
10 |     LOG(INFO) << "Hello from main.cpp!";
11 |     complex_calculation();
12 |     LOG(INFO) << "main function about to end!";
13 | }
14 | 


--------------------------------------------------------------------------------
/test/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | cd "$ROOT_DIR"
 7 | mkdir -p build
 8 | cd build
 9 | 
10 | cmake ..
11 | 
12 | # Use GCC:
13 | # cmake -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ ..
14 | 
15 | # Use GCC5:
16 | # cmake -DCMAKE_C_COMPILER=/usr/bin/gcc-5 -DCMAKE_CXX_COMPILER=/usr/bin/g++-5 ..
17 | 
18 | # Use clang-3.7:
19 | # cmake -DCMAKE_C_COMPILER=/usr/bin/clang-3.7 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-3.7 ..
20 | 
21 | make
22 | 


--------------------------------------------------------------------------------
/loguru_bench/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(loguru_bench)
 4 | 
 5 | if(NOT CMAKE_BUILD_TYPE)
 6 |   set(CMAKE_BUILD_TYPE "Release" CACHE STRING
 7 |       "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 8 | endif(NOT CMAKE_BUILD_TYPE)
 9 | 
10 | MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra")
13 | 
14 | file(GLOB source
15 |     "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
16 | )
17 | 
18 | add_executable(loguru_bench ${source})
19 | 
20 | find_package(Threads)
21 | target_link_libraries(loguru_bench ${CMAKE_THREAD_LIBS_INIT}) # For pthreads
22 | target_link_libraries(loguru_bench dl) # For ldl
23 | 


--------------------------------------------------------------------------------
/loguru_example/loguru_example.hpp:
--------------------------------------------------------------------------------
 1 | #include <chrono>
 2 | #include <thread>
 3 | 
 4 | #include "../loguru.hpp"
 5 | 
 6 | inline void sleep_ms(int ms)
 7 | {
 8 | 	VLOG_F(2, "Sleeping for %d ms", ms);
 9 | 	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
10 | }
11 | 
12 | inline void complex_calculation()
13 | {
14 | 	LOG_SCOPE_F(INFO, "complex_calculation");
15 | 	LOG_F(INFO, "Starting time machine...");
16 | 	sleep_ms(200);
17 | 	LOG_F(WARNING, "The flux capacitor is not getting enough power!");
18 | 	sleep_ms(400);
19 | 	LOG_F(INFO, "Lighting strike!");
20 | 	VLOG_F(1, "Found 1.21 gigawatts...");
21 | 	sleep_ms(400);
22 | 	std::thread([](){
23 | 		loguru::set_thread_name("the past");
24 | 		LOG_F(ERROR, "We ended up in 1985!");
25 | 	}).join();
26 | }
27 | 


--------------------------------------------------------------------------------
/glog_example/glog_example.hpp:
--------------------------------------------------------------------------------
 1 | #include <chrono>
 2 | #include <thread>
 3 | 
 4 | #include <glog/logging.h>
 5 | 
 6 | inline void sleep_ms(int ms)
 7 | {
 8 |     VLOG(2) << "Sleeping for " << ms << " ms";
 9 |     std::this_thread::sleep_for(std::chrono::milliseconds(ms));
10 | }
11 | 
12 | inline void complex_calculation()
13 | {
14 | 	LOG(INFO) << "complex_calculation started";
15 | 	LOG(INFO) << "Starting time machine...";
16 | 	sleep_ms(200);
17 | 	LOG(WARNING) << "The flux capacitor is not getting enough power!";
18 | 	sleep_ms(400);
19 | 	LOG(INFO) << "Lighting strike!";
20 | 	VLOG(1) << "Found 1.21 gigawatts...";
21 | 	sleep_ms(400);
22 | 	std::thread([](){
23 | 		LOG(ERROR) << "We ended up in 1985!";
24 | 	}).join();
25 | 	LOG(INFO) << "complex_calculation stopped";
26 | }
27 | 


--------------------------------------------------------------------------------
/test/fail_test_wrapper.cmake:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env cmake -P
 2 | cmake_minimum_required(VERSION 2.8.7)
 3 | 
 4 | get_filename_component(CurrentFile ${CMAKE_CURRENT_LIST_FILE} NAME)
 5 | 
 6 | # The script is invoked as cmake -P <script name> <loguru_test> <arg(s)>
 7 | # the following loop extracts the arguments after the one matching the script name
 8 | foreach(i RANGE 0 ${CMAKE_ARGC})
 9 |     if(CollectArgs)
10 |         list(APPEND TestArgs ${CMAKE_ARGV${i}})
11 |     elseif(CMAKE_ARGV${i} MATCHES "${CurrentFile}$")
12 |         set(CollectArgs true)
13 |     endif()
14 | endforeach()
15 | 
16 | # TestArgs contains <loguru_test> <arg(s)>
17 | execute_process(COMMAND ${TestArgs}
18 |                 RESULT_VARIABLE CmdResult)
19 | 
20 | # To invert the failure logic
21 | if(NOT CmdResult)
22 | # the wrapper must fail if the child process returned success
23 |     message(FATAL_ERROR "${TestArgs} passed.")
24 | endif()
25 | 


--------------------------------------------------------------------------------
/lnav_format_loguru_cpp.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "logurucpplogger": {
 3 |         "title": "Loguru c++ logger format",
 4 |         "description": "Log format used by loguru c++ class",
 5 |         "url": "",
 6 |         "regex": {
 7 |             "main" : {
 8 |                 "pattern": "^(?<timestamp>\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}) \\((?<uptime>.*)s\\) \\[(?<thread>.*)\\]\\s+(?<class>\\S+):(?<line>\\w+)\\s+(?<level>\\w+)\\| (?<bod$
 9 |             }
10 |         },
11 |         "level-field": "level",
12 |         "level": {
13 |             "critical": "FATL",
14 |             "error": "ERR",
15 |             "warning": "WARN",
16 |             "info": "INFO"
17 |         },
18 |         "value": {
19 |             "level": { "kind" : "string", "identifier" : true },
20 |             "class": { "kind" : "string", "identifier" : true },
21 |             "body": { "kind" : "string" },
22 |             "thread": { "kind" : "string" },
23 |             "uptime": { "kind" : "string" },
24 |             "line": { "kind" : "string" }
25 |         },
26 |         "sample": [
27 |             {
28 |                 "line": "2019-11-26 09:48:08.307 (   0.002s) [main thread     ]             loguru.cpp:612   INFO| stderr verbosity: 0"
29 |             }
30 |         ]
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <https://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/cmake/utilities.cmake:
--------------------------------------------------------------------------------
 1 | # --- set LOGURU_VERSION from loguru.hpp
 2 | # --------------------------------------
 3 | 
 4 | function(loguru_get_version_from_header)
 5 | 
 6 |   file(READ "${CMAKE_CURRENT_LIST_DIR}/loguru.hpp" _hdr_contents)
 7 |   string(REGEX REPLACE ".*LOGURU_VERSION_MAJOR ([0-9]+).*" "\\1" _version_major "${_hdr_contents}")
 8 |   string(REGEX REPLACE ".*LOGURU_VERSION_MINOR ([0-9]+).*" "\\1" _version_minor "${_hdr_contents}")
 9 |   string(REGEX REPLACE ".*LOGURU_VERSION_PATCH ([0-9]+).*" "\\1" _version_patch "${_hdr_contents}")
10 | 
11 |   if(_version_major STREQUAL "")
12 |     message(FATAL_ERROR "Could not extract major version number from loguru.hpp")
13 |   endif()
14 | 
15 |   if(_version_minor STREQUAL "")
16 |     message(FATAL_ERROR "Could not extract minor version number from loguru.hpp")
17 |   endif()
18 | 
19 |   if(_version_patch STREQUAL "")
20 |     message(FATAL_ERROR "Could not extract patch version number from loguru.hpp")
21 |   endif()
22 | 
23 |   set(LOGURU_VERSION_MAJOR "${_version_major}" CACHE STRING "" FORCE)
24 |   set(LOGURU_VERSION_MINOR "${_version_minor}" CACHE STRING "" FORCE)
25 |   set(LOGURU_VERSION_PATCH "${_version_patch}" CACHE STRING "" FORCE)
26 |   set(LOGURU_VERSION "${_version_major}.${_version_minor}.${_version_patch}" CACHE STRING "" FORCE)
27 | 
28 | endfunction()
29 | 
30 | # --- prints a var and its value
31 | # --------------------------------------
32 | 
33 | macro(print_var x)
34 |   message(STATUS "${x}=[${${x}}]")
35 | endmacro()
36 | 


--------------------------------------------------------------------------------
/loguru_example/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(loguru_example)
 4 | 
 5 | if(NOT CMAKE_BUILD_TYPE)
 6 |   set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
 7 |       "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 8 | endif(NOT CMAKE_BUILD_TYPE)
 9 | 
10 | MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | if(MSVC)
13 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall")
14 | else()
15 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra -pedantic")
16 | endif()
17 | 
18 | if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
19 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything")
20 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat")
21 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat-pedantic")
22 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-noreturn")
23 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-prototypes")
24 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments")
25 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-disabled-macro-expansion")
26 | endif() # Clang
27 | 
28 | file(GLOB source
29 |     "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
30 |     # "${CMAKE_CURRENT_SOURCE_DIR}/../*.cpp"
31 | )
32 | 
33 | add_executable(loguru_example ${source})
34 | 
35 | find_package(Threads)
36 | target_link_libraries(loguru_example ${CMAKE_THREAD_LIBS_INIT}) # For pthreads
37 | if(NOT WIN32)
38 |     target_link_libraries(loguru_example dl) # For ldl
39 | endif()
40 | 


--------------------------------------------------------------------------------
/test/build_and_run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e # Fail on error
 3 | 
 4 | ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 5 | 
 6 | $ROOT_DIR/build.sh
 7 | 
 8 | cd $ROOT_DIR/build/
 9 | 
10 | function test_failure
11 | {
12 |     echo ""
13 |     ./loguru_test $1 && echo "Expected command to fail!" && exit 1
14 |     echo ""
15 |     echo ""
16 | }
17 | 
18 | function test_success
19 | {
20 |     echo ""
21 |     ./loguru_test $1 || echo "Expected command to succeed!"
22 |     echo ""
23 |     echo ""
24 | }
25 | 
26 | echo "---------------------------------------------------------"
27 | echo "Testing failures..."
28 | echo "---------------------------------------------------------"
29 | test_failure "ABORT_F"
30 | test_failure "ABORT_S"
31 | test_failure "assert"
32 | test_failure "LOG_F_FATAL"
33 | test_failure "LOG_S_FATAL"
34 | test_failure "CHECK_NOTNULL_F"
35 | test_failure "CHECK_F"
36 | test_failure "CHECK_EQ_F_int"
37 | test_failure "CHECK_EQ_F_unsigned"
38 | test_failure "CHECK_EQ_F_size_t"
39 | test_failure "CHECK_EQ_F"
40 | test_failure "CHECK_EQ_F_message"
41 | test_failure "CHECK_EQ_S"
42 | test_failure "CHECK_LT_S"
43 | test_failure "CHECK_LT_S_message"
44 | test_failure "deep_abort"
45 | test_failure "SIGSEGV"
46 | test_failure "abort"
47 | test_failure "error_context"
48 | test_failure "throw_on_fatal"
49 | test_failure "throw_on_signal"
50 | test_success "callback"
51 | echo "---------------------------------------------------------"
52 | echo "ALL TESTS PASSED!"
53 | echo "---------------------------------------------------------"
54 | 
55 | ./loguru_test $@
56 | 
57 | ./loguru_test hang
58 | 


--------------------------------------------------------------------------------
/test/build_and_run.cmake:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env cmake -P
 2 | 
 3 | # for lack of an equivalent of `set -e` in bash
 4 | macro(EXEC_CMD_CHECK)
 5 |   message("running ${ARGN}")
 6 |   execute_process(COMMAND ${ARGN} RESULT_VARIABLE CMD_RESULT)
 7 |   if(CMD_RESULT)
 8 |     message(FATAL_ERROR "Error running ${ARGN}")
 9 |   endif()
10 | endmacro()
11 | 
12 | # Read the configuration from the environement
13 | if(NOT DEFINED Configuration AND DEFINED ENV{Configuration})
14 |   set(Configuration $ENV{Configuration})
15 | endif()
16 | # to override the default configuration: ex. -DConfiguration=Release
17 | if(DEFINED Configuration)
18 |   list(APPEND CMAKE_EXTRA_ARGS "-DCMAKE_BUILD_TYPE=${Configuration}")
19 |   set(CMAKE_BUILD_EXTRA_ARGS --config ${Configuration})
20 |   set(CTEST_EXTRA_ARGS -C ${Configuration})
21 | endif()
22 | 
23 | # The generator also, if we have an entry in the envirnoment
24 | if(NOT DEFINED Generator AND DEFINED ENV{Generator})
25 |   set(Generator $ENV{Generator})
26 | endif()
27 | # to override the default generator: ex. -DGenerator=Ninja
28 | if(DEFINED Generator)
29 |   list(APPEND CMAKE_EXTRA_ARGS "-G${Generator}")
30 | endif()
31 | 
32 | if(NOT DEFINED BUILD_DIR)
33 |   set(BUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/build)
34 | endif()
35 | file(MAKE_DIRECTORY ${BUILD_DIR})
36 | 
37 | # cd build && cmake .. && cd -
38 | EXEC_CMD_CHECK(${CMAKE_COMMAND} ${CMAKE_EXTRA_ARGS} ${CMAKE_CURRENT_LIST_DIR}
39 |                WORKING_DIRECTORY ${BUILD_DIR})
40 | 
41 | # platform-independent equivalent of `make`
42 | EXEC_CMD_CHECK(${CMAKE_COMMAND} --build ${BUILD_DIR} ${CMAKE_BUILD_EXTRA_ARGS})
43 | 
44 | EXEC_CMD_CHECK(${CMAKE_CTEST_COMMAND} ${CTEST_EXTRA_ARGS} --output-on-failure
45 |                WORKING_DIRECTORY ${BUILD_DIR})
46 | 


--------------------------------------------------------------------------------
/test/appveyor.cmake:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env cmake -P
 2 | # Group AppVeyor builds to use fewer VM instances and upload useful artifacts from each.
 3 | find_program(AppVeyor appveyor)
 4 | if(NOT AppVeyor)
 5 |   message(FATAL_ERROR "script specific to appveyor only")
 6 | endif()
 7 | 
 8 | function(message type) # overriding CMake built-in message function for AppVeyor
 9 |   set(msg "${ARGV}")
10 |   if(type STREQUAL FATAL_ERROR OR type STREQUAL SEND_ERROR)
11 |     set(msg "${ARGN}")
12 |     set(options -Category Error)
13 |   elseif(type STREQUAL WARNING OR type STREQUAL AUTHOR_WARNING)
14 |     set(msg "${ARGN}")
15 |     set(options -Category Warning)
16 |   elseif(type STREQUAL STATUS)
17 |     set(msg "${ARGN}")
18 |     set(options -Category Information)
19 |   endif()
20 |   execute_process(COMMAND ${AppVeyor} AddMessage "${msg}" ${options})
21 | 
22 |   _message(${ARGV}) # the built-in functionality
23 | endfunction()
24 | 
25 | function(BuildAndRun)
26 |   if(DEFINED Generator)
27 |     string(REPLACE " " "" gen "${Generator}/") # Remove spaces from generator
28 |   endif()
29 |   set(BUILD_DIR "${CMAKE_CURRENT_LIST_DIR}/build/${gen}${Configuration}")
30 |   message("Building ${gen}${Configuration}")
31 |   include(${CMAKE_CURRENT_LIST_DIR}/build_and_run.cmake)
32 |   message("Built ${gen}${Configuration}")
33 |   execute_process(COMMAND ${CMAKE_COMMAND} -E tar czf "${BUILD_DIR}/Testing.zip" "${BUILD_DIR}/Testing")
34 |   execute_process(COMMAND ${AppVeyor} PushArtifact "${BUILD_DIR}/Testing.zip" -FileName "${gen}${Configuration}.zip")
35 | endfunction()
36 | 
37 | foreach(Configuration "Debug" "Release")
38 |   if(WIN32)
39 |     foreach(Generator
40 |       "Visual Studio 14 2015"
41 |       "Visual Studio 14 2015 Win64"
42 |       "Visual Studio 15 2017"
43 |       "Visual Studio 15 2017 Win64"
44 |     )
45 |       BuildAndRun()
46 |     endforeach()
47 |   elseif(UNIX)
48 |     BuildAndRun()
49 |   endif()
50 | endforeach()
51 | 


--------------------------------------------------------------------------------
/glog_bench/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(glog_bench)
 4 | 
 5 | if(NOT CMAKE_BUILD_TYPE)
 6 |   set(CMAKE_BUILD_TYPE "Release" CACHE STRING
 7 |       "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 8 | endif(NOT CMAKE_BUILD_TYPE)
 9 | 
10 | MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | add_compile_options(-std=c++11 -Werror -Wall -Wextra)
13 | 
14 | file(GLOB source
15 |     "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
16 | )
17 | 
18 | # ------------------------------------------------------
19 | # GFLAGS
20 | find_library(GFLAGS_LIB  NAMES "gflags" PATHS
21 | 			${GFLAGS_ROOT}/lib
22 | 			${GFLAGS_ROOT}/Lib)
23 | 
24 | if (MSVC)
25 | 	find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS ${GFLAGS_ROOT}/Include)
26 | 	set(GFLAGS_LIB_DIR  ${GFLAGS_ROOT}/Lib)
27 | else()
28 | 	find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS
29 | 		${GFLAGS_ROOT}/include)
30 | 	set(GFLAGS_LIB_DIR  ${GFLAGS_ROOT}/lib)
31 | endif()
32 | mark_as_advanced(
33 |     GFLAGS_INCLUDE_DIR
34 |     GFLAGS_LIB
35 | )
36 | 
37 | # ------------------------------------------------------
38 | # GLOG
39 | 
40 | find_library(GLOG_LIB  NAMES "glog" libglog PATHS
41 | 			${GLOG_ROOT})
42 | 
43 | if (MSVC)
44 | 	find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS ${GLOG_ROOT})
45 | 	set(GLOG_LIB_DIR ${GLOG_ROOT})
46 | 	add_definitions(-DUSE_OWN_CHECK)
47 | else()
48 | 	find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS
49 | 		${GLOG_ROOT}/include)
50 | 	set(GLOG_LIB_DIR ${GLOG_ROOT}/lib)
51 | endif()
52 | add_definitions(-DGLOG_NO_ABBREVIATED_SEVERITIES=1)
53 | 
54 | mark_as_advanced(
55 |     GLOG_INCLUDE_DIR
56 |     GLOG_LIB
57 | )
58 | 
59 | # ------------------------------------------------------
60 | 
61 | add_executable(glog_bench ${source})
62 | 
63 | include_directories(
64 | 	${GFLAGS_INCLUDE_DIR}
65 | 	${GLOG_INCLUDE_DIR}
66 | )
67 | 
68 | target_link_libraries(glog_bench
69 |     ${GFLAGS_LIB}
70 |     ${GLOG_LIB}
71 | )
72 | 


--------------------------------------------------------------------------------
/glog_example/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(glog_example)
 4 | 
 5 | if(NOT CMAKE_BUILD_TYPE)
 6 |   set(CMAKE_BUILD_TYPE "Release" CACHE STRING
 7 |       "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 8 | endif(NOT CMAKE_BUILD_TYPE)
 9 | 
10 | MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | add_compile_options(-std=c++11 -Werror -Wall -Wextra)
13 | 
14 | file(GLOB source
15 |     "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
16 | )
17 | 
18 | # ------------------------------------------------------
19 | # GFLAGS
20 | find_library(GFLAGS_LIB  NAMES "gflags" PATHS
21 | 			${GFLAGS_ROOT}/lib
22 | 			${GFLAGS_ROOT}/Lib)
23 | 
24 | if (MSVC)
25 | 	find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS ${GFLAGS_ROOT}/Include)
26 | 	set(GFLAGS_LIB_DIR  ${GFLAGS_ROOT}/Lib)
27 | else()
28 | 	find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS
29 | 		${GFLAGS_ROOT}/include)
30 | 	set(GFLAGS_LIB_DIR  ${GFLAGS_ROOT}/lib)
31 | endif()
32 | mark_as_advanced(
33 |     GFLAGS_INCLUDE_DIR
34 |     GFLAGS_LIB
35 | )
36 | 
37 | # ------------------------------------------------------
38 | # GLOG
39 | 
40 | find_library(GLOG_LIB  NAMES "glog" libglog PATHS
41 | 			${GLOG_ROOT})
42 | 
43 | if (MSVC)
44 | 	find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS ${GLOG_ROOT})
45 | 	set(GLOG_LIB_DIR ${GLOG_ROOT})
46 | 	add_definitions(-DUSE_OWN_CHECK)
47 | else()
48 | 	find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS
49 | 		${GLOG_ROOT}/include)
50 | 	set(GLOG_LIB_DIR ${GLOG_ROOT}/lib)
51 | endif()
52 | add_definitions(-DGLOG_NO_ABBREVIATED_SEVERITIES=1)
53 | 
54 | mark_as_advanced(
55 |     GLOG_INCLUDE_DIR
56 |     GLOG_LIB
57 | )
58 | 
59 | # ------------------------------------------------------
60 | 
61 | add_executable(glog_example ${source})
62 | 
63 | include_directories(
64 | 	${GFLAGS_INCLUDE_DIR}
65 | 	${GLOG_INCLUDE_DIR}
66 | )
67 | 
68 | target_link_libraries(glog_example
69 |     ${GFLAGS_LIB}
70 |     ${GLOG_LIB}
71 | )
72 | 


--------------------------------------------------------------------------------
/cmake/loguru-cpack.cmake:
--------------------------------------------------------------------------------
 1 | # -- expose cache variables to the user
 2 | 
 3 | # Set .zip and tar.gz as default generators
 4 | set(LOGURU_CPACK_GENERATOR "TGZ;ZIP" CACHE STRING
 5 |     "Semicolon separated list of generators")
 6 | # NOTE: CPACK_PACKAGE_DIRECTORY normally defaults to CMAKE_BINARY_DIR
 7 | set(LOGURU_CPACK_PACKAGE_DIRECTORY "${PROJECT_BINARY_DIR}/packages" CACHE PATH
 8 |     "Where to generate loguru cpack installer packages")
 9 | 
10 | set(CPACK_GENERATOR ${LOGURU_CPACK_GENERATOR})
11 | set(CPACK_PACKAGE_DIRECTORY ${LOGURU_CPACK_PACKAGE_DIRECTORY})
12 | 
13 | # -- contact and summary
14 | 
15 | set(CPACK_PROJECT_URL     "${LOGURU_PACKAGE_URL}")
16 | set(CPACK_PACKAGE_VENDOR  "${LOGURU_PACKAGE_VENDOR}")
17 | set(CPACK_PACKAGE_CONTACT "${LOGURU_PACKAGE_CONTACT}")
18 | set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${LOGURU_PACKAGE_DESCRIPTION_SUMMARY}")
19 | set(CPACK_PACKAGE_DESCRIPTION_FILE    "${LOGURU_PACKAGE_DESCRIPTION_FILE}")
20 | 
21 | # -- version info
22 | 
23 | set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
24 | set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
25 | set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
26 | set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
27 | if(PROJECT_VERSION_TWEAK)
28 |   set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})
29 | endif()
30 | 
31 | # -- set non-default behavior
32 | 
33 | set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY ON)
34 | set(CPACK_STRIP_FILES ON)
35 | 
36 | # -- normalize paths
37 | 
38 | # NOTE: some generators don't understand paths that contain backslashes
39 | string(REPLACE "\\" "/" CPACK_PACKAGE_DIRECTORY "${CPACK_PACKAGE_DIRECTORY}" )
40 | 
41 | # -- make cpack work with sub-projects
42 | 
43 | # NOTE:
44 | #  cpack assumes by default that it's being called from a top-level project.
45 | #  It uses the top-level project values to generate 'CPackConfig.cmake' and
46 | #  tries to place it into the top-level build directory.
47 | #  This behavior makes sense if you're writing a standalone cmake project, but
48 | #  causes grief if your project is designed to be included as a sub-project
49 | #    e.g. using   add_subdirectory()   or   FetchContent()
50 | #  Here, we trick cpack into using the current current project info instead.
51 | set(CMAKE_BINARY_DIR   "${PROJECT_BINARY_DIR}")
52 | set(CMAKE_SOURCE_DIR   "${PROJECT_SOURCE_DIR}")
53 | set(CMAKE_PROJECT_NAME "${PROJECT_NAME}")
54 | 
55 | # -- include CPack module
56 | 
57 | # NOTE: This must be called at the end so it inherits all the values set above
58 | include(CPack)
59 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(loguru_test)
 4 | 
 5 | if(NOT CMAKE_BUILD_TYPE)
 6 |   set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
 7 |       "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 8 | endif(NOT CMAKE_BUILD_TYPE)
 9 | 
10 | MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | if(MSVC)
13 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall")
14 | else()
15 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra -pedantic -fsanitize=address -fno-omit-frame-pointer")
16 | endif()
17 | 
18 | if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
19 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything")
20 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat")
21 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat-pedantic")
22 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-noreturn")
23 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-prototypes")
24 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments")
25 | endif() # Clang
26 | 
27 | add_executable(loguru_test loguru_test.cpp)
28 | 
29 | find_package(Threads)
30 | target_link_libraries(loguru_test ${CMAKE_THREAD_LIBS_INIT}) # For pthreads
31 | if(NOT WIN32)
32 |     target_link_libraries(loguru_test dl) # For ldl
33 | endif()
34 | 
35 | enable_testing()
36 | 
37 | if(NOT WIN32)
38 | # Sadly, Windows doesn't allow us to safely run the following tests
39 |     list(APPEND ExtraFailureTests
40 |             SIGSEGV
41 |             throw_on_signal)
42 | endif()
43 | 
44 | if(CMAKE_BUILD_TYPE STREQUAL "Debug")
45 |     list(APPEND ExtraFailureTests
46 |             assert)
47 | endif()
48 | 
49 | # Failure Tests
50 | foreach(Test
51 |             ABORT_F
52 |             ABORT_S
53 |             LOG_F_FATAL
54 |             LOG_S_FATAL
55 |             CHECK_NOTNULL_F
56 |             CHECK_F
57 |             CHECK_EQ_F_int
58 |             CHECK_EQ_F_unsigned
59 |             CHECK_EQ_F_size_t
60 |             CHECK_EQ_F
61 |             CHECK_EQ_F_message
62 |             CHECK_EQ_S
63 |             CHECK_LT_S
64 |             CHECK_LT_S_message
65 |             deep_abort
66 |             abort
67 |             error_context
68 |             throw_on_fatal
69 |             ${ExtraFailureTests}
70 | )
71 |      add_test(NAME loguru_test_${Test}
72 |               COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_LIST_DIR}/fail_test_wrapper.cmake
73 |               $<TARGET_FILE:loguru_test> ${Test})
74 | endforeach()
75 | 
76 | # Success Tests
77 | foreach(Test
78 |             callback)
79 |     add_test(loguru_test_${Test} loguru_test ${Test})
80 | endforeach()
81 | 


--------------------------------------------------------------------------------
/glog_bench/glog_bench.cpp:
--------------------------------------------------------------------------------
 1 | #include <chrono>
 2 | #include <cmath>
 3 | #include <iomanip>
 4 | #include <iostream>
 5 | 
 6 | #include <glog/logging.h>
 7 | #include <glog/raw_logging.h>
 8 | 
 9 | const size_t kNumIterations = 50 * 1000;
10 | const size_t kNumRuns = 10;
11 | const double kPi = 3.1415926535897932384626433;
12 | 
13 | static long long now_ns()
14 | {
15 | 	using namespace std::chrono;
16 | 	return duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
17 | }
18 | 
19 | template<typename Function>
20 | double time_sec(const Function& function)
21 | {
22 | 	auto start_ns = now_ns();
23 | 	function();
24 | 	return (now_ns() - start_ns) * 1e-9;
25 | }
26 | 
27 | template<typename Function>
28 | void bench(const std::string& name, const Function& function)
29 | {
30 | 	function(); // Warm-up
31 | 
32 | 	printf("%-30s ", name.c_str());
33 | 	fflush(stdout);
34 | 	std::vector<double> times;
35 | 	double sum = 0;
36 | 	for (size_t i = 0; i < kNumRuns; ++i)
37 | 	{
38 | 		times.push_back(time_sec(function) / kNumIterations);
39 | 		sum += times.back();
40 | 	}
41 | 
42 | 	double mean = sum / kNumRuns;
43 | 	double std_dev_sum = 0;
44 | 
45 | 	for (double time : times) {
46 | 		std_dev_sum += (time - mean) * (time - mean);
47 | 	}
48 | 
49 | 	double variance = std::sqrt(std_dev_sum / kNumRuns);
50 | 
51 | 	printf("%6.3f +- %.3f us per call\n", mean * 1e6, variance * 1e6);
52 | 	fflush(stdout);
53 | }
54 | 
55 | // ----------------------------------------------------------------------------
56 | 
57 | void stream_strings()
58 | {
59 | 	for (size_t i = 0; i < kNumIterations; ++i) {
60 | 		LOG(WARNING) << "Some long, complex message.";
61 | 	}
62 | 	google::FlushLogFiles(google::GLOG_INFO);
63 | }
64 | 
65 | void stream_float()
66 | {
67 | 	for (size_t i = 0; i < kNumIterations; ++i) {
68 | 		LOG(WARNING) << std::setfill('0') << std::setw(6) << std::setprecision(3) << kPi;
69 | 	}
70 | 	google::FlushLogFiles(google::GLOG_INFO);
71 | }
72 | 
73 | void raw_string_float()
74 | {
75 | 	for (size_t i = 0; i < kNumIterations; ++i) {
76 | 		RAW_LOG(WARNING, "Some long, complex message.");
77 | 	}
78 | 	google::FlushLogFiles(google::GLOG_INFO);
79 | }
80 | 
81 | int main(int argc, char* argv[])
82 | {
83 |     FLAGS_alsologtostderr = true;
84 |     google::ParseCommandLineFlags(&argc, &argv, true);
85 |     google::InitGoogleLogging(argv[0]);
86 | 
87 |     bench("LOG(WARNING) << string (buffered):", stream_strings);
88 |     bench("LOG(WARNING) << float  (buffered):", stream_float);
89 | 
90 |     FLAGS_logbufsecs = 0; // Flush all output in realtime
91 |     bench("LOG(WARNING) << string (unbuffered):", stream_strings);
92 |     bench("LOG(WARNING) << float  (unbuffered):", stream_float);
93 | }
94 | 


--------------------------------------------------------------------------------
/loguru_cmake_example/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.10)
 2 | 
 3 | project(loguru_cmake_example CXX)
 4 | 
 5 | # Choose any ONE of the following three methods to import loguru into your cmake
 6 | #
 7 | # How do I set loguru compile-time flags?!
 8 | #
 9 | #   This example file demonstrates setting the 'LOGURU_WITH_STREAMS' option
10 | #
11 | #   For method 1 and 2:
12 | #     loguru is compiled alongside your project so all loguru compile-time flags
13 | #     can be set in your project as cmake variables!
14 | #
15 | #   For method 3:
16 | #     This method uses a pre-compiled copy of loguru, so the compile-time flags
17 | #     cannot be changed by your project. They must be set when compiling loguru.
18 | 
19 | # ------------------------------------------------------------------------------
20 | # --- Method 1: Add loguru as a sub-directory (great with git submodules!)
21 | # ------------------------------------------------------------------------------
22 | 
23 | # set any loguru compile-time flags before adding the subdirectory
24 | set(LOGURU_WITH_STREAMS TRUE)
25 | add_subdirectory(loguru) # defines target 'loguru::loguru'
26 | 
27 | # ------------------------------------------------------------------------------
28 | # --- Method 2: Fetch from an external repository
29 | # ------------------------------------------------------------------------------
30 | 
31 | # NOTE: The FetchContent functions shown here were introduced in CMake 3.14
32 | 
33 | include(FetchContent)
34 | FetchContent_Declare(LoguruGitRepo
35 | 	GIT_REPOSITORY "https://github.com/emilk/loguru" # can be a filesystem path
36 | 	GIT_TAG        "master"
37 | )
38 | # set any loguru compile-time flags before calling MakeAvailable()
39 | set(LOGURU_WITH_STREAMS TRUE)
40 | FetchContent_MakeAvailable(LoguruGitRepo) # defines target 'loguru::loguru'
41 | 
42 | # ------------------------------------------------------------------------------
43 | # -- Method 3: Use a pre-compiled installed copy of loguru
44 | # ------------------------------------------------------------------------------
45 | 
46 | # This method requires you to have first built + installed loguru on your system
47 | # using steps like the following (shown here setting WITH_STREAMS=1)
48 | #    cd loguru
49 | #    cmake -S. -Bbuild \
50 | #      -DCMAKE_INSTALL_PREFIX=/path/to/loguru/install \
51 | #      -DLOGURU_WITH_STREAMS=TRUE
52 | #    cmake --build build --target install
53 | find_package(loguru CONFIG REQUIRED) # imports target 'loguru::loguru'
54 | 
55 | # ------------------------------------------------------------------------------
56 | # -- Link to the loguru::loguru target
57 | # ------------------------------------------------------------------------------
58 | 
59 | # Regardless of the method used, you always link to the `loguru::loguru` target!
60 | 
61 | add_executable(YourTarget main.cpp)
62 | target_link_libraries(YourTarget PRIVATE loguru::loguru)
63 | 


--------------------------------------------------------------------------------
/loguru_bench/loguru_bench.cpp:
--------------------------------------------------------------------------------
  1 | #include <chrono>
  2 | #include <cmath>
  3 | #include <iomanip>
  4 | #include <iostream>
  5 | #include <vector>
  6 | 
  7 | #define LOGURU_WITH_STREAMS 1
  8 | #define LOGURU_REDEFINE_ASSERT 1
  9 | #include "../loguru.cpp"
 10 | 
 11 | const size_t kNumRuns = 10;
 12 | const double kPi = 3.1415926535897932384626433;
 13 | 
 14 | static long long now_ns()
 15 | {
 16 | 	using namespace std::chrono;
 17 | 	return duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
 18 | }
 19 | 
 20 | template<typename Function>
 21 | void bench(const std::string& name, const Function& function, size_t num_iterations)
 22 | {
 23 | 	function(num_iterations); // Warm-up.
 24 | 
 25 | 	printf("%-30s ", name.c_str());
 26 | 	fflush(stdout);
 27 | 	std::vector<double> times;
 28 | 	double sum = 0;
 29 | 	for (size_t i = 0; i < kNumRuns; ++i) {
 30 | 		auto start_ns = now_ns();
 31 | 		function(num_iterations);
 32 | 		double total_time_sec = (now_ns() - start_ns) * 1e-9;
 33 | 		times.push_back(total_time_sec / num_iterations);
 34 | 		sum += times.back();
 35 | 	}
 36 | 
 37 | 	double mean = sum / kNumRuns;
 38 | 	double std_dev_sum = 0;
 39 | 
 40 | 	for (double time : times) {
 41 | 		std_dev_sum += (time - mean) * (time - mean);
 42 | 	}
 43 | 
 44 | 	double variance = std::sqrt(std_dev_sum / kNumRuns);
 45 | 
 46 | 	printf("%6.3f ± %.3f μs per call\n", mean * 1e6, variance * 1e6);
 47 | 	fflush(stdout);
 48 | }
 49 | 
 50 | // ----------------------------------------------------------------------------
 51 | 
 52 | void format_strings(size_t num_iterations)
 53 | {
 54 | 	for (size_t i = 0; i < num_iterations; ++i) {
 55 | 		LOG_F(WARNING, "Some long, complex message.");
 56 | 	}
 57 | 	loguru::flush();
 58 | }
 59 | 
 60 | void format_float(size_t num_iterations)
 61 | {
 62 | 	for (size_t i = 0; i < num_iterations; ++i) {
 63 | 		LOG_F(WARNING, "%+05.3f", kPi);
 64 | 	}
 65 | 	loguru::flush();
 66 | }
 67 | 
 68 | void stream_strings(size_t num_iterations)
 69 | {
 70 | 	for (size_t i = 0; i < num_iterations; ++i) {
 71 | 		LOG_S(WARNING) << "Some long, complex message.";
 72 | 	}
 73 | 	loguru::flush();
 74 | }
 75 | 
 76 | void stream_float(size_t num_iterations)
 77 | {
 78 | 	for (size_t i = 0; i < num_iterations; ++i) {
 79 | 		LOG_S(WARNING) << std::setfill('0') << std::setw(5) << std::setprecision(3) << kPi;
 80 | 	}
 81 | 	loguru::flush();
 82 | }
 83 | 
 84 | void raw_string_float(size_t num_iterations)
 85 | {
 86 | 	for (size_t i = 0; i < num_iterations; ++i) {
 87 | 		RAW_LOG_F(WARNING, "Some long, complex message.");
 88 | 	}
 89 | 	loguru::flush();
 90 | }
 91 | 
 92 | void error_context(size_t num_iterations)
 93 | {
 94 | 	for (size_t i = 0; i < num_iterations; ++i) {
 95 | 		ERROR_CONTEXT("key", "value");
 96 | 	}
 97 | }
 98 | 
 99 | int main(int argc, char* argv[])
100 | {
101 | 	const size_t kNumIterations = 50 * 1000;
102 | 
103 | 	loguru::init(argc, argv);
104 | 	loguru::add_file("loguru_bench.log", loguru::Truncate, loguru::Verbosity_INFO);
105 | 
106 | 	bench("ERROR_CONTEXT", error_context, kNumIterations * 100);
107 | 
108 | 	loguru::g_flush_interval_ms = 200;
109 | 	bench("LOG_F string (buffered):", format_strings,   kNumIterations);
110 | 	bench("LOG_F float  (buffered):", format_float,     kNumIterations);
111 | 	bench("LOG_S string (buffered):", stream_strings,   kNumIterations);
112 | 	bench("LOG_S float  (buffered):", stream_float,     kNumIterations);
113 | 	bench("RAW_LOG_F    (buffered):", raw_string_float, kNumIterations);
114 | 
115 | 	loguru::g_flush_interval_ms = 0;
116 | 	bench("LOG_F string (unbuffered):", format_strings,   kNumIterations);
117 | 	bench("LOG_F float  (unbuffered):", format_float,     kNumIterations);
118 | 	bench("LOG_S string (unbuffered):", stream_strings,   kNumIterations);
119 | 	bench("LOG_S float  (unbuffered):", stream_float,     kNumIterations);
120 | 	bench("RAW_LOG_F    (unbuffered):", raw_string_float, kNumIterations);
121 | }
122 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Loguru: a lightweight and flexible C++ logging library.
  2 | 
  3 | [![Build status](https://ci.appveyor.com/api/projects/status/hret4rx3xakjs7j4?svg=true)](https://ci.appveyor.com/project/emilk/loguru)
  4 | 
  5 | ## At a glance
  6 | 
  7 | ![Loguru terminal output](docs/terminal_colors.png)
  8 | 
  9 | ## Documentation
 10 | Documentation can be found at https://emilk.github.io/loguru/index.html.
 11 | 
 12 | ## License
 13 | This software is in the public domain. Where that dedication is not recognized, you are granted a perpetual, irrevocable license to copy, modify and distribute it as you see fit.
 14 | 
 15 | Loguru is also available under [The Unlicense](https://choosealicense.com/licenses/unlicense/).
 16 | 
 17 | That being said, I would appreciate credit!
 18 | If you find Loguru useful, tweet me at @ernerfeldt mail me at emil.ernerfeldt@gmail.com.
 19 | 
 20 | ## Why another logging library?
 21 | I have yet to come across a nice, light-weight logging library for C++ that does everything I want. So I made one!
 22 | 
 23 | In particular, I want logging that produces logs that are both human-readable and easily grep:ed. I also want to be able to hook into the logging process to print some of the more severe messages on-screen in my app (for dev-purposes).
 24 | 
 25 | ## Features:
 26 | * Simple integration
 27 | 	* Just two files: `loguru.hpp` and `loguru.cpp`.
 28 | 	* Either build and link `loguru.cpp` or just `#include <loguru.cpp>` in one of your own .cpp files.
 29 | * Small, simple library.
 30 | 	* Small header with no `#include`s for **fast compile times** (see separate heading).
 31 | 	* No dependencies.
 32 | 	* Cross-platform
 33 | * Flexible:
 34 | 	* User can install callbacks for logging (e.g. to draw log messages on screen in a game).
 35 | 	* User can install callbacks for fatal error (e.g. to pause an attached debugger or throw an exception).
 36 | * Support multiple file outputs, either trunc or append:
 37 | 	* e.g. a logfile with just the latest run at low verbosity (high readability).
 38 | 	* e.g. a full logfile at highest verbosity which is appended to on every run.
 39 | * Full featured:
 40 | 	* Verbosity levels.
 41 | 	* Supports assertions: `CHECK_F(fp != nullptr, "Failed to open '%s'", filename)`
 42 | 	* Supports abort: `ABORT_F("Something went wrong, debug value is %d", value)`.
 43 | * Stack traces printed on abort.
 44 | 	* Stack traces are cleaned up somewhat.
 45 | 		* Before cleanup: `some_function_name(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&)`
 46 | 		* After cleanup: `some_function_name(std::vector<std::string> const&)`
 47 | 	* Stack traces are printed [the right way](http://yellerapp.com/posts/2015-01-22-upside-down-stacktraces.html):
 48 | 		* Chronological order with the most relevant at the end.
 49 | * (most) signals writes stack traces.
 50 | * Fast:
 51 | 	- When configured in unbuffered mode (loguru::g_flush_interval_ms = 0):
 52 | 		+ 6-8 us when logging to stderr + file (rMBP + SSD + Clang).
 53 | 		+ About 25%-75% faster than GLOG on my MacBook Pro (Clang).
 54 | 		+ About the same as GLOG on my Linux Desktop (GCC).
 55 | 	- With loguru::g_flush_interval_ms set to ~100 ms:
 56 | 		+ 3-5 us when logging to stderr + file (rMBP + SSD + Clang).
 57 | 		+ About twice as fast as GLOG.
 58 | * Drop-in replacement for most of GLOG (except for setup code).
 59 | * Choose between using printf-style or std::cout-style formatting.
 60 | * Compile-time checked printf-formating (on supported compilers).
 61 | * Support for [fmtlib](https://github.com/fmtlib/fmt) formatting.
 62 | 	* Add `#define LOGURU_USE_FMTLIB 1`, before including `loguru.hpp`
 63 | 	* You also need to set up the `fmtlib` include directory for building as well as linking against `fmtlib`, alternatively use the `FMT_HEADER_ONLY` preprocessor definition.
 64 | * Assertion failures are marked with `noreturn` for the benefit of the static analyzer and optimizer.
 65 | * All logging also written to stderr.
 66 | 	* With colors on supported terminals.
 67 | * Thread-safe.
 68 | * Can be configured to either:
 69 | 	* Flush every `loguru::g_flush_interval_ms` in a background thread
 70 | 	* Flushes output on each call so you won't miss anything even on hard crashes (and still faster than buffered GLOG!).
 71 | * Prefixes each log line with:
 72 | 	* Date and time to millisecond precision.
 73 | 	* Application uptime to millisecond precision.
 74 | 	* Thread name or id (you can set the name with `loguru::set_thread_name`).
 75 | 	* File and line.
 76 | 	* Log level.
 77 | 	* Indentation (see *Scopes*).
 78 | * Error context:
 79 | 	* Catch the values of local variables and print them only on a crash (see *Error context*).
 80 | * Scopes (see *Scopes*).
 81 | * grep:able logs:
 82 | 	* Each line has all the info you need (e.g. date).
 83 | 	* You can easily filter out high verbosity levels after the fact.
 84 | 
 85 | 
 86 | ## Compiling
 87 | 
 88 | Just include <loguru.hpp> where you want to use Loguru.
 89 | Then either compile and link with `loguru.cpp` or in one .cpp file: `#include <loguru.cpp>`
 90 | Make sure you compile with `-std=c++11 -lpthread -ldl` on relevant environments.
 91 | 
 92 | ## CMake Instructions
 93 | 
 94 | Loguru can be added to an existing CMake project in three ways
 95 | 
 96 | 1. `add_subdirectory()`
 97 | 2. `FetchContent()`
 98 | 3. `find_package()`
 99 | 
100 | See [CMake example](./loguru_cmake_example/CMakeLists.txt) for a demonstration.
101 | 
102 | ## Usage
103 | 
104 | ``` C++
105 | #include <loguru.hpp>
106 | 
107 | …
108 | 
109 | // Optional, but useful to time-stamp the start of the log.
110 | // Will also detect verbosity level on command line as -v.
111 | loguru::init(argc, argv);
112 | 
113 | // Put every log message in "everything.log":
114 | loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX);
115 | 
116 | // Only log INFO, WARNING, ERROR and FATAL to "latest_readable.log":
117 | loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO);
118 | 
119 | // Only show most relevant things on stderr:
120 | loguru::g_stderr_verbosity = 1;
121 | 
122 | LOG_SCOPE_F(INFO, "Will indent all log messages within this scope.");
123 | LOG_F(INFO, "I'm hungry for some %.3f!", 3.14159);
124 | LOG_F(2, "Will only show if verbosity is 2 or higher");
125 | VLOG_F(get_log_level(), "Use vlog for dynamic log level (integer in the range 0-9, inclusive)");
126 | LOG_IF_F(ERROR, badness, "Will only show if badness happens");
127 | auto fp = fopen(filename, "r");
128 | CHECK_F(fp != nullptr, "Failed to open file '%s'", filename);
129 | CHECK_GT_F(length, 0); // Will print the value of `length` on failure.
130 | CHECK_EQ_F(a, b, "You can also supply a custom message, like to print something: %d", a + b);
131 | 
132 | // Each function also comes with a version prefixed with D for Debug:
133 | DCHECK_F(expensive_check(x)); // Only checked #if !NDEBUG
134 | DLOG_F(INFO, "Only written in debug-builds");
135 | 
136 | // Turn off writing to stderr:
137 | loguru::g_stderr_verbosity = loguru::Verbosity_OFF;
138 | 
139 | // Turn off writing err/warn in red:
140 | loguru::g_colorlogtostderr = false;
141 | 
142 | // Throw exceptions instead of aborting on CHECK fails:
143 | loguru::set_fatal_handler([](const loguru::Message& message){
144 | 	throw std::runtime_error(std::string(message.prefix) + message.message);
145 | });
146 | ```
147 | 
148 | If you prefer logging with streams:
149 | 
150 | ``` C++
151 | #define LOGURU_WITH_STREAMS 1
152 | #include <loguru.hpp>
153 | ...
154 | LOG_S(INFO) << "Look at my custom object: " << a.cross(b);
155 | CHECK_EQ_S(pi, 3.14) << "Maybe it is closer to " << M_PI;
156 | ```
157 | 
158 | For more info, see [the official documentation](https://emilk.github.io/loguru/index.html).
159 | 
160 | ## Grep:able logs
161 | ``` bash
162 | # Only show warnings, errors and fatal messages:
163 | cat logfile.txt | egrep "[^0-9]\|"
164 | 
165 | # Ignore verbosity-levels 4 and above:
166 | cat logfile.txt | egrep "[^4-9]\|"
167 | 
168 | # Only show verbosity-level 6:
169 | cat logfile.txt | egrep "6\|"
170 | 
171 | # Only show messages from the main thread:
172 | cat logfile.txt | egrep "\[main thread     \]"
173 | ```
174 | 
175 | ## No includes in loguru.hpp
176 | I abhor logging libraries that `#include`'s everything from `iostream` to `windows.h` into every compilation unit in your project. Logging should be frequent in your source code, and thus as lightweight as possible. Loguru's header has *no #includes*. This means it will not slow down the compilation of your project.
177 | 
178 | In a test of a medium-sized project, including `loguru.hpp` instead of `glog/logging.hpp` everywhere gave about 10% speedup in compilation times.
179 | 
180 | Note, however, that this gives you the bare-bones version of Loguru with printf-style logging. If you want `std::ostream` style logging (or GLOG functionality) you need to `#define LOGURU_WITH_STREAMS 1` before `#include <loguru.hpp>`, and that will make `loguru.hpp` include `<sstream>`. No away around it!
181 | 
182 | ## Scopes
183 | The library supports scopes for indenting the log-file. Here's an example:
184 | 
185 | ``` C++
186 | int main(int argc, char* argv[])
187 | {
188 | 	loguru::init(argc, argv);
189 | 	LOG_SCOPE_FUNCTION(INFO);
190 | 	LOG_F(INFO, "Doing some stuff...");
191 | 	for (int i=0; i<2; ++i) {
192 | 		VLOG_SCOPE_F(1, "Iteration %d", i);
193 | 		auto result = some_expensive_operation();
194 | 		LOG_IF_F(WARNING, result == BAD, "Bad result");
195 | 	}
196 | 	LOG_F(INFO, "Time to go!");
197 | 	return 0;
198 | }
199 | ```
200 | 
201 | 
202 | This will output:
203 | 
204 | ```
205 | 	     loguru.cpp:184      0| arguments:       ./loguru_test test -v1
206 | 	     loguru.cpp:185      0| Verbosity level: 1
207 | 	     loguru.cpp:186      0| -----------------------------------
208 | 	loguru_test.cpp:108      0| { int main_test(int, char **)
209 | 	loguru_test.cpp:109      0| .   Doing some stuff...
210 | 	loguru_test.cpp:111      1| .   { Iteration 0
211 | 	loguru_test.cpp:111      1| .   } 0.133 s: Iteration 0
212 | 	loguru_test.cpp:111      1| .   { Iteration 1
213 | 	loguru_test.cpp:113      0| .   .   Bad result
214 | 	loguru_test.cpp:111      1| .   } 0.134 s: Iteration 1
215 | 	loguru_test.cpp:115      0| .   Time to go!
216 | 	loguru_test.cpp:108      0| } 0.267 s: int main_test(int, char **)
217 | ```
218 | 
219 | 
220 | # `ERROR_CONTEXT`
221 | You can also optionally log things ONLY if there is a crash. This is a very useful feature:
222 | 
223 | ```
224 | 	void process_file(const char* filename)
225 | 	{
226 | 		ERROR_CONTEXT("filename", filename);
227 | 		parse_file(filename); // Only if this crashes will filename be logged.
228 | 	}
229 | ```
230 | 
231 | 
232 | ## Streams vs printf
233 | Some logging libraries only supports stream style logging, not printf-style. This means that what in Loguru is:
234 | 
235 | ``` C++
236 | LOG_F(INFO, "Some float: %+05.3f", number);
237 | ```
238 | 
239 | in Glog becomes something along the lines of:
240 | 
241 | ``` C++
242 | LOG(INFO) << "Some float: " << std::setfill('0') << std::setw(5) << std::setprecision(3) << number;
243 | ```
244 | 
245 | Loguru allows you to use whatever style you prefer.
246 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 3.10)
  2 | 
  3 | # --- include useful utility functions
  4 | # ----------------------------------------------------------
  5 | 
  6 | include(cmake/utilities.cmake)
  7 | 
  8 | # --- extract project version
  9 | # ----------------------------------------------------------
 10 | 
 11 | loguru_get_version_from_header() # defines LOGURU_VERSION
 12 | 
 13 | # --- define project and policies
 14 | # ----------------------------------------------------------
 15 | 
 16 | set(_namespace loguru)
 17 | project(loguru VERSION "${LOGURU_VERSION}" LANGUAGES CXX)
 18 | 
 19 | set(LOGURU_PACKAGE_URL     "https://github.com/emilk/loguru"               CACHE STRING "")
 20 | set(LOGURU_PACKAGE_VENDOR  "Emil Ernerfeldt"                               CACHE STRING "")
 21 | set(LOGURU_PACKAGE_CONTACT "Emil Ernerfeldt <emil.ernerfeldt@gmail.com>"   CACHE STRING "")
 22 | set(LOGURU_PACKAGE_DESCRIPTION_SUMMARY "A lightweight C++ logging library" CACHE STRING "")
 23 | set(LOGURU_PACKAGE_DESCRIPTION_FILE    "${PROJECT_SOURCE_DIR}/README.md"   CACHE STRING "")
 24 | 
 25 | # --- check if toplevel or subdirectory
 26 | # ----------------------------------------------------------
 27 | 
 28 | # This variable is set automatically by the project() call in CMake 3.21+
 29 | string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${PROJECT_SOURCE_DIR}" PROJECT_IS_TOP_LEVEL)
 30 | if (PROJECT_IS_TOP_LEVEL)
 31 |   message(STATUS "Configuring ${PROJECT_NAME} as top-level")
 32 | else()
 33 |   message(STATUS "Configuring ${PROJECT_NAME} as sub-directory")
 34 | endif()
 35 | 
 36 | # --- set default build type
 37 | # ----------------------------------------------------------
 38 | 
 39 | # NOTE: when running as a standalone project, we only allow Release & Debug
 40 | #       but as a sub-project we don't want to accidentally pollute the parent
 41 | if (PROJECT_IS_TOP_LEVEL)
 42 |   if(NOT CMAKE_BUILD_TYPE)
 43 |       set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
 44 |   endif()
 45 |   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Release;Debug")
 46 | endif()
 47 | 
 48 | # --- expose cmake-specific user options
 49 | # ----------------------------------------------------------
 50 | 
 51 | option(LOGURU_INSTALL        "Generate the install target(s)" ${PROJECT_IS_TOP_LEVEL})
 52 | option(LOGURU_BUILD_EXAMPLES "Build the project examples"     ${PROJECT_IS_TOP_LEVEL})
 53 | option(LOGURU_BUILD_TESTS    "Build the tests"                ${PROJECT_IS_TOP_LEVEL})
 54 | if (LOGURU_INSTALL)
 55 |   option(LOGURU_CPACK "Generate CPackConfig.cmake" ${PROJECT_IS_TOP_LEVEL})
 56 | endif()
 57 | 
 58 | # --- set global compile flags
 59 | # ----------------------------------------------------------
 60 | 
 61 | if (PROJECT_IS_TOP_LEVEL)
 62 |   # enable ALL warnings for all subsequently defined targets
 63 |   add_compile_options(
 64 |     "$<$<CXX_COMPILER_ID:GNU>:-Wall;-Wextra;-Werror;-pedantic>"
 65 |     "$<$<CXX_COMPILER_ID:Clang>:-Weverything;-Wno-c++98-compat;-Wno-c++98-compat-pedantic>"
 66 |     "$<$<CXX_COMPILER_ID:MSVC>:/W4>"
 67 |   )
 68 | endif()
 69 | 
 70 | # --- add loguru target
 71 | # ----------------------------------------------------------
 72 | 
 73 | add_library(loguru loguru.cpp) # allow BUILD_SHARED_LIBS to decide STATIC/SHARED
 74 | 
 75 | if (NOT PROJECT_IS_TOP_LEVEL)
 76 |   add_library(${_namespace}::loguru ALIAS loguru)
 77 | endif()
 78 | 
 79 | # --- determine if linking 'dl' is required
 80 | # ----------------------------------------------------------
 81 | 
 82 | if (LOGURU_STACKTRACES AND (NOT CMAKE_DL_LIBS))
 83 |   message(WARNING
 84 |     "Stack traces requested but the required 'dl' library was not found. "
 85 |     "LOGURU_STACKTRACES has been automatically disabled (set to 0)"
 86 |   )
 87 |   set(LOGURU_STACKTRACES 0)
 88 | endif()
 89 | 
 90 | if (LOGURU_STACKTRACES)
 91 |   set(_lib_dl_linkflag "-l${CMAKE_DL_LIBS}")
 92 | else()
 93 |   set(_lib_dl_linkflag) # dl dependency is not needed if STACKTRACES=0
 94 | endif()
 95 | 
 96 | # --- set loguru target properties
 97 | # ----------------------------------------------------------
 98 | 
 99 | target_include_directories(loguru
100 |   PUBLIC
101 |     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
102 | )
103 | 
104 | target_compile_features(loguru PUBLIC cxx_std_11)
105 | 
106 | find_package(Threads REQUIRED) # defines IMPORTED target Threads::Threads
107 | target_link_libraries(loguru
108 |   PUBLIC
109 |     Threads::Threads    # pthreads (or equivalent)
110 |     ${_lib_dl_linkflag} # dl (or equivalent)
111 | )
112 | 
113 | set_target_properties(loguru
114 |   PROPERTIES
115 |     VERSION   "${LOGURU_VERSION}"
116 |     SOVERSION "${LOGURU_VERSION_MAJOR}"
117 |     DEBUG_POSTFIX "d"
118 | )
119 | 
120 | target_compile_definitions(loguru
121 |   # NOTE: these generator expressions are dense but the logic is quite simple!
122 |   #       if any of the cache variables are not equal to the empty string, set them as a definition.
123 |   #       Additionally, the "boolean" variables are coerced into a numeric representation (1 or 0)
124 |   PUBLIC
125 |     $<$<NOT:$<STREQUAL:,${LOGURU_EXPORT}>>:LOGURU_EXPORT=${LOGURU_EXPORT}>
126 |     $<$<NOT:$<STREQUAL:,${LOGURU_DEBUG_LOGGING}>>:LOGURU_DEBUG_LOGGING=$<BOOL:${LOGURU_DEBUG_LOGGING}>>
127 |     $<$<NOT:$<STREQUAL:,${LOGURU_DEBUG_CHECKS}>>:LOGURU_DEBUG_CHECKS=$<BOOL:${LOGURU_DEBUG_CHECKS}>>
128 |     $<$<NOT:$<STREQUAL:,${LOGURU_SCOPE_TEXT_SIZE}>>:LOGURU_SCOPE_TEXT_SIZE=${LOGURU_SCOPE_TEXT_SIZE}>
129 |     $<$<NOT:$<STREQUAL:,${LOGURU_REDEFINE_ASSERT}>>:LOGURU_REDEFINE_ASSERT=$<BOOL:${LOGURU_REDEFINE_ASSERT}>>
130 |     $<$<NOT:$<STREQUAL:,${LOGURU_WITH_STREAMS}>>:LOGURU_WITH_STREAMS=$<BOOL:${LOGURU_WITH_STREAMS}>>
131 |     $<$<NOT:$<STREQUAL:,${LOGURU_REPLACE_GLOG}>>:LOGURU_REPLACE_GLOG=$<BOOL:${LOGURU_REPLACE_GLOG}>>
132 |     $<$<NOT:$<STREQUAL:,${LOGURU_USE_FMTLIB}>>:LOGURU_USE_FMTLIB=$<BOOL:${LOGURU_USE_FMTLIB}>>
133 |     $<$<NOT:$<STREQUAL:,${LOGURU_FMT_HEADER_ONLY}>>:LOGURU_FMT_HEADER_ONLY=$<BOOL:${LOGURU_FMT_HEADER_ONLY}>>
134 |     $<$<NOT:$<STREQUAL:,${LOGURU_WITH_FILEABS}>>:LOGURU_WITH_FILEABS=$<BOOL:${LOGURU_WITH_FILEABS}>>
135 |     $<$<NOT:$<STREQUAL:,${LOGURU_STACKTRACES}>>:LOGURU_STACKTRACES=$<BOOL:${LOGURU_STACKTRACES}>>
136 |     $<$<NOT:$<STREQUAL:,${LOGURU_RTTI}>>:LOGURU_RTTI=$<BOOL:${LOGURU_RTTI}>>
137 |     $<$<NOT:$<STREQUAL:,${LOGURU_FILENAME_WIDTH}>>:LOGURU_FILENAME_WIDTH=${LOGURU_FILENAME_WIDTH}>
138 |     $<$<NOT:$<STREQUAL:,${LOGURU_THREADNAME_WIDTH}>>:LOGURU_THREADNAME_WIDTH=${LOGURU_THREADNAME_WIDTH}>
139 |     $<$<NOT:$<STREQUAL:,${LOGURU_SCOPE_TIME_PRECISION}>>:LOGURU_SCOPE_TIME_PRECISION=${LOGURU_SCOPE_TIME_PRECISION}>
140 |     $<$<NOT:$<STREQUAL:,${LOGURU_VERBOSE_SCOPE_ENDINGS}>>:LOGURU_VERBOSE_SCOPE_ENDINGS=$<BOOL:${LOGURU_VERBOSE_SCOPE_ENDINGS}>>
141 | )
142 | 
143 | # --- import and link fmt (if needed)
144 | # ----------------------------------------------------------
145 | 
146 | if (LOGURU_USE_FMTLIB)
147 | 
148 |   message(STATUS "linking to fmt")
149 | 
150 |   if (NOT TARGET fmt::fmt) # only search if not already found in parent scope
151 |     find_package(fmt CONFIG REQUIRED)
152 |   endif()
153 | 
154 |   if (LOGURU_FMT_HEADER_ONLY)
155 |     target_link_libraries(loguru PUBLIC fmt::fmt-header-only)
156 |   else()
157 |     target_link_libraries(loguru PUBLIC fmt::fmt)
158 |   endif()
159 | 
160 |   message(STATUS "linking to fmt - done")
161 | 
162 | endif()
163 | 
164 | # --- set ide-specific properties
165 | # ----------------------------------------------------------
166 | 
167 | # make the project the default when opened in visual studio ide
168 | set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${PROJECT_NAME})
169 | 
170 | # --- setup examples
171 | # ----------------------------------------------------------
172 | 
173 | # TODO: make the examples work with this cmake paradigm
174 | if (LOGURU_BUILD_EXAMPLES)
175 |   message(STATUS "!!! the examples don't work with this cmake build yet")
176 |   # message(STATUS "building examples")
177 | 
178 |   # add_subdirectory(glog_bench)
179 |   # add_subdirectory(glog_example)
180 |   # add_subdirectory(loguru_bench)
181 |   # add_subdirectory(loguru_example)
182 | 
183 |   # message(STATUS "building examples - done")
184 | endif()
185 | 
186 | # --- setup tests
187 | # ----------------------------------------------------------
188 | 
189 | # TODO: make the tests work with this cmake paradigm
190 | if (LOGURU_BUILD_TESTS)
191 |   message(STATUS "!!! the tests don't work with this cmake build yet")
192 |   # message(STATUS "building tests")
193 |   # add_subdirectory(test)
194 |   # message(STATUS "building tests - done")
195 | endif()
196 | 
197 | # --- setup install rules
198 | # ----------------------------------------------------------
199 | 
200 | if (LOGURU_INSTALL)
201 | 
202 |   message(STATUS "generating install rules")
203 | 
204 |   # -- include modules
205 | 
206 |   include(GNUInstallDirs)
207 |   include(CMakePackageConfigHelpers)
208 | 
209 |   # -- expose cache variables for users to customize install location
210 | 
211 |   set(LOGURU_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" CACHE STRING
212 |       "Install directory for cmake files, relative to \${CMAKE_INSTALL_PREFIX} or an absolute path")
213 |   set(LOGURU_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}" CACHE STRING
214 |       "Install directory for libraries, relative to \${CMAKE_INSTALL_PREFIX} or an absolute path")
215 |   set(LOGURU_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE STRING
216 |       "Install directory for include files, relative to \${CMAKE_INSTALL_PREFIX} or an absolute path")
217 |   set(LOGURU_INSTALL_PKGCONFIGDIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE STRING
218 |       "Install directory for pkgconfig (.pc) files, relative to \${CMAKE_INSTALL_PREFIX} or an absolute path")
219 | 
220 |   # -- set additional target properties relevant to install dir
221 | 
222 |   target_include_directories(loguru
223 |     PUBLIC
224 |       $<INSTALL_INTERFACE:${LOGURU_INSTALL_INCLUDEDIR}/loguru>
225 |   )
226 | 
227 |   # -- setup install config files
228 | 
229 |   set(_project_config_file_in  ${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}-config.cmake.in)
230 |   set(_project_config_file_out ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake)
231 |   set(_version_config_file ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake)
232 |   set(_targets_export_name ${PROJECT_NAME}-targets)
233 |   set(_pkgconfig_file_in   ${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}.pc.in)
234 |   set(_pkgconfig_file_out  ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.pc)
235 | 
236 |   # -- Configure pkg-config template
237 | 
238 |   set(_pkgconfig_libdir     "\${exec_prefix}/${LOGURU_INSTALL_LIBDIR}")
239 |   set(_pkgconfig_includedir "\${prefix}/${LOGURU_INSTALL_INCLUDEDIR}")
240 | 
241 |   # if the user chose absolute paths, strip the ${prefix} and/or ${exec_prefix}
242 |   if (IS_ABSOLUTE "${LOGURU_INSTALL_LIBDIR}")
243 |     set(_pkgconfig_libdir "${LOGURU_INSTALL_LIBDIR}")
244 |   endif()
245 | 
246 |   if (IS_ABSOLUTE "${LOGURU_INSTALL_INCLUDEDIR}")
247 |     set(_pkgconfig_includedir "${LOGURU_INSTALL_INCLUDEDIR}")
248 |   endif()
249 | 
250 |   configure_file(
251 |     ${_pkgconfig_file_in}
252 |     ${_pkgconfig_file_out}
253 |     @ONLY
254 |   )
255 | 
256 |   # -- Generate the version file in the build directory
257 | 
258 |   write_basic_package_version_file( # function from CMakePackageConfigHelpers
259 |     ${_version_config_file}
260 |     COMPATIBILITY SameMajorVersion
261 |   )
262 | 
263 |   # -- Generate the config file in the build directory
264 | 
265 |   configure_package_config_file( # function from CMakePackageConfigHelpers
266 |     ${_project_config_file_in}
267 |     ${_project_config_file_out}
268 |     INSTALL_DESTINATION ${LOGURU_INSTALL_CMAKEDIR}
269 |   )
270 | 
271 |   # -- Install the main library
272 | 
273 |   install(TARGETS loguru
274 |     EXPORT ${_targets_export_name}  # Add this target to the 'exports' file
275 |     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}  # .dll, .exe
276 |     ARCHIVE DESTINATION ${LOGURU_INSTALL_LIBDIR} # .lib, .a
277 |     LIBRARY DESTINATION ${LOGURU_INSTALL_LIBDIR} # .so
278 |   )
279 | 
280 |   # -- Install the header file
281 | 
282 |   install(FILES loguru.hpp
283 |     DESTINATION ${LOGURU_INSTALL_INCLUDEDIR}/loguru
284 |   )
285 | 
286 |   # -- Install version and config files
287 | 
288 |   install(FILES  ${_project_config_file_out}  ${_version_config_file}
289 |     DESTINATION ${LOGURU_INSTALL_CMAKEDIR}
290 |   )
291 | 
292 |   # -- Install pkgconfig file
293 | 
294 |   install(FILES ${_pkgconfig_file_out}
295 |     DESTINATION ${LOGURU_INSTALL_PKGCONFIGDIR}
296 |   )
297 | 
298 |   # -- Install target exports file
299 | 
300 |   install(EXPORT ${_targets_export_name}
301 |     NAMESPACE ${_namespace}::
302 |     DESTINATION ${LOGURU_INSTALL_CMAKEDIR}
303 |   )
304 | 
305 |   # -- Install .pdb file (if exists)
306 | 
307 |   if (MSVC AND BUILD_SHARED_LIBS)
308 |     install(FILES $<TARGET_PDB_FILE:loguru>
309 |       CONFIGURATIONS "Debug"
310 |       DESTINATION ${LOGURU_INSTALL_LIBDIR} OPTIONAL
311 |     )
312 |   endif()
313 | 
314 |   message(STATUS "generating install rules - done")
315 | 
316 | endif() # LOGURU_INSTALL
317 | 
318 | 
319 | # -- Setup CPack
320 | # ----------------------------------------------------------
321 | 
322 | if (LOGURU_INSTALL AND LOGURU_CPACK)
323 | 
324 |   message(STATUS "setting up cpack")
325 | 
326 |   # NOTE: this must be the very last instruction in this file
327 |   include(cmake/${PROJECT_NAME}-cpack.cmake)
328 | 
329 |   message(STATUS "setting up cpack - done")
330 | 
331 | endif()
332 | 


--------------------------------------------------------------------------------
/test/loguru_test.cpp:
--------------------------------------------------------------------------------
  1 | // Include loguru first to test that it needs no dependencies:
  2 | #define LOGURU_FILENAME_WIDTH  16
  3 | #define LOGURU_WITH_STREAMS     1
  4 | #define LOGURU_REDEFINE_ASSERT  1
  5 | #define LOGURU_USE_FMTLIB       0
  6 | #define LOGURU_WITH_FILEABS     0
  7 | // #define LOGURU_STACKTRACES      1
  8 | // #define LOGURU_RTTI             1
  9 | #include "../loguru.cpp"
 10 | 
 11 | #include <chrono>
 12 | #include <string>
 13 | #include <thread>
 14 | 
 15 | #include <fstream>
 16 | 
 17 | void the_one_where_the_problem_is(const std::vector<std::string>& v) {
 18 | 	ABORT_F("Abort deep in stack trace, msg: %s", v[0].c_str());
 19 | }
 20 | void deep_abort_1(const std::vector<std::string>& v) { the_one_where_the_problem_is(v); }
 21 | void deep_abort_2(const std::vector<std::string>& v) { deep_abort_1(v); }
 22 | void deep_abort_3(const std::vector<std::string>& v) { deep_abort_2(v); }
 23 | void deep_abort_4(const std::vector<std::string>& v) { deep_abort_3(v); }
 24 | void deep_abort_5(const std::vector<std::string>& v) { deep_abort_4(v); }
 25 | void deep_abort_6(const std::vector<std::string>& v) { deep_abort_5(v); }
 26 | void deep_abort_7(const std::vector<std::string>& v) { deep_abort_6(v); }
 27 | void deep_abort_8(const std::vector<std::string>& v) { deep_abort_7(v); }
 28 | void deep_abort_9(const std::vector<std::string>& v) { deep_abort_8(v); }
 29 | void deep_abort_10(const std::vector<std::string>& v) { deep_abort_9(v); }
 30 | 
 31 | void sleep_ms(int ms)
 32 | {
 33 | 	LOG_F(3, "Sleeping for %d ms", ms);
 34 | 	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
 35 | }
 36 | 
 37 | void test_thread_names()
 38 | {
 39 | 	LOG_SCOPE_FUNCTION(INFO);
 40 | 
 41 | 	{
 42 | 		char thread_name[17];
 43 | 		loguru::get_thread_name(thread_name, sizeof(thread_name), false);
 44 | 		LOG_F(INFO, "Hello from main thread ('%s')", thread_name);
 45 | 	}
 46 | 
 47 | 	auto a = std::thread([](){
 48 | 		char thread_name[17];
 49 | 		loguru::get_thread_name(thread_name, sizeof(thread_name), false);
 50 | 		LOG_F(INFO, "Hello from nameless thread ('%s')", thread_name);
 51 | 	});
 52 | 
 53 | 	auto b = std::thread([](){
 54 | 		loguru::set_thread_name("renderer");
 55 | 		char thread_name[17];
 56 | 		loguru::get_thread_name(thread_name, sizeof(thread_name), false);
 57 | 		LOG_F(INFO, "Hello from render thread ('%s')", thread_name);
 58 | 	});
 59 | 
 60 | 	auto c = std::thread([](){
 61 | 		loguru::set_thread_name("abcdefghijklmnopqrstuvwxyz");
 62 | 		char thread_name[17];
 63 | 		loguru::get_thread_name(thread_name, sizeof(thread_name), false);
 64 | 		LOG_F(INFO, "Hello from thread with a very long name ('%s')", thread_name);
 65 | 	});
 66 | 
 67 | 	a.join();
 68 | 	b.join();
 69 | 	c.join();
 70 | }
 71 | 
 72 | void test_scopes()
 73 | {
 74 | 	LOG_SCOPE_FUNCTION(INFO);
 75 | 
 76 | 	LOG_F(INFO, "Should be indented one step");
 77 | 	LOG_F(1, "First thing");
 78 | 	LOG_F(1, "Second thing");
 79 | 
 80 | 	{
 81 | 		LOG_SCOPE_F(1, "Some indentation at level 1");
 82 | 		LOG_F(INFO, "Should only be indented one more step iff verbosity is 1 or higher");
 83 | 		LOG_F(2, "Some info");
 84 | 		sleep_ms(123);
 85 | 	}
 86 | 
 87 | 	sleep_ms(64);
 88 | }
 89 | 
 90 | void test_levels()
 91 | {
 92 | 	LOG_SCOPE_FUNCTION(INFO);
 93 | 	{
 94 | 		VLOG_SCOPE_F(1, "Scope with verbosity 1");
 95 | 		LOG_F(3,       "Only visible with -v 3 or higher");
 96 | 		LOG_F(2,       "Only visible with -v 2 or higher");
 97 | 		LOG_F(1,       "Only visible with -v 1 or higher");
 98 | 	}
 99 | 	LOG_F(0,       "LOG_F(0)");
100 | 	LOG_F(INFO,    "This is some INFO");
101 | 	LOG_F(WARNING, "This is a WARNING");
102 | 	LOG_F(ERROR,   "This is a serious ERROR");
103 | }
104 | 
105 | #if LOGURU_WITH_STREAMS
106 | void test_stream()
107 | {
108 | 	LOG_SCOPE_FUNCTION(INFO);
109 | 	LOG_S(INFO) << "Testing stream-logging.";
110 | 	LOG_S(INFO) << "First line" << std::endl << "Seconds line.";
111 | 	LOG_S(1) << "Stream-logging with verbosity 1";
112 | 	LOG_S(2) << "Stream-logging with verbosity 2";
113 | 	LOG_S(3) << "Stream-logging with verbosity 3";
114 | 	LOG_IF_S(INFO, true) << "Should be visible";
115 | 	LOG_IF_S(INFO, false) << "SHOULD NOT BE VISIBLE";
116 | 	LOG_IF_S(1, true) << "Should be visible if verbosity is at least 1";
117 | 	LOG_IF_S(1, false) << "SHOULD NOT BE VISIBLE";
118 | 	CHECK_LT_S(1, 2);
119 | 	CHECK_GT_S(3, 2) << "Weird";
120 | }
121 | #endif
122 | 
123 | int some_expensive_operation() { static int r=31; sleep_ms(132); return r++; }
124 | const int BAD = 32;
125 | 
126 | int always_increasing() { static int x = 0; return x++; }
127 | 
128 | int main_test(int argc, char* argv[])
129 | {
130 | 	loguru::init(argc, argv);
131 | 	LOG_SCOPE_FUNCTION(INFO);
132 | 	LOG_F(INFO, "Doing some stuff...");
133 | 	for (int i=0; i<2; ++i) {
134 | 		LOG_SCOPE_F(1, "Iteration %d", i);
135 | 		auto result = some_expensive_operation();
136 | 		LOG_IF_F(WARNING, result == BAD, "Bad result");
137 | 	}
138 | 	LOG_F(INFO, "Time to go!");
139 | 
140 | 	return 0;
141 | }
142 | 
143 | void test_SIGSEGV_0()
144 | {
145 | 	LOG_F(INFO, "Intentionally writing to nullptr:");
146 | 	int* ptr = nullptr;
147 | 	*ptr = 42;
148 | 	LOG_F(FATAL, "We shouldn't get here");
149 | }
150 | void test_SIGSEGV_1() { test_SIGSEGV_0(); }
151 | void test_SIGSEGV_2() { test_SIGSEGV_1(); }
152 | 
153 | void test_abort_0()
154 | {
155 | 	LOG_F(INFO, "Calling std::abort");
156 | 	std::abort();
157 | }
158 | void test_abort_1() { test_abort_0(); }
159 | void test_abort_2() { test_abort_1(); }
160 | 
161 | struct CustomType
162 | {
163 | 	std::string contents;
164 | };
165 | 
166 | namespace loguru {
167 | Text ec_to_text(const CustomType* custom)
168 | {
169 | 	return Text(strdup(custom->contents.c_str()));
170 | }
171 | } // namespace loguru
172 | 
173 | void test_error_contex()
174 | {
175 | 	{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
176 | 	ERROR_CONTEXT("Parent thread value", 42);
177 | 	{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
178 | 	char parent_thread_name[17];
179 | 	loguru::get_thread_name(parent_thread_name, sizeof(parent_thread_name), false);
180 | 	ERROR_CONTEXT("Parent thread name", &parent_thread_name[0]);
181 | 
182 | 	const auto parent_ec_handle = loguru::get_thread_ec_handle();
183 | 
184 | 	std::thread([=]{
185 | 		loguru::set_thread_name("EC test thread");
186 | 		ERROR_CONTEXT("parent error context", parent_ec_handle);
187 | 		{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
188 | 		ERROR_CONTEXT("const char*",       "test string");
189 | 		ERROR_CONTEXT("integer",           42);
190 | 		ERROR_CONTEXT("float",              3.14f);
191 | 		ERROR_CONTEXT("double",             3.14);
192 | 		{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
193 | 		ERROR_CONTEXT("char A",            'A');
194 | 		ERROR_CONTEXT("char backslash",    '\\');
195 | 		ERROR_CONTEXT("char double-quote", '\"');
196 | 		ERROR_CONTEXT("char single-quote", '\'');
197 | 		ERROR_CONTEXT("char zero",         '\0');
198 | 		ERROR_CONTEXT("char bell",         '\b');
199 | 		ERROR_CONTEXT("char feed",         '\f');
200 | 		ERROR_CONTEXT("char newline",      '\n');
201 | 		ERROR_CONTEXT("char return",       '\r');
202 | 		ERROR_CONTEXT("char tab",          '\t');
203 | 		ERROR_CONTEXT("char x13",          '\u0013');
204 | 		{ ERROR_CONTEXT("THIS SHOULDN'T BE PRINTED", "scoped"); }
205 | 		CustomType custom{"custom_contents"};
206 | 		ERROR_CONTEXT("CustomType", &custom);
207 | 		ABORT_F("Intentional abort");
208 | 	}).join();
209 | }
210 | 
211 | void test_hang_0()
212 | {
213 | 	LOG_F(INFO, "Press ctrl-C to kill.");
214 | 	for(;;) {
215 | 		// LOG_F(INFO, "Press ctrl-C to break out of this infinite loop.");
216 | 	}
217 | }
218 | void test_hang_1() { test_hang_0(); }
219 | void test_hang_2() { test_hang_1(); }
220 | 
221 | void throw_on_fatal()
222 | {
223 | 	loguru::set_fatal_handler([](const loguru::Message& message){
224 | 		LOG_F(INFO, "Throwing exception...");
225 | 		throw std::runtime_error(std::string(message.prefix) + message.message);
226 | 	});
227 | 	{
228 | 		LOG_SCOPE_F(INFO, "CHECK_F throw + catch");
229 | 		try {
230 | 			CHECK_F(false, "some CHECK_F message");
231 | 		} catch (std::runtime_error& e) {
232 | 			LOG_F(INFO, "CHECK_F threw this: '%s'", e.what());
233 | 		}
234 | 	}
235 | #if LOGURU_WITH_STREAMS
236 | 	{
237 | 		LOG_SCOPE_F(INFO, "CHECK_S throw + catch");
238 | 		try {
239 | 			CHECK_S(false) << "Some CHECK_S message";
240 | 		} catch (std::runtime_error& e) {
241 | 			LOG_F(INFO, "CHECK_S threw this: '%s'", e.what());
242 | 		}
243 | 	}
244 | 	LOG_F(INFO, "Trying an uncaught exception:");
245 | 	CHECK_S(false);
246 | #else
247 | 	CHECK_F(false);
248 | #endif // LOGURU_WITH_STREAMS
249 | }
250 | 
251 | void throw_on_signal()
252 | {
253 | 	loguru::set_fatal_handler([](const loguru::Message& message){
254 | 		LOG_F(INFO, "Throwing exception...");
255 | 		throw std::runtime_error(std::string(message.prefix) + message.message);
256 | 	});
257 | 	test_SIGSEGV_0();
258 | }
259 | 
260 | // void die(std::ofstream& of)
261 | // {
262 | // 	(void)of;
263 | // 	test_hang_2();
264 | // }
265 | 
266 | // ----------------------------------------------------------------------------
267 | 
268 | struct CallbackTester
269 | {
270 | 	size_t num_print = 0;
271 | 	size_t num_flush = 0;
272 | 	size_t num_close = 0;
273 | };
274 | 
275 | void callbackPrint(void* user_data, const loguru::Message& message)
276 | {
277 | 	printf("Custom callback: %s%s\n", message.prefix, message.message);
278 | 	reinterpret_cast<CallbackTester*>(user_data)->num_print += 1;
279 | }
280 | 
281 | void callbackFlush(void* user_data)
282 | {
283 | 	printf("Custom callback flush\n");
284 | 	reinterpret_cast<CallbackTester*>(user_data)->num_flush += 1;
285 | }
286 | 
287 | void callbackClose(void* user_data)
288 | {
289 | 	printf("Custom callback close\n");
290 | 	reinterpret_cast<CallbackTester*>(user_data)->num_close += 1;
291 | }
292 | 
293 | void test_log_callback()
294 | {
295 | 	CallbackTester tester;
296 | 	loguru::add_callback(
297 | 		"user_callback", callbackPrint, &tester,
298 | 		loguru::Verbosity_INFO, callbackClose, callbackFlush);
299 | 	CHECK_EQ_F(tester.num_print, 0u);
300 | 	LOG_F(INFO, "Test print");
301 | 	CHECK_EQ_F(tester.num_print, 1u);
302 | 	CHECK_EQ_F(tester.num_close, 0u);
303 | 	CHECK_EQ_F(tester.num_flush, 1u);
304 | 	loguru::flush();
305 | 	CHECK_EQ_F(tester.num_flush, 2u);
306 | 	loguru::remove_callback("user_callback");
307 | 	CHECK_EQ_F(tester.num_close, 1u);
308 | }
309 | 
310 | #if defined _WIN32 && defined _DEBUG
311 | #define USE_WIN_DBG_HOOK
312 | static int winDbgHook(int reportType, char *message, int *)
313 | {
314 | 	fprintf(stderr, "Report type: %d\nMessage: %s\n", reportType,
315 | 					(nullptr != message ? message : "nullptr message"));
316 | 	return 1; // To prevent the Abort, Retry, Ignore dialog
317 | }
318 | #endif
319 | 
320 | // ----------------------------------------------------------------------------
321 | 
322 | int main(int argc, char* argv[])
323 | {
324 | #ifdef USE_WIN_DBG_HOOK
325 | 	_CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, winDbgHook);
326 | #endif
327 | 
328 | 	// loguru::g_preamble = false;
329 | 
330 | 	if (argc > 1 && argv[1] == std::string("test"))
331 | 	{
332 | 		return main_test(argc, argv);
333 | 	}
334 | 
335 | 	loguru::init(argc, argv);
336 | 
337 | 	// auto verbose_type_name = loguru::demangle(typeid(std::ofstream).name());
338 | 	// loguru::add_stack_cleanup(verbose_type_name.c_str(), "std::ofstream");
339 | 	// std::ofstream os;
340 | 	// die(os);
341 | 
342 | 	if (argc == 1)
343 | 	{
344 | 		loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO);
345 | 		loguru::add_file("everything.log",      loguru::Append,   loguru::Verbosity_MAX);
346 | #ifdef LOGURU_SYSLOG
347 | 		loguru::add_syslog("loguru_test",       loguru::Verbosity_MAX);
348 | #endif
349 | 
350 | 		LOG_F(INFO, "Loguru test");
351 | 		test_thread_names();
352 | 
353 | 		test_scopes();
354 | 		test_levels();
355 | 		#if LOGURU_WITH_STREAMS
356 | 		test_stream();
357 | 		#endif
358 | 
359 | 		loguru::shutdown();
360 | 
361 | 		LOG_F(INFO, "goes to stderr, but not to file");
362 | 	}
363 | 	else
364 | 	{
365 | 		std::string test = argv[1];
366 | 		if (test == "ABORT_F") {
367 | 			ABORT_F("ABORT_F format message");
368 | 		} else if (test == "ABORT_S") {
369 | 			ABORT_S() << "ABORT_S stream message";
370 | 		} else if (test == "assert") {
371 | 			const char* ptr = nullptr;
372 | 			(void)ptr;
373 | 			assert(ptr && "Error that was unexpected");
374 | 		} else if (test == "LOG_F_FATAL") {
375 | 			LOG_F(FATAL, "Fatal format message");
376 | 		} else if (test == "LOG_S_FATAL") {
377 | 			LOG_S(FATAL) << "Fatal stream message";
378 | 		} else if (test == "CHECK_NOTNULL_F") {
379 | 			const char* ptr = nullptr;
380 | 			CHECK_NOTNULL_F(ptr);
381 | 		} else if (test == "CHECK_F") {
382 | 			CHECK_F(1 > 2);
383 | 		} else if (test == "CHECK_EQ_F") {
384 | 			CHECK_EQ_F(always_increasing(),  0);
385 | 			CHECK_EQ_F(always_increasing(),  1);
386 | 			CHECK_EQ_F(always_increasing(), 42);
387 | 		} else if (test == "CHECK_EQ_F_int") {
388 | 			int x = 42;
389 | 			CHECK_EQ_F(x, x + 1);
390 | 		} else if (test == "CHECK_EQ_F_unsigned") {
391 | 			unsigned x = 42;
392 | 			CHECK_EQ_F(x, x + 1);
393 | 		} else if (test == "CHECK_EQ_F_size_t") {
394 | 			size_t x = 42;
395 | 			CHECK_EQ_F(x, x + 1);
396 | 		} else if (test == "CHECK_EQ_F_message") {
397 | 			CHECK_EQ_F(always_increasing(),  0, "Should pass");
398 | 			CHECK_EQ_F(always_increasing(),  1, "Should pass");
399 | 			CHECK_EQ_F(always_increasing(), 42, "Should fail");
400 | 		} else if (test == "CHECK_EQ_S") {
401 | 			std::string str = "right";
402 | 			CHECK_EQ_F(str, "wrong", "Expected to fail, since `str` isn't \"wrong\" but \"%s\"", str.c_str());
403 | 		} else if (test == "CHECK_LT_S") {
404 | 			CHECK_EQ_F(always_increasing(), 0);
405 | 			CHECK_EQ_F(always_increasing(), 1);
406 | 			CHECK_EQ_F(always_increasing(), 42);
407 | 		} else if (test == "CHECK_LT_S_message") {
408 | 			CHECK_EQ_F(always_increasing(),  0, "Should pass");
409 | 			CHECK_EQ_F(always_increasing(),  1, "Should pass");
410 | 			CHECK_EQ_F(always_increasing(), 42, "Should fail!");
411 | 		} else if (test == "deep_abort") {
412 | 			deep_abort_10({"deep_abort"});
413 | 		} else if (test == "SIGSEGV") {
414 | 			test_SIGSEGV_2();
415 | 		} else if (test == "abort") {
416 | 			test_abort_2();
417 | 		} else if (test == "error_context") {
418 | 			test_error_contex();
419 | 		} else if (test == "throw_on_fatal") {
420 | 			throw_on_fatal();
421 | 		} else if (test == "throw_on_signal") {
422 | 			throw_on_signal();
423 | 		} else if (test == "callback") {
424 | 			test_log_callback();
425 | 		} else if (test == "hang") {
426 | 			loguru::add_file("hang.log", loguru::Truncate, loguru::Verbosity_INFO);
427 | 			test_hang_2();
428 | 		} else {
429 | 			LOG_F(ERROR, "Unknown test: '%s'", test.c_str());
430 | 		}
431 | 	}
432 | }
433 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
  1 | <meta charset="utf-8">
  2 | 
  3 | # Loguru
  4 | This document contains the official documentation of Loguru, a lightweight and flexible C++ logging library. This documentations is not 100% complete. Read the `loguru.hpp` for more details.
  5 | 
  6 | The official project homepage of Loguru is at https://github.com/emilk/loguru.
  7 | 
  8 | Loguru provides a set of functions and macros to aid logging to one or several files and/or to `stderr`. It prefixes each log line with useful information such as time.
  9 | 
 10 | # Getting started
 11 | Download `loguru.hpp` and `loguru.cpp` from https://github.com/emilk/loguru. To use Loguru in any file, simply `#include <loguru.hpp>`. Then either compile and link with `loguru.cpp` or add `#include <loguru.cpp>` to one of your `.cpp` files.
 12 | 
 13 | Loguru uses C++11, so make sure you compile with `-std=c++11`. On Linux you also need the following linker flags: `-lpthread -ldl`.
 14 | 
 15 | Now you are ready to use Loguru! Here is a simple example:
 16 | 
 17 | ``` C++
 18 | 	#include <loguru.cpp>
 19 | 
 20 | 	int main_test(int argc, char* argv[])
 21 | 	{
 22 | 		loguru::init(argc, argv);
 23 | 		loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX);
 24 | 		LOG_F(INFO, "Hello log file!");
 25 | 		return 0;
 26 | 	}
 27 | ```
 28 | 
 29 | ## A slightly more advanced example
 30 | `main.cpp`:
 31 | 
 32 | ``` C++
 33 | 	#include <chrono>
 34 | 	#include <thread>
 35 | 
 36 | 	#include <loguru.cpp>
 37 | 
 38 | 	void sleep_ms(int ms)
 39 | 	{
 40 | 		VLOG_F(2, "Sleeping for %d ms", ms);
 41 | 		std::this_thread::sleep_for(std::chrono::milliseconds(ms));
 42 | 	}
 43 | 
 44 | 	void complex_calculation()
 45 | 	{
 46 | 		LOG_SCOPE_F(INFO, "complex_calculation");
 47 | 		LOG_F(INFO, "Starting time machine...");
 48 | 		sleep_ms(200);
 49 | 		LOG_F(WARNING, "The flux capacitor is not getting enough power!");
 50 | 		sleep_ms(400);
 51 | 		LOG_F(INFO, "Lighting strike!");
 52 | 		VLOG_F(1, "Found 1.21 gigawatts...");
 53 | 		sleep_ms(400);
 54 | 		std::thread([](){
 55 | 			loguru::set_thread_name("the past");
 56 | 			LOG_F(ERROR, "We ended up in 1985!");
 57 | 		}).join();
 58 | 	}
 59 | 
 60 | 	int main(int argc, char* argv[])
 61 | 	{
 62 | 	    loguru::init(argc, argv);
 63 | 	    LOG_F(INFO, "Hello from main.cpp!");
 64 | 	    complex_calculation();
 65 | 	    LOG_F(INFO, "main function about to end!");
 66 | 	}
 67 | ```
 68 | 
 69 | ``` bash
 70 | 	g++ -std=c++11 main.cpp -o loguru_example
 71 | 	./loguru_example -v 1
 72 | ```
 73 | 
 74 | Output:
 75 | ![Notice how the color matches the verbosity level (`0 = INFO`)](terminal_colors.png)
 76 | 
 77 | 
 78 | ## Older versions
 79 | Before Loguru 2.0 was released in 2018, Loguru consisted of a single `loguru.hpp` header. If you are still using that version (and for some reason don't want to upgrade), this is how you use it:
 80 | 
 81 | In ONE `.cpp` file you need to add this:
 82 | 
 83 | ``` C++
 84 | 	#define LOGURU_IMPLEMENTATION
 85 | 	#include <loguru.hpp>
 86 | ```
 87 | 
 88 | That's it! Most of this documentation will still apply the same.
 89 | 
 90 | 
 91 | # How Loguru works
 92 | ## Outputs and verbosity
 93 | Loguru has several outputs. By default, Loguru logs everything to `stderr` and nowhere else. You can add files to write to using `loguru::add_file`. Each output (`stderr` and files) has a *verbosity level* attached to it. Each time you log something, you also pick a verbosity level, for instance `INFO` or `ERROR`. This way you can have one log file where only the most important messages go (e.g. `WARNING`s and `ERROR`s) and another where all logging goes. You can control the verbosity level of `stderr` either from code (with `loguru::g_stderr_verbosity`) or from the command line arguments with the `-v` flags.
 94 | 
 95 | 
 96 | *************************************************************
 97 | * .---------.                                               *
 98 | * | LOG_F   +->+                      .-------.             *
 99 | * '---------'  |                  +->| stderr  |            *
100 | *              |                  |   '-------'             *
101 | * .---------.  |                  |   .------------------.  *
102 | * | CHECK_F +->+      _________   +->| optional callback  | *
103 | * '---------'  |     /        /   |   '------------------'  *
104 | *              +->-++ Loguru ++---+   .-------.             *
105 | * .---------.  |   /________/     +->| file 1  |            *
106 | * | ABORT_F +->+                  |   '-------'             *
107 | * '---------'  |                  |   .---------.           *
108 | *              |                  +->| file 2 …  |          *
109 | * .---------.  |                      '---------'           *
110 | * | Crash   +->+                                            *
111 | * '---------'                                               *
112 | *************************************************************
113 | 
114 | 
115 | # Logging
116 | ## Verbosity levels
117 | Loguru has a hierarchy of verbosity levels:
118 | 
119 | * FATAL (caused by failed checks, signals or calls to ABORT_F)
120 | * ERROR (= -2)
121 | * WARNING (= -1)
122 | * INFO (= 0)
123 | * 1-9
124 | 
125 | When calling a log function you must pick one of the above log levels (except FATAL). Loguru will then only process it (write to `stderr`, a file, or your custom callbacks) if the verbosity is below the cutoff for that output. For instance, by default only INFO, WARNING and ERROR is written to `stderr`.
126 | 
127 | A common approach is to print only high-verbosity things to `stderr`, but write everything to a logfile.
128 | 
129 | ## Log functions
130 | 
131 | ### `LOG_F(verbosity_name, fmt, ...)`
132 | The first and foremost logging function is `LOG_F` which looks like this.
133 | 
134 | ``` C++
135 | 	LOG_F(INFO, "Warming up %d lasers", 3);
136 | 	LOG_F(WARNING, "%s is an old code, but it checks out", code_id);
137 | 	LOG_F(ERROR, "The hyperdrive doesn't work");
138 | ```
139 | 
140 | You can pass any number of arguments to `LOG_F` just like with `printf`. On modern compilers you will get compile-time checking of the argument number and types.
141 | 
142 | Those are the named verbosity levels, and those you will most often use. However, sometimes you may want to log some details that you may very seldom be interested in. For this you can pick an integer verbosity level in the range 0-9 (inclusive). `0` is identical with `INFO`. A higher number means "more verbose", e.g. "more likely to be irrelevant". Example:
143 | 
144 | ``` C++
145 | 	LOG_F(1, "This may be important, but probably not");
146 | 	LOG_F(9, "Nobody will ever care about this.");
147 | ```
148 | 
149 | If you want to pick verbosity level dynamically, use the `VLOG_F` function.
150 | 
151 | ### `VLOG_F(verbosity, fmt, ...)`
152 | This is for when you want a dynamic verbosity, i.e. an verbosity derived from a function call:
153 | ``` C++
154 | 	VLOG_F(is_vip(guest) ? 0 : 9, "%s has entered the room", guest);
155 | 
156 | 	loguru::Verbosity verbosity = 5; // Higher = less likely to be printed
157 | 	VLOG_F(verbosity, "...");
158 | 
159 | 	verbosity = loguru::Verbosity_WARNING;
160 | 	VLOG_F(verbosity, "...");
161 | ```
162 | 
163 | ### `LOG_IF_F(verbosity_name, condition, fmt, ...)`
164 | Conditionally log something.
165 | ``` C++
166 | 	LOG_IF_F(WARNING, value == invalid, "Invalid value: %d", value);
167 | 
168 | 	// Equivalent to:
169 | 	if (value == invalid) {
170 | 		LOG_F(WARNING, "Invalid value: %d", value);
171 | 	}
172 | ```
173 | 
174 | ### `RAW_LOG_F(verbosity_name, fmt, ...)`
175 | Log something without the usual prefix of date, time, file etc.
176 | 
177 | 
178 | ### All logging functions
179 | There are also combinations of the `RAW`, `IF`, and `V` versions. Here is the complete list:
180 | 
181 | ``` C++
182 | 	LOG_F(verbosity_name, fmt, ...)
183 | 	VLOG_F(verbosity, fmt, ...)
184 | 	LOG_IF_F(verbosity_name, cond, fmt, ...)
185 | 	VLOG_IF_F(verbosity, cond, fmt, ...)
186 | 	RAW_LOG_F(verbosity_name, fmt, ...)
187 | 	RAW_VLOG_F(verbosity, fmt, ...)
188 | ```
189 | 
190 | ### Debug-only logging:
191 | In addition, there are variants who only log in debug builds (and/or when `LOGURU_DEBUG_LOGGING=1`):
192 | 
193 | ``` C++
194 | 	DLOG_F(verbosity_name, fmt, ...)
195 | 	DVLOG_F(verbosity, fmt, ...)
196 | 	DLOG_IF_F(verbosity_name, cond, fmt, ...)
197 | 	DVLOG_IF_F(verbosity, cond, fmt, ...)
198 | 	DRAW_LOG_F(verbosity_name, fmt, ...)
199 | 	DRAW_VLOG_F(verbosity, fmt, ...)
200 | ```
201 | 
202 | ## Log scopes
203 | Loguru has the concept of *log scopes*. This is a way to indent you logging to make them more readable. This is great for readability of your log files. Here's an example:
204 | 
205 | ``` C++
206 | 	int main(int argc, char* argv[])
207 | 	{
208 | 		loguru::init(argc, argv);
209 | 		LOG_SCOPE_FUNCTION(INFO);
210 | 		LOG_F(INFO, "Doing some stuff...");
211 | 		for (int i=0; i<2; ++i) {
212 | 			VLOG_SCOPE_F(1, "Iteration %d", i);
213 | 			auto result = some_expensive_operation();
214 | 			LOG_IF_F(WARNING, result == BAD, "Bad result");
215 | 		}
216 | 		LOG_F(INFO, "Time to go!");
217 | 		return 0;
218 | 	}
219 | ```
220 | 
221 | This will output:
222 | 
223 | ```
224 | 	     loguru.cpp:184      0| arguments:       ./loguru_test test -v1
225 | 	     loguru.cpp:185      0| Verbosity level: 1
226 | 	     loguru.cpp:186      0| -----------------------------------
227 | 	loguru_test.cpp:108      0| { int main_test(int, char **)
228 | 	loguru_test.cpp:109      0| .   Doing some stuff...
229 | 	loguru_test.cpp:111      1| .   { Iteration 0
230 | 	loguru_test.cpp:111      1| .   } 0.133 s: Iteration 0
231 | 	loguru_test.cpp:111      1| .   { Iteration 1
232 | 	loguru_test.cpp:113      0| .   .   Bad result
233 | 	loguru_test.cpp:111      1| .   } 0.134 s: Iteration 1
234 | 	loguru_test.cpp:115      0| .   Time to go!
235 | 	loguru_test.cpp:108      0| } 0.267 s: int main_test(int, char **)
236 | ```
237 | 
238 | 
239 | Here are the LOG_SCOPE family of functions:
240 | ``` C++
241 | 	LOG_SCOPE_F(verbosity_name, fmt, ...)
242 | 	VLOG_SCOPE_F(name, fmt, ...)
243 | 	LOG_SCOPE_FUNCTION(verbosity_name)  // Logs the name of the current function.
244 | ```
245 | 
246 | Scopes affects logging on all threads.
247 | 
248 | 
249 | ## Logging with streams
250 | By default, Loguru will only let you log with `printf`-style formatting. If you prefer to use C++-style stream logging you need to define `LOGURU_WITH_STREAMS=1` (e.g. set `#define LOGURU_WITH_STREAMS 1` before including `loguru.hpp` or pass `-DLOGURU_WITH_STREAMS=1` to your compiler).
251 | 
252 | This will enable new logging functions with `_S` suffixes:
253 | 
254 | ```
255 | 	LOG_S(INFO) << "Look at my custom object: " << a.cross(b);
256 | 	CHECK_EQ_S(pi, 3.14) << "Maybe it is closer to " << M_PI;
257 | ```
258 | 
259 | Here are all the stream logging functions:
260 | 
261 | ``` C++
262 | 	VLOG_IF_S(verbosity, cond) << ...
263 | 	LOG_IF_S(verbosity_name, cond) << ...
264 | 	VLOG_S(verbosity) << ...
265 | 	LOG_S(verbosity_name) << ...
266 | 	DVLOG_IF_S(verbosity, cond) << ...
267 | 	DLOG_IF_S(verbosity_name, cond) << ...
268 | 	DVLOG_S(verbosity) << ...
269 | 	DLOG_S(verbosity_name) << ...
270 | ```
271 | 
272 | ## Notes
273 | 	* Any arguments to LOG functions or LOG_SCOPE are only evaluated iff the verbosity test passes.
274 | 	* Any arguments to LOG_IF functions are only evaluated if the test passes.
275 | 
276 | 
277 | # Logging crashes
278 | One of the most important parts of any logging library is to log things when they go horribly wrong. In Loguru, we call this *FATAL* logging. This can be caused by CHECK fails, signals or manual aborts.
279 | 
280 | When they happen, Loguru will:
281 | 
282 | * Print the cause of the fatality
283 | * Print the error context (see separate chapter)
284 | * Print a stack trace
285 | * Call any installed fatal handler (see `set_fatal_handler`).
286 | * Abort your program (unless your fatal handler chose to instead throw an exception).
287 | 
288 | Let's examine all the causes for FATALs:
289 | 
290 | ## CHECKS
291 | Loguru can also do runtime checks which are similar to [`assert`](http://en.cppreference.com/w/cpp/error/assert) but far more powerful. In particular, by default Loguru will run the checks in release builds as well as debug builds, and helpful and descriptive errors will be logged when a check fails. Here is a simple example of some checks:
292 | 
293 | ``` C++
294 | 	CHECK_F(list.empty(), "Expected empty list, but list has %lu elements in it", list.size());
295 | 	CHECK_NOTNULL_F(some_pointer);
296 | 	CHECK_GT_F(number, 0, "Expected a positive integer");
297 | ```
298 | 
299 | ### Variants
300 | ``` C++
301 | 	CHECK_F(test, ...)
302 | 	CHECK_NOTNULL_F(x, ...)
303 | 	CHECK_EQ_F(a, b, ...)
304 | 	CHECK_NE_F(a, b, ...)
305 | 	CHECK_LT_F(a, b, ...)
306 | 	CHECK_LE_F(a, b, ...)
307 | 	CHECK_GT_F(a, b, ...)
308 | 	CHECK_GE_F(a, b, ...)
309 | ```
310 | 
311 | You also have debug-versions of these:
312 | ``` C++
313 | 	DCHECK_F(test, ...)
314 | 	DCHECK_NOTNULL_F(x, ...)
315 | 	DCHECK_EQ_F(a, b, ...)
316 | 	DCHECK_NE_F(a, b, ...)
317 | 	DCHECK_LT_F(a, b, ...)
318 | 	DCHECK_LE_F(a, b, ...)
319 | 	DCHECK_GT_F(a, b, ...)
320 | 	DCHECK_GE_F(a, b, ...)
321 | ```
322 | 
323 | These can be used to run a check ONLY in debug build (or when `LOGURU_DEBUG_CHECKS` is defined).
324 | 
325 | ### Format string
326 | The format string to CHECK:s are optional. All these work:
327 | 
328 | ``` C++
329 | 	CHECK_F(exists(filename));
330 | 	CHECK_F(exists(filename), "File does not exist");
331 | 	CHECK_F(exists(filename), "File does not exist: '%s'", filename);
332 | ```
333 | 
334 | Arguments to CHECK:s are only evaluated once.
335 | 
336 | ## `ABORT_F`
337 | You can also call `ABORT_F` to abort your program with a message written to the log: `ABORT_F("Something went wrong wile processing '%s'", filename);`
338 | 
339 | ## Signals
340 | By calling `loguru::init` Loguru will also catch signals such as segmentation errors and divisions by zero. Here is the full list of signals caught by Loguru:
341 | 
342 | * `SIGABRT`
343 | * `SIGBUS`
344 | * `SIGFPE`
345 | * `SIGILL`
346 | * `SIGINT`
347 | * `SIGSEGV`
348 | * `SIGTERM`
349 | 
350 | You can control which signals are caught by the options passed to `loguru::init`.
351 | 
352 | ## Error context
353 | A stack trace gives you the names of the function at the point of a crash. With `ERROR_CONTEXT`, you can also get the values of select local variables. `ERROR_CONTEXT` is in effect a logging that only occurs if there is a crash.
354 | 
355 | Usage:
356 | 
357 | ``` C++
358 | void process_customers(const std::string& filename)
359 | {
360 |     ERROR_CONTEXT("Processing file", filename.c_str());
361 |     for (size_t i = 0; i < num_customers; ++i) {
362 | 	    ERROR_CONTEXT("Customer index", i);
363 | 	    if (i == 42) { crashy_code(); }
364 |     }
365 | }
366 | ```
367 | 
368 | The context extends to the containing scope of the `ERROR_CONTEXT` macro.
369 | 
370 | Example output (in case of crash):
371 | 
372 | ```
373 | 	------------------------------------------------
374 | 	[ErrorContext]                main.cpp:416   Processing file:    "customers.json"
375 | 	[ErrorContext]                main.cpp:417   Customer index:     42
376 | 	------------------------------------------------
377 | ```
378 | 
379 | Error contexts are printed automatically on crashes. Note that values captured by `ERROR_CONTEXT` are **only printed on a crash**. They do not litter the log file otherwise. They also have an almost negligible performance hit (about 12 nanoseconds per `ERROR_CONTEXT` on my MacBook Pro, compared to about 4-7 milliseconds a line in the logfile).
380 | 
381 | `ERROR_CONTEXT` works with built-in types (`float`, `int`, `char` etc) as well as `const char*`. You can also add support for your own types by overloading `loguru::ec_to_text` (see [`loguru.hpp`](https://github.com/emilk/loguru/blob/master/loguru.hpp) for details).
382 | 
383 | The `ERROR_CONTEXT` feature of Loguru is actually orthogonal to the logging. If you want to, you can use Loguru just for its `ERROR_CONTEXT` (and use some other library for logging). You can print the error context stack at any time like this:
384 | 
385 | ```
386 | 	auto text = loguru::get_error_context();
387 | 	printf("%s", text.c_str());
388 | 	some_stream << text.c_str(); // Or like this
389 | ```
390 | 
391 | 
392 | # Functions
393 | ## `void init(int& argc, char* argv[], const Options& options = {})`
394 | 
395 | Should be called from the main thread.
396 | You don't *need* to call this, but if you do you get:
397 | 	* Signal handlers installed
398 | 	* Program arguments logged
399 | 	* Working dir logged
400 | 	* Optional `-v` verbosity flag parsed
401 | 	* Main thread name set to "main thread"
402 | 	* Explanation of the preamble (date, threanmae etc) logged
403 | 
404 | `loguru::init()` will look for arguments meant for loguru and remove them.
405 | Loguru currently only looks for the `-v` argument:
406 | ```
407 | 	-v n   Set loguru::g_stderr_verbosity level. Examples:
408 | 		-v 3        Show verbosity level 3 and lower.
409 | 		-v 0        Only show INFO, WARNING, ERROR, FATAL (default).
410 | 		-v INFO     Only show INFO, WARNING, ERROR, FATAL (default).
411 | 		-v WARNING  Only show WARNING, ERROR, FATAL.
412 | 		-v ERROR    Only show ERROR, FATAL.
413 | 		-v FATAL    Only show FATAL.
414 | 		-v OFF      Turn off logging to stderr.
415 | ```
416 | 
417 | Tip: You can set `g_stderr_verbosity` before calling `loguru::init`.
418 | That way you can set the default but have the user override it with the `-v` flag.
419 | Note that `-v` does not affect file logging (see `loguru::add_file`).
420 | 
421 | You can you something other than the `-v` flag by setting the `verbosity_flag` option.
422 | 
423 | ``` C++
424 | // Runtime options passed to loguru::init
425 | struct Options
426 | {
427 | 	// This allows you to use something else instead of "-v" via verbosity_flag.
428 | 	// Set to nullptr to if you don't want Loguru to parse verbosity from the args.'
429 | 	const char* verbosity_flag = "-v";
430 | 
431 | 	// loguru::init will set the name of the calling thread to this.
432 | 	// If you don't want Loguru to set the name of the main thread,
433 | 	// set this to nullptr.
434 | 	// NOTE: on SOME platforms loguru::init will only overwrite the thread name
435 | 	// if a thread name has not already been set.
436 | 	// To always set a thread name, use loguru::set_thread_name instead.
437 | 	const char* main_thread_name = "main thread";
438 | 
439 | 	SignalOptions signals = SignalOptions{};
440 | };
441 | 
442 | struct SignalOptions
443 | {
444 | 	/// Make Loguru try to do unsafe but useful things,
445 | 	/// like printing a stack trace, when catching signals.
446 | 	/// This may lead to bad things like deadlocks in certain situations.
447 | 	bool unsafe_signal_handler = true;
448 | 
449 | 	/// Should Loguru catch SIGABRT ?
450 | 	bool sigabrt = true;
451 | 
452 | 	/// Should Loguru catch SIGBUS ?
453 | 	bool sigbus = true;
454 | 
455 | 	/// Should Loguru catch SIGFPE ?
456 | 	bool sigfpe = true;
457 | 
458 | 	/// Should Loguru catch SIGILL ?
459 | 	bool sigill = true;
460 | 
461 | 	/// Should Loguru catch SIGINT ?
462 | 	bool sigint = true;
463 | 
464 | 	/// Should Loguru catch SIGSEGV ?
465 | 	bool sigsegv = true;
466 | 
467 | 	/// Should Loguru catch SIGTERM ?
468 | 	bool sigterm = true;
469 | }
470 | ```
471 | 
472 | ## `void shutdown()`
473 | Will call `loguru::remove_all_callbacks()`, thus stopping all logging except to `stderr`.
474 | 
475 | You generally don't need to call this.
476 | 
477 | ## `bool add_file(const char* path, FileMode mode, Verbosity verbosity)`
478 | 
479 | Will log to a file at the given path. Any logging message with a verbosity lower or equal to the given verbosity will be included. The function will create all directories in 'path' if needed (like `mkdir -p`).
480 | 
481 | If the path starts with a `~`, it will be replaced with your home path.
482 | To stop the file logging, just call `loguru::remove_callback(path)` with the same path.
483 | 
484 | Examples:
485 | 
486 | ``` C++
487 | 	// Put every log message in "everything.log":
488 | 	loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX);
489 | 
490 | 	// Only log INFO, WARNING, ERROR and FATAL to "latest_readable.log":
491 | 	loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO);
492 | 
493 | 	char log_path[PATH_MAX];
494 | 	loguru::suggest_log_path("~/loguru/", log_path, sizeof(log_path));
495 | 	loguru::add_file(log_path, loguru::FileMode::Truncate, loguru::Verbosity_MAX);
496 | 
497 | ```
498 | 
499 | ## `bool add_syslog(const char* app_name, Verbosity verbosity, int facility = LOG_USER)`
500 | Any logging message with a verbosity lower or equal to the given verbosity will be sent to <a href="https://man7.org/linux/man-pages/man3/syslog.3.html">syslog</a>.
501 | 
502 | For systems that do not support syslog a note is made in the log that this functionality is not supported (and return false).
503 | 
504 | Parameters:
505 |  * app_name:    If null uses argv[0]. The name of the application in the syslog.
506 |  * verbosity:   Min verbosity need to add an item to syslog
507 |  * facility:    SysLog application type. You should not normally need to change this.
508 |                 Only change if you know what you are doing first.
509 | 
510 | 
511 | ## `void suggest_log_path(const char* prefix, char* buff, unsigned buff_size)`
512 | Given a prefix of e.g. `"~/loguru/"` this might return:
513 | 
514 | 	`"/home/your_username/loguru/app_name/20151017_161503.123.log"`
515 | 
516 | where "app_name" is a sanitized version of `argv[0]`.
517 | 
518 | ## `void set_thread_name(const char* name)`
519 | Thread names can be set for the benefit of readable logs.
520 | If you do not set the thread name, a hex id will be shown instead.
521 | These thread names may or may not be the same as the system thread names,
522 | depending on the system.
523 | Try to limit the thread name to 15 characters or less.
524 | `loguru::init` will set the name of the calling thread to `"main thread"`.
525 | 
526 | ## `void get_thread_name(char* buffer, unsigned long long length, bool right_align_hex_id)`
527 | Returns the thread name for this thread.
528 | On most *nix systems this will return the system thread name (settable from both within and without Loguru).
529 | On other systems it will return whatever you set in `set_thread_name()`;
530 | If no thread name is set, this will return a hexadecimal thread id.
531 | `length` should be the number of bytes available in the buffer.
532 | 17 is a good number for length.
533 | `right_align_hex_id` means any hexadecimal thread id will be written to the end of buffer.
534 | 
535 | ## `Text stacktrace(int skip = 1)`
536 | Generates a readable stacktrace as a string. 'skip' specifies how many stack frames to skip. For instance, the default skip means: don't include the function `loguru::stacktrace` in the stack trace.
537 | 
538 | `Text` here is just a simple wrapper type. You can print its content with `.c_str()` just like you would with an `std::string`.
539 | 
540 | ## `Text errno_as_text();`
541 | A thread-safe version `strerror`.
542 | 
543 | 
544 | # Callbacks
545 | ## Logging callbacks
546 | Say you want to send your log messages over a network, or print them to the screen in your game. What you want then is a callback from Loguru each time a logging function is called. This is what `loguru::add_callback` is for. Here is an example how to do this:
547 | 
548 | ``` C++
549 | 	struct MyNetworkLogger{...};
550 | 
551 | 	// Note: this function should be thread safe,
552 | 	// as logging can be done from any thread at any time.
553 | 	void log_to_network(void* user_data, const loguru::Message& message)
554 | 	{
555 | 		MyNetworkLogger* logger = reinterpret_cast<MyNetworkLogger*>(user_data);
556 | 		logger->log("%s%s", message.prefix, message.message);
557 | 	}
558 | 
559 | 	int main(int argc, char* argv[]) {
560 | 		MyNetworkLogger network_logger{...};
561 | 		loguru::add_callback("network_logger",
562 | 			log_to_network, &network_logger, loguru::Verbosity_INFO);
563 | 		loguru::init(argc, argv);
564 | 		...
565 | }
566 | ```
567 | 
568 | Here's the relevant excerpt from `Loguru.hpp`:
569 | ``` C++
570 | 	struct Message
571 | 	{
572 | 		// You would generally print a Message by just concating the buffers without spacing.
573 | 		// Optionally, ignore preamble and indentation.
574 | 		Verbosity   verbosity;   // Already part of preamble
575 | 		const char* filename;    // Already part of preamble
576 | 		unsigned    line;        // Already part of preamble
577 | 		const char* preamble;    // Date, time, uptime, thread, file:line, verbosity.
578 | 		const char* indentation; // Just a bunch of spacing.
579 | 		const char* prefix;      // Assertion failure info goes here (or "").
580 | 		const char* message;     // User message goes here.
581 | 	};
582 | 
583 | 	// May not throw!
584 | 	typedef void (*log_handler_t)(void* user_data, const Message& message);
585 | 	typedef void (*close_handler_t)(void* user_data);
586 | 	typedef void (*flush_handler_t)(void* user_data);
587 | 
588 | 	/*  Will be called on each log messages with a verbosity less or equal to the given one.
589 | 		Useful for displaying messages on-screen in a game, for example.
590 | 		The given on_close is also expected to flush (if desired).
591 | 	*/
592 | 	void add_callback(
593 | 		const char*     id,
594 | 		log_handler_t   callback,
595 | 		void*           user_data,
596 | 		Verbosity       verbosity,
597 | 		close_handler_t on_close = nullptr,
598 | 		flush_handler_t on_flush = nullptr);
599 | 
600 | 	// Returns true iff the callback was found (and removed).
601 | 	bool remove_callback(const char* id);
602 | ```
603 | 
604 | ## Fatal handler
605 | You can install a callback to be called when your program is about to crash (a CHECK failed, a signal was caught, or somebody called `ABORT_F`).
606 | 
607 | Example:
608 | 
609 | ``` C+++
610 | 	// Throw exceptions instead of aborting:
611 | 	loguru::set_fatal_handler([](const loguru::Message& message){
612 | 		throw std::runtime_error(std::string(message.prefix) + message.message);
613 | 	});
614 | ```
615 | 
616 | 
617 | # Options
618 | ## Run-time option:
619 | There are some options you can set via global variables in the `loguru::` namespace:
620 | 
621 | ``` C++
622 | 	// Only write warnings, errors and crashes to stderr:
623 | 	loguru::g_stderr_verbosity = loguru::Verbosity_WARNING;
624 | 
625 | 	// Turn off writing err/warn in red:
626 | 	loguru::g_colorlogtostderr = false;
627 | ```
628 | 
629 | Generally you would do the above once before calling `loguru::init`.
630 | 
631 | 
632 | ### `loguru::g_stderr_verbosity`
633 | Everything with a verbosity equal or greater than g_stderr_verbosity will be
634 | written to stderr. You can set this in code or via the -v argument.
635 | Set to loguru::Verbosity_OFF to write nothing to stderr.
636 | Default is 0, i.e. only log ERROR, WARNING and INFO are written to stderr.
637 | 
638 | ### `loguru::g_flush_interval_ms`:
639 | If set to zero Loguru will flush on every line (unbuffered mode).
640 | Else Loguru will flush outputs every `g_flush_interval_ms` milliseconds (buffered mode). The default is `g_flush_interval_ms=0`, i.e. unbuffered mode.
641 | 
642 | ### List
643 | Here is the full list:
644 | 
645 | ``` C++
646 | 	Verbosity g_stderr_verbosity  = 0;    // 0 (INFO) by default.
647 | 	bool      g_colorlogtostderr  = true; // If you don't want color in your terminal.
648 | 	unsigned  g_flush_interval_ms = 0;    // Unbuffered (0) by default.
649 | 	bool      g_preamble_header   = true; // Prepend each log start by a descriptions line with all columns name?
650 | 	bool      g_preamble          = true; // Prefix each log line with date, time etc?
651 | 
652 | 	// Turn off individual parts of the preamble
653 | 	bool g_preamble_date    = true; // The date field
654 | 	bool g_preamble_time    = true; // The time of the current day
655 | 	bool g_preamble_uptime  = true; // The time since init call
656 | 	bool g_preamble_thread  = true; // The logging thread
657 | 	bool g_preamble_file    = true; // The file from which the log originates from
658 | 	bool g_preamble_verbose = true; // The verbosity field
659 | 	bool g_preamble_pipe    = true; // The pipe symbol right before the message
660 | ```
661 | 
662 | 
663 | ## Compile-time options
664 | Loguru let's you tweak many aspects of how it works via macros that you can set either manually with `#define LOGURU_FOO 1` or with a compilation flag as `-DLOGURU_FOO=1`.
665 | 
666 | Here follows a list of flags and their default values:
667 | 
668 | ### `LOGURU_EXPORT`
669 | Define to your project's export declaration if needed for use in a shared library.
670 | 
671 | ### `LOGURU_DEBUG_LOGGING` (defaults to the opposite of `NDEBUG`):
672 | Enables debug versions of logging statements (`DLOG_F` etc).
673 | 
674 | ### `LOGURU_DEBUG_CHECKS` (defaults to the opposite of `NDEBUG`):
675 | Enables debug versions of checks (`DCHECK_F` etc).
676 | 
677 | ### `LOGURU_SCOPE_TEXT_SIZE = 196`
678 | Maximum length of text that can be printed by a `LOG_SCOPE`. This should be long enough to get most things, but short enough not to clutter the stack.
679 | 
680 | ### `LOGURU_REDEFINE_ASSERT = 0`
681 | Redefine "assert" to call Loguru version (!NDEBUG only).
682 | 
683 | ### `LOGURU_WITH_STREAMS = 0`
684 | Add support for _S versions for all LOG and CHECK functions:
685 | ``` C++
686 | 	LOG_S(INFO) << "My vec3: " << x.cross(y);
687 | 	CHECK_EQ_S(a, b) << "I expected a and b to be the same!";
688 | ```
689 | This is off by default to keep down compilation times.
690 | 
691 | ### `LOGURU_REPLACE_GLOG = 0`
692 | Make Loguru mimic GLOG as close as possible, including #defining `LOG`, `CHECK`, `VLOG_IS_ON` etc. Great if you plan to migrate from GLOG to Loguru and don't want to add _S suffixes to all your logging functions (see `LOGURU_WITH_STREAMS`). `LOGURU_REPLACE_GLOG` implies `LOGURU_WITH_STREAMS`.
693 | 
694 | ### `LOGURU_USE_FMTLIB = 0`
695 | Use fmtlib formatting. See https://github.com/fmtlib/fmt
696 | This will make `loguru.hpp` depend on `&lt;fmt/format.h&gt;`
697 | You will need to link against `fmtlib` or use the `FMT_HEADER_ONLY` preprocessor definition.
698 | Feature by kolis (https://github.com/emilk/loguru/pull/22)
699 | 
700 | ### `LOGURU_WITH_FILEABS = 0`
701 | When `LOGURU_WITH_FILEABS` is turned on, a check of file change will be performed on every call to file_log.
702 | If the file is moved, or inode changes, file is reopened using the same FileMode as is done by add_file.
703 | Such a scheme is useful if you have a daemon program that moves the log file every 24 hours and expects new file to be created.
704 | Feature by scinart (https://github.com/emilk/loguru/pull/23).
705 | 
706 | ### `LOGURU_STACKTRACES` (default 1 on supported platforms)
707 | Print stack traces on abort.
708 | 
709 | ### `LOGURU_RTTI`
710 | Set to 0 if your platform does not support runtime type information (-fno-rtti).
711 | 
712 | ### Flags for controlling output formats:
713 | #### `LOGURU_FILENAME_WIDTH = 23`
714 | Width of the column containing the file name
715 | 
716 | #### `LOGURU_THREADNAME_WIDTH = 16`
717 | Width of the column containing the thread name.
718 | 
719 | #### `LOGURU_VERBOSE_SCOPE_ENDINGS = 1`
720 | Show milliseconds and scope name at end of scope.
721 | 
722 | #### `LOGURU_SCOPE_TIME_PRECISION = 3`
723 | Resolution of scope timers. 3=ms, 6=us, 9=ns
724 | 
725 | 
726 | <!-- Markdeep: --><style class="fallback">body{visibility:hidden;white-space:pre;font-family:monospace}</style><script src="markdeep.min.js"></script><script src="https://casual-effects.com/markdeep/latest/markdeep.min.js"></script><script>window.alreadyProcessedMarkdeep||(document.body.style.visibility="visible")</script>
727 | 


--------------------------------------------------------------------------------
/loguru.hpp:
--------------------------------------------------------------------------------
   1 | /*
   2 | Loguru logging library for C++, by Emil Ernerfeldt.
   3 | www.github.com/emilk/loguru
   4 | If you find Loguru useful, please let me know on twitter or in a mail!
   5 | Twitter: @ernerfeldt
   6 | Mail:    emil.ernerfeldt@gmail.com
   7 | Website: www.ilikebigbits.com
   8 | 
   9 | # License
  10 | 	This software is in the public domain. Where that dedication is not
  11 | 	recognized, you are granted a perpetual, irrevocable license to
  12 | 	copy, modify and distribute it as you see fit.
  13 | 
  14 | # Inspiration
  15 | 	Much of Loguru was inspired by GLOG, https://code.google.com/p/google-glog/.
  16 | 	The choice of public domain is fully due Sean T. Barrett
  17 | 	and his wonderful stb libraries at https://github.com/nothings/stb.
  18 | 
  19 | # Version history
  20 | 	* Version 0.1.0 - 2015-03-22 - Works great on Mac.
  21 | 	* Version 0.2.0 - 2015-09-17 - Removed the only dependency.
  22 | 	* Version 0.3.0 - 2015-10-02 - Drop-in replacement for most of GLOG
  23 | 	* Version 0.4.0 - 2015-10-07 - Single-file!
  24 | 	* Version 0.5.0 - 2015-10-17 - Improved file logging
  25 | 	* Version 0.6.0 - 2015-10-24 - Add stack traces
  26 | 	* Version 0.7.0 - 2015-10-27 - Signals
  27 | 	* Version 0.8.0 - 2015-10-30 - Color logging.
  28 | 	* Version 0.9.0 - 2015-11-26 - ABORT_S and proper handling of FATAL
  29 | 	* Version 1.0.0 - 2016-02-14 - ERROR_CONTEXT
  30 | 	* Version 1.1.0 - 2016-02-19 - -v OFF, -v INFO etc
  31 | 	* Version 1.1.1 - 2016-02-20 - textprintf vs strprintf
  32 | 	* Version 1.1.2 - 2016-02-22 - Remove g_alsologtostderr
  33 | 	* Version 1.1.3 - 2016-02-29 - ERROR_CONTEXT as linked list
  34 | 	* Version 1.2.0 - 2016-03-19 - Add get_thread_name()
  35 | 	* Version 1.2.1 - 2016-03-20 - Minor fixes
  36 | 	* Version 1.2.2 - 2016-03-29 - Fix issues with set_fatal_handler throwing an exception
  37 | 	* Version 1.2.3 - 2016-05-16 - Log current working directory in loguru::init().
  38 | 	* Version 1.2.4 - 2016-05-18 - Custom replacement for -v in loguru::init() by bjoernpollex
  39 | 	* Version 1.2.5 - 2016-05-18 - Add ability to print ERROR_CONTEXT of parent thread.
  40 | 	* Version 1.2.6 - 2016-05-19 - Bug fix regarding VLOG verbosity argument lacking ().
  41 | 	* Version 1.2.7 - 2016-05-23 - Fix PATH_MAX problem.
  42 | 	* Version 1.2.8 - 2016-05-26 - Add shutdown() and remove_all_callbacks()
  43 | 	* Version 1.2.9 - 2016-06-09 - Use a monotonic clock for uptime.
  44 | 	* Version 1.3.0 - 2016-07-20 - Fix issues with callback flush/close not being called.
  45 | 	* Version 1.3.1 - 2016-07-20 - Add LOGURU_UNSAFE_SIGNAL_HANDLER to toggle stacktrace on signals.
  46 | 	* Version 1.3.2 - 2016-07-20 - Add loguru::arguments()
  47 | 	* Version 1.4.0 - 2016-09-15 - Semantic versioning + add loguru::create_directories
  48 | 	* Version 1.4.1 - 2016-09-29 - Customize formating with LOGURU_FILENAME_WIDTH
  49 | 	* Version 1.5.0 - 2016-12-22 - LOGURU_USE_FMTLIB by kolis and LOGURU_WITH_FILEABS by scinart
  50 | 	* Version 1.5.1 - 2017-08-08 - Terminal colors on Windows 10 thanks to looki
  51 | 	* Version 1.6.0 - 2018-01-03 - Add LOGURU_RTTI and LOGURU_STACKTRACES settings
  52 | 	* Version 1.7.0 - 2018-01-03 - Add ability to turn off the preamble with loguru::g_preamble
  53 | 	* Version 1.7.1 - 2018-04-05 - Add function get_fatal_handler
  54 | 	* Version 1.7.2 - 2018-04-22 - Fix a bug where large file names could cause stack corruption (thanks @ccamporesi)
  55 | 	* Version 1.8.0 - 2018-04-23 - Shorten long file names to keep preamble fixed width
  56 | 	* Version 1.9.0 - 2018-09-22 - Adjust terminal colors, add LOGURU_VERBOSE_SCOPE_ENDINGS, add LOGURU_SCOPE_TIME_PRECISION, add named log levels
  57 | 	* Version 2.0.0 - 2018-09-22 - Split loguru.hpp into loguru.hpp and loguru.cpp
  58 | 	* Version 2.1.0 - 2019-09-23 - Update fmtlib + add option to loguru::init to NOT set main thread name.
  59 | 	* Version 2.2.0 - 2020-07-31 - Replace LOGURU_CATCH_SIGABRT with struct SignalOptions
  60 | 
  61 | # Compiling
  62 | 	Just include <loguru.hpp> where you want to use Loguru.
  63 | 	Then, in one .cpp file #include <loguru.cpp>
  64 | 	Make sure you compile with -std=c++11 -lstdc++ -lpthread -ldl
  65 | 
  66 | # Usage
  67 | 	For details, please see the official documentation at emilk.github.io/loguru
  68 | 
  69 | 	#include <loguru.hpp>
  70 | 
  71 | 	int main(int argc, char* argv[]) {
  72 | 		loguru::init(argc, argv);
  73 | 
  74 | 		// Put every log message in "everything.log":
  75 | 		loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX);
  76 | 
  77 | 		LOG_F(INFO, "The magic number is %d", 42);
  78 | 	}
  79 | 
  80 | */
  81 | 
  82 | #if defined(LOGURU_IMPLEMENTATION)
  83 | 	#error "You are defining LOGURU_IMPLEMENTATION. This is for older versions of Loguru. You should now instead include loguru.cpp (or build it and link with it)"
  84 | #endif
  85 | 
  86 | // Disable all warnings from gcc/clang:
  87 | #if defined(__clang__)
  88 | 	#pragma clang system_header
  89 | #elif defined(__GNUC__)
  90 | 	#pragma GCC system_header
  91 | #endif
  92 | 
  93 | #ifndef LOGURU_HAS_DECLARED_FORMAT_HEADER
  94 | #define LOGURU_HAS_DECLARED_FORMAT_HEADER
  95 | 
  96 | // Semantic versioning. Loguru version can be printed with printf("%d.%d.%d", LOGURU_VERSION_MAJOR, LOGURU_VERSION_MINOR, LOGURU_VERSION_PATCH);
  97 | #define LOGURU_VERSION_MAJOR 2
  98 | #define LOGURU_VERSION_MINOR 1
  99 | #define LOGURU_VERSION_PATCH 0
 100 | 
 101 | #if defined(_MSC_VER)
 102 | #include <sal.h>	// Needed for _In_z_ etc annotations
 103 | #endif
 104 | 
 105 | #if defined(__linux__) || defined(__APPLE__)
 106 | #define LOGURU_SYSLOG 1
 107 | #else
 108 | #define LOGURU_SYSLOG 0
 109 | #endif
 110 | 
 111 | // ----------------------------------------------------------------------------
 112 | 
 113 | #ifndef LOGURU_EXPORT
 114 | 	// Define to your project's export declaration if needed for use in a shared library.
 115 | 	#define LOGURU_EXPORT
 116 | #endif
 117 | 
 118 | #ifndef LOGURU_SCOPE_TEXT_SIZE
 119 | 	// Maximum length of text that can be printed by a LOG_SCOPE.
 120 | 	// This should be long enough to get most things, but short enough not to clutter the stack.
 121 | 	#define LOGURU_SCOPE_TEXT_SIZE 196
 122 | #endif
 123 | 
 124 | #ifndef LOGURU_FILENAME_WIDTH
 125 | 	// Width of the column containing the file name
 126 | 	#define LOGURU_FILENAME_WIDTH 23
 127 | #endif
 128 | 
 129 | #ifndef LOGURU_THREADNAME_WIDTH
 130 | 	// Width of the column containing the thread name
 131 | 	#define LOGURU_THREADNAME_WIDTH 16
 132 | #endif
 133 | 
 134 | #ifndef LOGURU_SCOPE_TIME_PRECISION
 135 | 	// Resolution of scope timers. 3=ms, 6=us, 9=ns
 136 | 	#define LOGURU_SCOPE_TIME_PRECISION 3
 137 | #endif
 138 | 
 139 | #ifdef LOGURU_CATCH_SIGABRT
 140 | 	#error "You are defining LOGURU_CATCH_SIGABRT. This is for older versions of Loguru. You should now instead set the options passed to loguru::init"
 141 | #endif
 142 | 
 143 | #ifndef LOGURU_VERBOSE_SCOPE_ENDINGS
 144 | 	// Show milliseconds and scope name at end of scope.
 145 | 	#define LOGURU_VERBOSE_SCOPE_ENDINGS 1
 146 | #endif
 147 | 
 148 | #ifndef LOGURU_REDEFINE_ASSERT
 149 | 	#define LOGURU_REDEFINE_ASSERT 0
 150 | #endif
 151 | 
 152 | #ifndef LOGURU_WITH_STREAMS
 153 | 	#define LOGURU_WITH_STREAMS 0
 154 | #endif
 155 | 
 156 | #ifndef LOGURU_REPLACE_GLOG
 157 | 	#define LOGURU_REPLACE_GLOG 0
 158 | #endif
 159 | 
 160 | #if LOGURU_REPLACE_GLOG
 161 | 	#undef LOGURU_WITH_STREAMS
 162 | 	#define LOGURU_WITH_STREAMS 1
 163 | #endif
 164 | 
 165 | #if defined(LOGURU_UNSAFE_SIGNAL_HANDLER)
 166 | 	#error "You are defining LOGURU_UNSAFE_SIGNAL_HANDLER. This is for older versions of Loguru. You should now instead set the unsafe_signal_handler option when you call loguru::init."
 167 | #endif
 168 | 
 169 | #if LOGURU_IMPLEMENTATION
 170 | 	#undef LOGURU_WITH_STREAMS
 171 | 	#define LOGURU_WITH_STREAMS 1
 172 | #endif
 173 | 
 174 | #ifndef LOGURU_USE_FMTLIB
 175 | 	#define LOGURU_USE_FMTLIB 0
 176 | #endif
 177 | 
 178 | #ifndef LOGURU_USE_LOCALE
 179 |         #define LOGURU_USE_LOCALE 0
 180 | #endif
 181 | 
 182 | #ifndef LOGURU_WITH_FILEABS
 183 | 	#define LOGURU_WITH_FILEABS 0
 184 | #endif
 185 | 
 186 | #ifndef LOGURU_RTTI
 187 | #if defined(__clang__)
 188 | 	#if __has_feature(cxx_rtti)
 189 | 		#define LOGURU_RTTI 1
 190 | 	#endif
 191 | #elif defined(__GNUG__)
 192 | 	#if defined(__GXX_RTTI)
 193 | 		#define LOGURU_RTTI 1
 194 | 	#endif
 195 | #elif defined(_MSC_VER)
 196 | 	#if defined(_CPPRTTI)
 197 | 		#define LOGURU_RTTI 1
 198 | 	#endif
 199 | #endif
 200 | #endif
 201 | 
 202 | #ifdef LOGURU_USE_ANONYMOUS_NAMESPACE
 203 | 	#define LOGURU_ANONYMOUS_NAMESPACE_BEGIN namespace {
 204 | 	#define LOGURU_ANONYMOUS_NAMESPACE_END }
 205 | #else
 206 | 	#define LOGURU_ANONYMOUS_NAMESPACE_BEGIN
 207 | 	#define LOGURU_ANONYMOUS_NAMESPACE_END
 208 | #endif
 209 | 
 210 | // --------------------------------------------------------------------
 211 | // Utility macros
 212 | 
 213 | #define LOGURU_CONCATENATE_IMPL(s1, s2) s1 ## s2
 214 | #define LOGURU_CONCATENATE(s1, s2) LOGURU_CONCATENATE_IMPL(s1, s2)
 215 | 
 216 | #ifdef __COUNTER__
 217 | #   define LOGURU_ANONYMOUS_VARIABLE(str) LOGURU_CONCATENATE(str, __COUNTER__)
 218 | #else
 219 | #   define LOGURU_ANONYMOUS_VARIABLE(str) LOGURU_CONCATENATE(str, __LINE__)
 220 | #endif
 221 | 
 222 | #if defined(__clang__) || defined(__GNUC__)
 223 | 	// Helper macro for declaring functions as having similar signature to printf.
 224 | 	// This allows the compiler to catch format errors at compile-time.
 225 | 	#define LOGURU_PRINTF_LIKE(fmtarg, firstvararg) __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
 226 | 	#define LOGURU_FORMAT_STRING_TYPE const char*
 227 | #elif defined(_MSC_VER)
 228 | 	#define LOGURU_PRINTF_LIKE(fmtarg, firstvararg)
 229 | 	#define LOGURU_FORMAT_STRING_TYPE _In_z_ _Printf_format_string_ const char*
 230 | #else
 231 | 	#define LOGURU_PRINTF_LIKE(fmtarg, firstvararg)
 232 | 	#define LOGURU_FORMAT_STRING_TYPE const char*
 233 | #endif
 234 | 
 235 | // Used to mark log_and_abort for the benefit of the static analyzer and optimizer.
 236 | #if defined(_MSC_VER)
 237 | #define LOGURU_NORETURN __declspec(noreturn)
 238 | #else
 239 | #define LOGURU_NORETURN __attribute__((noreturn))
 240 | #endif
 241 | 
 242 | #if defined(_MSC_VER)
 243 | #define LOGURU_PREDICT_FALSE(x) (x)
 244 | #define LOGURU_PREDICT_TRUE(x)  (x)
 245 | #else
 246 | #define LOGURU_PREDICT_FALSE(x) (__builtin_expect(x,     0))
 247 | #define LOGURU_PREDICT_TRUE(x)  (__builtin_expect(!!(x), 1))
 248 | #endif
 249 | 
 250 | #if LOGURU_USE_FMTLIB
 251 | 	#include <fmt/format.h>
 252 | 	#define LOGURU_FMT(x) "{:" #x "}"
 253 | #else
 254 | 	#define LOGURU_FMT(x) "%" #x
 255 | #endif
 256 | 
 257 | #ifdef _WIN32
 258 | 	#define STRDUP(str) _strdup(str)
 259 | #else
 260 | 	#define STRDUP(str) strdup(str)
 261 | #endif
 262 | 
 263 | #include <stdarg.h>
 264 | 
 265 | // --------------------------------------------------------------------
 266 | LOGURU_ANONYMOUS_NAMESPACE_BEGIN
 267 | 
 268 | namespace loguru
 269 | {
 270 | 	// Simple RAII ownership of a char*.
 271 | 	class LOGURU_EXPORT Text
 272 | 	{
 273 | 	public:
 274 | 		explicit Text(char* owned_str) : _str(owned_str) {}
 275 | 		~Text();
 276 | 		Text(Text&& t)
 277 | 		{
 278 | 			_str = t._str;
 279 | 			t._str = nullptr;
 280 | 		}
 281 | 		Text(Text& t) = delete;
 282 | 		Text& operator=(Text& t) = delete;
 283 | 		void operator=(Text&& t) = delete;
 284 | 
 285 | 		const char* c_str() const { return _str; }
 286 | 		bool empty() const { return _str == nullptr || *_str == '\0'; }
 287 | 
 288 | 		char* release()
 289 | 		{
 290 | 			auto result = _str;
 291 | 			_str = nullptr;
 292 | 			return result;
 293 | 		}
 294 | 
 295 | 	private:
 296 | 		char* _str;
 297 | 	};
 298 | 
 299 | 	// Like printf, but returns the formated text.
 300 | #if LOGURU_USE_FMTLIB
 301 | 	LOGURU_EXPORT
 302 | 	Text vtextprintf(const char* format, fmt::format_args args);
 303 | 
 304 | 	template<typename... Args>
 305 | 	LOGURU_EXPORT
 306 | 	Text textprintf(LOGURU_FORMAT_STRING_TYPE format, const Args&... args) {
 307 | 		return vtextprintf(format, fmt::make_format_args(args...));
 308 | 	}
 309 | #else
 310 | 	LOGURU_EXPORT
 311 | 	Text textprintf(LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(1, 2);
 312 | #endif
 313 | 
 314 | 	// Overloaded for variadic template matching.
 315 | 	LOGURU_EXPORT
 316 | 	Text textprintf();
 317 | 
 318 | 	using Verbosity = int;
 319 | 
 320 | #undef FATAL
 321 | #undef ERROR
 322 | #undef WARNING
 323 | #undef INFO
 324 | #undef MAX
 325 | 
 326 | 	enum NamedVerbosity : Verbosity
 327 | 	{
 328 | 		// Used to mark an invalid verbosity. Do not log to this level.
 329 | 		Verbosity_INVALID = -10, // Never do LOG_F(INVALID)
 330 | 
 331 | 		// You may use Verbosity_OFF on g_stderr_verbosity, but for nothing else!
 332 | 		Verbosity_OFF     = -9, // Never do LOG_F(OFF)
 333 | 
 334 | 		// Prefer to use ABORT_F or ABORT_S over LOG_F(FATAL) or LOG_S(FATAL).
 335 | 		Verbosity_FATAL   = -3,
 336 | 		Verbosity_ERROR   = -2,
 337 | 		Verbosity_WARNING = -1,
 338 | 
 339 | 		// Normal messages. By default written to stderr.
 340 | 		Verbosity_INFO    =  0,
 341 | 
 342 | 		// Same as Verbosity_INFO in every way.
 343 | 		Verbosity_0       =  0,
 344 | 
 345 | 		// Verbosity levels 1-9 are generally not written to stderr, but are written to file.
 346 | 		Verbosity_1       = +1,
 347 | 		Verbosity_2       = +2,
 348 | 		Verbosity_3       = +3,
 349 | 		Verbosity_4       = +4,
 350 | 		Verbosity_5       = +5,
 351 | 		Verbosity_6       = +6,
 352 | 		Verbosity_7       = +7,
 353 | 		Verbosity_8       = +8,
 354 | 		Verbosity_9       = +9,
 355 | 
 356 | 		// Do not use higher verbosity levels, as that will make grepping log files harder.
 357 | 		Verbosity_MAX     = +9,
 358 | 	};
 359 | 
 360 | 	struct Message
 361 | 	{
 362 | 		// You would generally print a Message by just concatenating the buffers without spacing.
 363 | 		// Optionally, ignore preamble and indentation.
 364 | 		Verbosity   verbosity;   // Already part of preamble
 365 | 		const char* filename;    // Already part of preamble
 366 | 		unsigned    line;        // Already part of preamble
 367 | 		const char* preamble;    // Date, time, uptime, thread, file:line, verbosity.
 368 | 		const char* indentation; // Just a bunch of spacing.
 369 | 		const char* prefix;      // Assertion failure info goes here (or "").
 370 | 		const char* message;     // User message goes here.
 371 | 	};
 372 | 
 373 | 	/* Everything with a verbosity equal or greater than g_stderr_verbosity will be
 374 | 	written to stderr. You can set this in code or via the -v argument.
 375 | 	Set to loguru::Verbosity_OFF to write nothing to stderr.
 376 | 	Default is 0, i.e. only log ERROR, WARNING and INFO are written to stderr.
 377 | 	*/
 378 | 	LOGURU_EXPORT extern Verbosity g_stderr_verbosity;
 379 | 	LOGURU_EXPORT extern bool      g_colorlogtostderr; // True by default.
 380 | 	LOGURU_EXPORT extern unsigned  g_flush_interval_ms; // 0 (unbuffered) by default.
 381 | 	LOGURU_EXPORT extern bool      g_preamble_header; // Prepend each log start by a descriptions line with all columns name? True by default.
 382 | 	LOGURU_EXPORT extern bool      g_preamble; // Prefix each log line with date, time etc? True by default.
 383 | 
 384 | 	/* Specify the verbosity used by loguru to log its info messages including the header
 385 | 	logged when logged::init() is called or on exit. Default is 0 (INFO).
 386 | 	*/
 387 | 	LOGURU_EXPORT extern Verbosity g_internal_verbosity;
 388 | 
 389 | 	// Turn off individual parts of the preamble
 390 | 	LOGURU_EXPORT extern bool      g_preamble_date; // The date field
 391 | 	LOGURU_EXPORT extern bool      g_preamble_time; // The time of the current day
 392 | 	LOGURU_EXPORT extern bool      g_preamble_uptime; // The time since init call
 393 | 	LOGURU_EXPORT extern bool      g_preamble_thread; // The logging thread
 394 | 	LOGURU_EXPORT extern bool      g_preamble_file; // The file from which the log originates from
 395 | 	LOGURU_EXPORT extern bool      g_preamble_verbose; // The verbosity field
 396 | 	LOGURU_EXPORT extern bool      g_preamble_pipe; // The pipe symbol right before the message
 397 | 
 398 | 	// May not throw!
 399 | 	typedef void (*log_handler_t)(void* user_data, const Message& message);
 400 | 	typedef void (*close_handler_t)(void* user_data);
 401 | 	typedef void (*flush_handler_t)(void* user_data);
 402 | 
 403 | 	// May throw if that's how you'd like to handle your errors.
 404 | 	typedef void (*fatal_handler_t)(const Message& message);
 405 | 
 406 | 	// Given a verbosity level, return the level's name or nullptr.
 407 | 	typedef const char* (*verbosity_to_name_t)(Verbosity verbosity);
 408 | 
 409 | 	// Given a verbosity level name, return the verbosity level or
 410 | 	// Verbosity_INVALID if name is not recognized.
 411 | 	typedef Verbosity (*name_to_verbosity_t)(const char* name);
 412 | 
 413 | 	struct SignalOptions
 414 | 	{
 415 | 		/// Make Loguru try to do unsafe but useful things,
 416 | 		/// like printing a stack trace, when catching signals.
 417 | 		/// This may lead to bad things like deadlocks in certain situations.
 418 | 		bool unsafe_signal_handler = true;
 419 | 
 420 | 		/// Should Loguru catch SIGABRT ?
 421 | 		bool sigabrt = true;
 422 | 
 423 | 		/// Should Loguru catch SIGBUS ?
 424 | 		bool sigbus = true;
 425 | 
 426 | 		/// Should Loguru catch SIGFPE ?
 427 | 		bool sigfpe = true;
 428 | 
 429 | 		/// Should Loguru catch SIGILL ?
 430 | 		bool sigill = true;
 431 | 
 432 | 		/// Should Loguru catch SIGINT ?
 433 | 		bool sigint = true;
 434 | 
 435 | 		/// Should Loguru catch SIGSEGV ?
 436 | 		bool sigsegv = true;
 437 | 
 438 | 		/// Should Loguru catch SIGTERM ?
 439 | 		bool sigterm = true;
 440 | 
 441 | 		static SignalOptions none()
 442 | 		{
 443 | 			SignalOptions options;
 444 | 			options.unsafe_signal_handler = false;
 445 | 			options.sigabrt = false;
 446 | 			options.sigbus = false;
 447 | 			options.sigfpe = false;
 448 | 			options.sigill = false;
 449 | 			options.sigint = false;
 450 | 			options.sigsegv = false;
 451 | 			options.sigterm = false;
 452 | 			return options;
 453 | 		}
 454 | 	};
 455 | 
 456 | 	// Runtime options passed to loguru::init
 457 | 	struct Options
 458 | 	{
 459 | 		// This allows you to use something else instead of "-v" via verbosity_flag.
 460 | 		// Set to nullptr if you don't want Loguru to parse verbosity from the args.
 461 | 		const char* verbosity_flag = "-v";
 462 | 
 463 | 		// loguru::init will set the name of the calling thread to this.
 464 | 		// If you don't want Loguru to set the name of the main thread,
 465 | 		// set this to nullptr.
 466 | 		// NOTE: on SOME platforms loguru::init will only overwrite the thread name
 467 | 		// if a thread name has not already been set.
 468 | 		// To always set a thread name, use loguru::set_thread_name instead.
 469 | 		const char* main_thread_name = "main thread";
 470 | 
 471 | 		SignalOptions signal_options;
 472 | 	};
 473 | 
 474 | 	/*  Should be called from the main thread.
 475 | 		You don't *need* to call this, but if you do you get:
 476 | 			* Signal handlers installed
 477 | 			* Program arguments logged
 478 | 			* Working dir logged
 479 | 			* Optional -v verbosity flag parsed
 480 | 			* Main thread name set to "main thread"
 481 | 			* Explanation of the preamble (date, thread name, etc) logged
 482 | 
 483 | 		loguru::init() will look for arguments meant for loguru and remove them.
 484 | 		Arguments meant for loguru are:
 485 | 			-v n   Set loguru::g_stderr_verbosity level. Examples:
 486 | 				-v 3        Show verbosity level 3 and lower.
 487 | 				-v 0        Only show INFO, WARNING, ERROR, FATAL (default).
 488 | 				-v INFO     Only show INFO, WARNING, ERROR, FATAL (default).
 489 | 				-v WARNING  Only show WARNING, ERROR, FATAL.
 490 | 				-v ERROR    Only show ERROR, FATAL.
 491 | 				-v FATAL    Only show FATAL.
 492 | 				-v OFF      Turn off logging to stderr.
 493 | 
 494 | 		Tip: You can set g_stderr_verbosity before calling loguru::init.
 495 | 		That way you can set the default but have the user override it with the -v flag.
 496 | 		Note that -v does not affect file logging (see loguru::add_file).
 497 | 
 498 | 		You can you something other than the -v flag by setting the verbosity_flag option.
 499 | 	*/
 500 | 	LOGURU_EXPORT
 501 | 	void init(int& argc, char* argv[], const Options& options = {});
 502 | 
 503 | 	// Will call remove_all_callbacks(). After calling this, logging will still go to stderr.
 504 | 	// You generally don't need to call this.
 505 | 	LOGURU_EXPORT
 506 | 	void shutdown();
 507 | 
 508 | 	// What ~ will be replaced with, e.g. "/home/your_user_name/"
 509 | 	LOGURU_EXPORT
 510 | 	const char* home_dir();
 511 | 
 512 | 	/* Returns the name of the app as given in argv[0] but without leading path.
 513 | 	   That is, if argv[0] is "../foo/app" this will return "app".
 514 | 	*/
 515 | 	LOGURU_EXPORT
 516 | 	const char* argv0_filename();
 517 | 
 518 | 	// Returns all arguments given to loguru::init(), but escaped with a single space as separator.
 519 | 	LOGURU_EXPORT
 520 | 	const char* arguments();
 521 | 
 522 | 	// Returns the path to the current working dir when loguru::init() was called.
 523 | 	LOGURU_EXPORT
 524 | 	const char* current_dir();
 525 | 
 526 | 	// Returns the part of the path after the last / or \ (if any).
 527 | 	LOGURU_EXPORT
 528 | 	const char* filename(const char* path);
 529 | 
 530 | 	// e.g. "foo/bar/baz.ext" will create the directories "foo/" and "foo/bar/"
 531 | 	LOGURU_EXPORT
 532 | 	bool create_directories(const char* file_path_const);
 533 | 
 534 | 	// Writes date and time with millisecond precision, e.g. "20151017_161503.123"
 535 | 	LOGURU_EXPORT
 536 | 	void write_date_time(char* buff, unsigned long long buff_size);
 537 | 
 538 | 	// Helper: thread-safe version strerror
 539 | 	LOGURU_EXPORT
 540 | 	Text errno_as_text();
 541 | 
 542 | 	/* Given a prefix of e.g. "~/loguru/" this might return
 543 | 	   "/home/your_username/loguru/app_name/20151017_161503.123.log"
 544 | 
 545 | 	   where "app_name" is a sanitized version of argv[0].
 546 | 	*/
 547 | 	LOGURU_EXPORT
 548 | 	void suggest_log_path(const char* prefix, char* buff, unsigned long long buff_size);
 549 | 
 550 | 	enum FileMode { Truncate, Append };
 551 | 
 552 | 	/*  Will log to a file at the given path.
 553 | 		Any logging message with a verbosity lower or equal to
 554 | 		the given verbosity will be included.
 555 | 		The function will create all directories in 'path' if needed.
 556 | 		If path starts with a ~, it will be replaced with loguru::home_dir()
 557 | 		To stop the file logging, just call loguru::remove_callback(path) with the same path.
 558 | 	*/
 559 | 	LOGURU_EXPORT
 560 | 	bool add_file(const char* path, FileMode mode, Verbosity verbosity);
 561 | 
 562 | 	LOGURU_EXPORT
 563 | 	// Send logs to syslog with LOG_USER facility (see next call)
 564 | 	bool add_syslog(const char* app_name, Verbosity verbosity);
 565 | 	LOGURU_EXPORT
 566 | 	// Send logs to syslog with your own choice of facility (LOG_USER, LOG_AUTH, ...)
 567 | 	// see loguru.cpp: syslog_log() for more details.
 568 | 	bool add_syslog(const char* app_name, Verbosity verbosity, int facility);
 569 | 
 570 | 	/*  Will be called right before abort().
 571 | 		You can for instance use this to print custom error messages, or throw an exception.
 572 | 		Feel free to call LOG:ing function from this, but not FATAL ones! */
 573 | 	LOGURU_EXPORT
 574 | 	void set_fatal_handler(fatal_handler_t handler);
 575 | 
 576 | 	// Get the current fatal handler, if any. Default value is nullptr.
 577 | 	LOGURU_EXPORT
 578 | 	fatal_handler_t get_fatal_handler();
 579 | 
 580 | 	/*  Will be called on each log messages with a verbosity less or equal to the given one.
 581 | 		Useful for displaying messages on-screen in a game, for example.
 582 | 		The given on_close is also expected to flush (if desired).
 583 | 	*/
 584 | 	LOGURU_EXPORT
 585 | 	void add_callback(
 586 | 		const char*     id,
 587 | 		log_handler_t   callback,
 588 | 		void*           user_data,
 589 | 		Verbosity       verbosity,
 590 | 		close_handler_t on_close = nullptr,
 591 | 		flush_handler_t on_flush = nullptr);
 592 | 
 593 | 	/*  Set a callback that returns custom verbosity level names. If callback
 594 | 		is nullptr or returns nullptr, default log names will be used.
 595 | 	*/
 596 | 	LOGURU_EXPORT
 597 | 	void set_verbosity_to_name_callback(verbosity_to_name_t callback);
 598 | 
 599 | 	/*  Set a callback that returns the verbosity level matching a name. The
 600 | 		callback should return Verbosity_INVALID if the name is not
 601 | 		recognized.
 602 | 	*/
 603 | 	LOGURU_EXPORT
 604 | 	void set_name_to_verbosity_callback(name_to_verbosity_t callback);
 605 | 
 606 | 	/*  Get a custom name for a specific verbosity, if one exists, or nullptr. */
 607 | 	LOGURU_EXPORT
 608 | 	const char* get_verbosity_name(Verbosity verbosity);
 609 | 
 610 | 	/*  Get the verbosity enum value from a custom 4-character level name, if one exists.
 611 | 		If the name does not match a custom level name, Verbosity_INVALID is returned.
 612 | 	*/
 613 | 	LOGURU_EXPORT
 614 | 	Verbosity get_verbosity_from_name(const char* name);
 615 | 
 616 | 	// Returns true iff the callback was found (and removed).
 617 | 	LOGURU_EXPORT
 618 | 	bool remove_callback(const char* id);
 619 | 
 620 | 	// Shut down all file logging and any other callback hooks installed.
 621 | 	LOGURU_EXPORT
 622 | 	void remove_all_callbacks();
 623 | 
 624 | 	// Returns the maximum of g_stderr_verbosity and all file/custom outputs.
 625 | 	LOGURU_EXPORT
 626 | 	Verbosity current_verbosity_cutoff();
 627 | 
 628 | #if LOGURU_USE_FMTLIB
 629 | 	// Internal functions
 630 |     LOGURU_EXPORT
 631 | 	void vlog(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args args);
 632 |     LOGURU_EXPORT
 633 | 	void raw_vlog(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args args);
 634 | 
 635 | 	// Actual logging function. Use the LOG macro instead of calling this directly.
 636 | 	template <typename... Args>
 637 | 	LOGURU_EXPORT
 638 | 	void log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args &... args) {
 639 | 	    vlog(verbosity, file, line, format, fmt::make_format_args(args...));
 640 | 	}
 641 | 
 642 | 	// Log without any preamble or indentation.
 643 | 	template <typename... Args>
 644 | 	LOGURU_EXPORT
 645 | 	void raw_log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args &... args) {
 646 | 	    raw_vlog(verbosity, file, line, format, fmt::make_format_args(args...));
 647 | 	}
 648 | #else // LOGURU_USE_FMTLIB?
 649 | 	// Actual logging function. Use the LOG macro instead of calling this directly.
 650 | 	LOGURU_EXPORT
 651 | 	void log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(4, 5);
 652 | 
 653 | 	// Actual logging function.
 654 | 	LOGURU_EXPORT
 655 | 	void vlog(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, va_list) LOGURU_PRINTF_LIKE(4, 0);
 656 | 
 657 | 	// Log without any preamble or indentation.
 658 | 	LOGURU_EXPORT
 659 | 	void raw_log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(4, 5);
 660 | #endif // !LOGURU_USE_FMTLIB
 661 | 
 662 | 	// Helper class for LOG_SCOPE_F
 663 | 	class LOGURU_EXPORT LogScopeRAII
 664 | 	{
 665 | 	public:
 666 | 		LogScopeRAII() : _file(nullptr) {} // No logging
 667 | 		LogScopeRAII(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, va_list vlist) LOGURU_PRINTF_LIKE(5, 0);
 668 | 		LogScopeRAII(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(5, 6);
 669 | 		~LogScopeRAII();
 670 | 
 671 | 		void Init(LOGURU_FORMAT_STRING_TYPE format, va_list vlist) LOGURU_PRINTF_LIKE(2, 0);
 672 | 
 673 | #if defined(_MSC_VER) && _MSC_VER > 1800
 674 | 		// older MSVC default move ctors close the scope on move. See
 675 | 		// issue #43
 676 | 		LogScopeRAII(LogScopeRAII&& other)
 677 | 			: _verbosity(other._verbosity)
 678 | 			, _file(other._file)
 679 | 			, _line(other._line)
 680 | 			, _indent_stderr(other._indent_stderr)
 681 | 			, _start_time_ns(other._start_time_ns)
 682 | 		{
 683 | 			// Make sure the tmp object's destruction doesn't close the scope:
 684 | 			other._file = nullptr;
 685 | 
 686 | 			for (unsigned int i = 0; i < LOGURU_SCOPE_TEXT_SIZE; ++i) {
 687 | 				_name[i] = other._name[i];
 688 | 			}
 689 | 		}
 690 | #else
 691 | 		LogScopeRAII(LogScopeRAII&&) = default;
 692 | #endif
 693 | 
 694 | 	private:
 695 | 		LogScopeRAII(const LogScopeRAII&) = delete;
 696 | 		LogScopeRAII& operator=(const LogScopeRAII&) = delete;
 697 | 		void operator=(LogScopeRAII&&) = delete;
 698 | 
 699 | 		Verbosity   _verbosity;
 700 | 		const char* _file; // Set to null if we are disabled due to verbosity
 701 | 		unsigned    _line;
 702 | 		bool        _indent_stderr; // Did we?
 703 | 		long long   _start_time_ns;
 704 | 		char        _name[LOGURU_SCOPE_TEXT_SIZE];
 705 | 	};
 706 | 
 707 | 	// Marked as 'noreturn' for the benefit of the static analyzer and optimizer.
 708 | 	// stack_trace_skip is the number of extrace stack frames to skip above log_and_abort.
 709 | #if LOGURU_USE_FMTLIB
 710 | 	LOGURU_EXPORT
 711 | 	LOGURU_NORETURN void vlog_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args);
 712 | 	template <typename... Args>
 713 | 	LOGURU_EXPORT
 714 | 	LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args&... args) {
 715 | 	    vlog_and_abort(stack_trace_skip, expr, file, line, format, fmt::make_format_args(args...));
 716 | 	}
 717 | #else
 718 | 	LOGURU_EXPORT
 719 | 	LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(5, 6);
 720 | #endif
 721 | 	LOGURU_EXPORT
 722 | 	LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line);
 723 | 
 724 | 	// Flush output to stderr and files.
 725 | 	// If g_flush_interval_ms is set to non-zero, this will be called automatically this often.
 726 | 	// If not set, you do not need to call this at all.
 727 | 	LOGURU_EXPORT
 728 | 	void flush();
 729 | 
 730 | 	template<class T> inline Text format_value(const T&)                    { return textprintf("N/A");     }
 731 | 	template<>        inline Text format_value(const char& v)               { return textprintf(LOGURU_FMT(c),   v); }
 732 | 	template<>        inline Text format_value(const int& v)                { return textprintf(LOGURU_FMT(d),   v); }
 733 | 	template<>        inline Text format_value(const float& v)              { return textprintf(LOGURU_FMT(f),   v); }
 734 | 	template<>        inline Text format_value(const double& v)             { return textprintf(LOGURU_FMT(f),   v); }
 735 | 
 736 | #if LOGURU_USE_FMTLIB
 737 | 	template<>        inline Text format_value(const unsigned int& v)       { return textprintf(LOGURU_FMT(d), v); }
 738 | 	template<>        inline Text format_value(const long& v)               { return textprintf(LOGURU_FMT(d), v); }
 739 | 	template<>        inline Text format_value(const unsigned long& v)      { return textprintf(LOGURU_FMT(d), v); }
 740 | 	template<>        inline Text format_value(const long long& v)          { return textprintf(LOGURU_FMT(d), v); }
 741 | 	template<>        inline Text format_value(const unsigned long long& v) { return textprintf(LOGURU_FMT(d), v); }
 742 | #else
 743 | 	template<>        inline Text format_value(const unsigned int& v)       { return textprintf(LOGURU_FMT(u),   v); }
 744 | 	template<>        inline Text format_value(const long& v)               { return textprintf(LOGURU_FMT(lu),  v); }
 745 | 	template<>        inline Text format_value(const unsigned long& v)      { return textprintf(LOGURU_FMT(ld),  v); }
 746 | 	template<>        inline Text format_value(const long long& v)          { return textprintf(LOGURU_FMT(llu), v); }
 747 | 	template<>        inline Text format_value(const unsigned long long& v) { return textprintf(LOGURU_FMT(lld), v); }
 748 | #endif
 749 | 
 750 | 	/* Thread names can be set for the benefit of readable logs.
 751 | 	   If you do not set the thread name, a hex id will be shown instead.
 752 | 	   These thread names may or may not be the same as the system thread names,
 753 | 	   depending on the system.
 754 | 	   Try to limit the thread name to 15 characters or less. */
 755 | 	LOGURU_EXPORT
 756 | 	void set_thread_name(const char* name);
 757 | 
 758 | 	/* Returns the thread name for this thread.
 759 | 	   On most *nix systems this will return the system thread name (settable from both within and without Loguru).
 760 | 	   On other systems it will return whatever you set in `set_thread_name()`;
 761 | 	   If no thread name is set, this will return a hexadecimal thread id.
 762 | 	   `length` should be the number of bytes available in the buffer.
 763 | 	   17 is a good number for length.
 764 | 	   `right_align_hex_id` means any hexadecimal thread id will be written to the end of buffer.
 765 | 	*/
 766 | 	LOGURU_EXPORT
 767 | 	void get_thread_name(char* buffer, unsigned long long length, bool right_align_hex_id);
 768 | 
 769 | 	/* Generates a readable stacktrace as a string.
 770 | 	   'skip' specifies how many stack frames to skip.
 771 | 	   For instance, the default skip (1) means:
 772 | 	   don't include the call to loguru::stacktrace in the stack trace. */
 773 | 	LOGURU_EXPORT
 774 | 	Text stacktrace(int skip = 1);
 775 | 
 776 | 	/*  Add a string to be replaced with something else in the stack output.
 777 | 
 778 | 		For instance, instead of having a stack trace look like this:
 779 | 			0x41f541 some_function(std::basic_ofstream<char, std::char_traits<char> >&)
 780 | 		You can clean it up with:
 781 | 			auto verbose_type_name = loguru::demangle(typeid(std::ofstream).name());
 782 | 			loguru::add_stack_cleanup(verbose_type_name.c_str(); "std::ofstream");
 783 | 		So the next time you will instead see:
 784 | 			0x41f541 some_function(std::ofstream&)
 785 | 
 786 | 		`replace_with_this` must be shorter than `find_this`.
 787 | 	*/
 788 | 	LOGURU_EXPORT
 789 | 	void add_stack_cleanup(const char* find_this, const char* replace_with_this);
 790 | 
 791 | 	// Example: demangle(typeid(std::ofstream).name()) -> "std::basic_ofstream<char, std::char_traits<char> >"
 792 | 	LOGURU_EXPORT
 793 | 	Text demangle(const char* name);
 794 | 
 795 | 	// ------------------------------------------------------------------------
 796 | 	/*
 797 | 	Not all terminals support colors, but if they do, and g_colorlogtostderr
 798 | 	is set, Loguru will write them to stderr to make errors in red, etc.
 799 | 
 800 | 	You also have the option to manually use them, via the function below.
 801 | 
 802 | 	Note, however, that if you do, the color codes could end up in your logfile!
 803 | 
 804 | 	This means if you intend to use them functions you should either:
 805 | 		* Use them on the stderr/stdout directly (bypass Loguru).
 806 | 		* Don't add file outputs to Loguru.
 807 | 		* Expect some \e[1m things in your logfile.
 808 | 
 809 | 	Usage:
 810 | 		printf("%sRed%sGreen%sBold green%sClear again\n",
 811 | 			   loguru::terminal_red(), loguru::terminal_green(),
 812 | 			   loguru::terminal_bold(), loguru::terminal_reset());
 813 | 
 814 | 	If the terminal at hand does not support colors the above output
 815 | 	will just not have funky \e[1m things showing.
 816 | 	*/
 817 | 
 818 | 	// Do the output terminal support colors?
 819 | 	LOGURU_EXPORT
 820 | 	bool terminal_has_color();
 821 | 
 822 | 	// Colors
 823 | 	LOGURU_EXPORT const char* terminal_black();
 824 | 	LOGURU_EXPORT const char* terminal_red();
 825 | 	LOGURU_EXPORT const char* terminal_green();
 826 | 	LOGURU_EXPORT const char* terminal_yellow();
 827 | 	LOGURU_EXPORT const char* terminal_blue();
 828 | 	LOGURU_EXPORT const char* terminal_purple();
 829 | 	LOGURU_EXPORT const char* terminal_cyan();
 830 | 	LOGURU_EXPORT const char* terminal_light_gray();
 831 | 	LOGURU_EXPORT const char* terminal_light_red();
 832 | 	LOGURU_EXPORT const char* terminal_white();
 833 | 
 834 | 	// Formating
 835 | 	LOGURU_EXPORT const char* terminal_bold();
 836 | 	LOGURU_EXPORT const char* terminal_underline();
 837 | 
 838 | 	// You should end each line with this!
 839 | 	LOGURU_EXPORT const char* terminal_reset();
 840 | 
 841 | 	// --------------------------------------------------------------------
 842 | 	// Error context related:
 843 | 
 844 | 	struct StringStream;
 845 | 
 846 | 	// Use this in your EcEntryBase::print_value overload.
 847 | 	LOGURU_EXPORT
 848 | 	void stream_print(StringStream& out_string_stream, const char* text);
 849 | 
 850 | 	class LOGURU_EXPORT EcEntryBase
 851 | 	{
 852 | 	public:
 853 | 		EcEntryBase(const char* file, unsigned line, const char* descr);
 854 | 		~EcEntryBase();
 855 | 		EcEntryBase(const EcEntryBase&) = delete;
 856 | 		EcEntryBase(EcEntryBase&&) = delete;
 857 | 		EcEntryBase& operator=(const EcEntryBase&) = delete;
 858 | 		EcEntryBase& operator=(EcEntryBase&&) = delete;
 859 | 
 860 | 		virtual void print_value(StringStream& out_string_stream) const = 0;
 861 | 
 862 | 		EcEntryBase* previous() const { return _previous; }
 863 | 
 864 | 	// private:
 865 | 		const char*  _file;
 866 | 		unsigned     _line;
 867 | 		const char*  _descr;
 868 | 		EcEntryBase* _previous;
 869 | 	};
 870 | 
 871 | 	template<typename T>
 872 | 	class EcEntryData : public EcEntryBase
 873 | 	{
 874 | 	public:
 875 | 		using Printer = Text(*)(T data);
 876 | 
 877 | 		EcEntryData(const char* file, unsigned line, const char* descr, T data, Printer&& printer)
 878 | 			: EcEntryBase(file, line, descr), _data(data), _printer(printer) {}
 879 | 
 880 | 		virtual void print_value(StringStream& out_string_stream) const override
 881 | 		{
 882 | 			const auto str = _printer(_data);
 883 | 			stream_print(out_string_stream, str.c_str());
 884 | 		}
 885 | 
 886 | 	private:
 887 | 		T       _data;
 888 | 		Printer _printer;
 889 | 	};
 890 | 
 891 | 	// template<typename Printer>
 892 | 	// class EcEntryLambda : public EcEntryBase
 893 | 	// {
 894 | 	// public:
 895 | 	// 	EcEntryLambda(const char* file, unsigned line, const char* descr, Printer&& printer)
 896 | 	// 		: EcEntryBase(file, line, descr), _printer(std::move(printer)) {}
 897 | 
 898 | 	// 	virtual void print_value(StringStream& out_string_stream) const override
 899 | 	// 	{
 900 | 	// 		const auto str = _printer();
 901 | 	// 		stream_print(out_string_stream, str.c_str());
 902 | 	// 	}
 903 | 
 904 | 	// private:
 905 | 	// 	Printer _printer;
 906 | 	// };
 907 | 
 908 | 	// template<typename Printer>
 909 | 	// EcEntryLambda<Printer> make_ec_entry_lambda(const char* file, unsigned line, const char* descr, Printer&& printer)
 910 | 	// {
 911 | 	// 	return {file, line, descr, std::move(printer)};
 912 | 	// }
 913 | 
 914 | 	template <class T>
 915 | 	struct decay_char_array { using type = T; };
 916 | 
 917 | 	template <unsigned long long  N>
 918 | 	struct decay_char_array<const char(&)[N]> { using type = const char*; };
 919 | 
 920 | 	template <class T>
 921 | 	struct make_const_ptr { using type = T; };
 922 | 
 923 | 	template <class T>
 924 | 	struct make_const_ptr<T*> { using type = const T*; };
 925 | 
 926 | 	template <class T>
 927 | 	struct make_ec_type { using type = typename make_const_ptr<typename decay_char_array<T>::type>::type; };
 928 | 
 929 | 	/* 	A stack trace gives you the names of the function at the point of a crash.
 930 | 		With ERROR_CONTEXT, you can also get the values of select local variables.
 931 | 		Usage:
 932 | 
 933 | 		void process_customers(const std::string& filename)
 934 | 		{
 935 | 			ERROR_CONTEXT("Processing file", filename.c_str());
 936 | 			for (int customer_index : ...)
 937 | 			{
 938 | 				ERROR_CONTEXT("Customer index", customer_index);
 939 | 				...
 940 | 			}
 941 | 		}
 942 | 
 943 | 		The context is in effect during the scope of the ERROR_CONTEXT.
 944 | 		Use loguru::get_error_context() to get the contents of the active error contexts.
 945 | 
 946 | 		Example result:
 947 | 
 948 | 		------------------------------------------------
 949 | 		[ErrorContext]                main.cpp:416   Processing file:    "customers.json"
 950 | 		[ErrorContext]                main.cpp:417   Customer index:     42
 951 | 		------------------------------------------------
 952 | 
 953 | 		Error contexts are printed automatically on crashes, and only on crashes.
 954 | 		This makes them much faster than logging the value of a variable.
 955 | 	*/
 956 | 	#define ERROR_CONTEXT(descr, data)                                             \
 957 | 		const loguru::EcEntryData<loguru::make_ec_type<decltype(data)>::type>      \
 958 | 			LOGURU_ANONYMOUS_VARIABLE(error_context_scope_)(                       \
 959 | 				__FILE__, __LINE__, descr, data,                                   \
 960 | 				static_cast<loguru::EcEntryData<loguru::make_ec_type<decltype(data)>::type>::Printer>(loguru::ec_to_text) ) // For better error messages
 961 | 
 962 | /*
 963 | 	#define ERROR_CONTEXT(descr, data)                                 \
 964 | 		const auto LOGURU_ANONYMOUS_VARIABLE(error_context_scope_)(    \
 965 | 			loguru::make_ec_entry_lambda(__FILE__, __LINE__, descr,    \
 966 | 				[=](){ return loguru::ec_to_text(data); }))
 967 | */
 968 | 
 969 | 	using EcHandle = const EcEntryBase*;
 970 | 
 971 | 	/*
 972 | 		Get a light-weight handle to the error context stack on this thread.
 973 | 		The handle is valid as long as the current thread has no changes to its error context stack.
 974 | 		You can pass the handle to loguru::get_error_context on another thread.
 975 | 		This can be very useful for when you have a parent thread spawning several working threads,
 976 | 		and you want the error context of the parent thread to get printed (too) when there is an
 977 | 		error on the child thread. You can accomplish this thusly:
 978 | 
 979 | 		void foo(const char* parameter)
 980 | 		{
 981 | 			ERROR_CONTEXT("parameter", parameter)
 982 | 			const auto parent_ec_handle = loguru::get_thread_ec_handle();
 983 | 
 984 | 			std::thread([=]{
 985 | 				loguru::set_thread_name("child thread");
 986 | 				ERROR_CONTEXT("parent context", parent_ec_handle);
 987 | 				dangerous_code();
 988 | 			}.join();
 989 | 		}
 990 | 
 991 | 	*/
 992 | 	LOGURU_EXPORT
 993 | 	EcHandle get_thread_ec_handle();
 994 | 
 995 | 	// Get a string describing the current stack of error context. Empty string if there is none.
 996 | 	LOGURU_EXPORT
 997 | 	Text get_error_context();
 998 | 
 999 | 	// Get a string describing the error context of the given thread handle.
1000 | 	LOGURU_EXPORT
1001 | 	Text get_error_context_for(EcHandle ec_handle);
1002 | 
1003 | 	// ------------------------------------------------------------------------
1004 | 
1005 | 	LOGURU_EXPORT Text ec_to_text(const char* data);
1006 | 	LOGURU_EXPORT Text ec_to_text(char data);
1007 | 	LOGURU_EXPORT Text ec_to_text(int data);
1008 | 	LOGURU_EXPORT Text ec_to_text(unsigned int data);
1009 | 	LOGURU_EXPORT Text ec_to_text(long data);
1010 | 	LOGURU_EXPORT Text ec_to_text(unsigned long data);
1011 | 	LOGURU_EXPORT Text ec_to_text(long long data);
1012 | 	LOGURU_EXPORT Text ec_to_text(unsigned long long data);
1013 | 	LOGURU_EXPORT Text ec_to_text(float data);
1014 | 	LOGURU_EXPORT Text ec_to_text(double data);
1015 | 	LOGURU_EXPORT Text ec_to_text(long double data);
1016 | 	LOGURU_EXPORT Text ec_to_text(EcHandle);
1017 | 
1018 | 	/*
1019 | 	You can add ERROR_CONTEXT support for your own types by overloading ec_to_text. Here's how:
1020 | 
1021 | 	some.hpp:
1022 | 		namespace loguru {
1023 | 			Text ec_to_text(MySmallType data)
1024 | 			Text ec_to_text(const MyBigType* data)
1025 | 		} // namespace loguru
1026 | 
1027 | 	some.cpp:
1028 | 		namespace loguru {
1029 | 			Text ec_to_text(MySmallType small_value)
1030 | 			{
1031 | 				// Called only when needed, i.e. on a crash.
1032 | 				std::string str = small_value.as_string(); // Format 'small_value' here somehow.
1033 | 				return Text{STRDUP(str.c_str())};
1034 | 			}
1035 | 
1036 | 			Text ec_to_text(const MyBigType* big_value)
1037 | 			{
1038 | 				// Called only when needed, i.e. on a crash.
1039 | 				std::string str = big_value->as_string(); // Format 'big_value' here somehow.
1040 | 				return Text{STRDUP(str.c_str())};
1041 | 			}
1042 | 		} // namespace loguru
1043 | 
1044 | 	Any file that include some.hpp:
1045 | 		void foo(MySmallType small, const MyBigType& big)
1046 | 		{
1047 | 			ERROR_CONTEXT("Small", small); // Copy ´small` by value.
1048 | 			ERROR_CONTEXT("Big",   &big);  // `big` should not change during this scope!
1049 | 			....
1050 | 		}
1051 | 	*/
1052 | } // namespace loguru
1053 | 
1054 | LOGURU_ANONYMOUS_NAMESPACE_END
1055 | 
1056 | // --------------------------------------------------------------------
1057 | // Logging macros
1058 | 
1059 | // LOG_F(2, "Only logged if verbosity is 2 or higher: %d", some_number);
1060 | #define VLOG_F(verbosity, ...)                                                                     \
1061 | 	((verbosity) > loguru::current_verbosity_cutoff()) ? (void)0                                   \
1062 | 									  : loguru::log(verbosity, __FILE__, __LINE__, __VA_ARGS__)
1063 | 
1064 | // LOG_F(INFO, "Foo: %d", some_number);
1065 | #define LOG_F(verbosity_name, ...) VLOG_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__)
1066 | 
1067 | #define VLOG_IF_F(verbosity, cond, ...)                                                            \
1068 | 	((verbosity) > loguru::current_verbosity_cutoff() || (cond) == false)                          \
1069 | 		? (void)0                                                                                  \
1070 | 		: loguru::log(verbosity, __FILE__, __LINE__, __VA_ARGS__)
1071 | 
1072 | #define LOG_IF_F(verbosity_name, cond, ...)                                                        \
1073 | 	VLOG_IF_F(loguru::Verbosity_ ## verbosity_name, cond, __VA_ARGS__)
1074 | 
1075 | #define VLOG_SCOPE_F(verbosity, ...)                                                               \
1076 | 	loguru::LogScopeRAII LOGURU_ANONYMOUS_VARIABLE(error_context_RAII_) =                          \
1077 | 	((verbosity) > loguru::current_verbosity_cutoff()) ? loguru::LogScopeRAII() :                  \
1078 | 	loguru::LogScopeRAII(verbosity, __FILE__, __LINE__, __VA_ARGS__)
1079 | 
1080 | // Raw logging - no preamble, no indentation. Slightly faster than full logging.
1081 | #define RAW_VLOG_F(verbosity, ...)                                                                 \
1082 | 	((verbosity) > loguru::current_verbosity_cutoff()) ? (void)0                                   \
1083 | 									  : loguru::raw_log(verbosity, __FILE__, __LINE__, __VA_ARGS__)
1084 | 
1085 | #define RAW_LOG_F(verbosity_name, ...) RAW_VLOG_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__)
1086 | 
1087 | // Use to book-end a scope. Affects logging on all threads.
1088 | #define LOG_SCOPE_F(verbosity_name, ...)                                                           \
1089 | 	VLOG_SCOPE_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__)
1090 | 
1091 | #define LOG_SCOPE_FUNCTION(verbosity_name) LOG_SCOPE_F(verbosity_name, __func__)
1092 | 
1093 | // -----------------------------------------------
1094 | // ABORT_F macro. Usage:  ABORT_F("Cause of error: %s", error_str);
1095 | 
1096 | // Message is optional
1097 | #define ABORT_F(...) loguru::log_and_abort(0, "ABORT: ", __FILE__, __LINE__, __VA_ARGS__)
1098 | 
1099 | // --------------------------------------------------------------------
1100 | // CHECK_F macros:
1101 | 
1102 | #define CHECK_WITH_INFO_F(test, info, ...)                                                         \
1103 | 	LOGURU_PREDICT_TRUE((test) == true) ? (void)0 : loguru::log_and_abort(0, "CHECK FAILED:  " info "  ", __FILE__,      \
1104 | 													   __LINE__, ##__VA_ARGS__)
1105 | 
1106 | /* Checked at runtime too. Will print error, then call fatal_handler (if any), then 'abort'.
1107 |    Note that the test must be boolean.
1108 |    CHECK_F(ptr); will not compile, but CHECK_F(ptr != nullptr); will. */
1109 | #define CHECK_F(test, ...) CHECK_WITH_INFO_F(test, #test, ##__VA_ARGS__)
1110 | 
1111 | #define CHECK_NOTNULL_F(x, ...) CHECK_WITH_INFO_F((x) != nullptr, #x " != nullptr", ##__VA_ARGS__)
1112 | 
1113 | #define CHECK_OP_F(expr_left, expr_right, op, ...)                                                 \
1114 | 	do                                                                                             \
1115 | 	{                                                                                              \
1116 | 		auto val_left = expr_left;                                                                 \
1117 | 		auto val_right = expr_right;                                                               \
1118 | 		if (! LOGURU_PREDICT_TRUE(val_left op val_right))                                          \
1119 | 		{                                                                                          \
1120 | 			auto str_left = loguru::format_value(val_left);                                        \
1121 | 			auto str_right = loguru::format_value(val_right);                                      \
1122 | 			auto fail_info = loguru::textprintf("CHECK FAILED:  " LOGURU_FMT(s) " " LOGURU_FMT(s) " " LOGURU_FMT(s) "  (" LOGURU_FMT(s) " " LOGURU_FMT(s) " " LOGURU_FMT(s) ")  ",           \
1123 | 				#expr_left, #op, #expr_right, str_left.c_str(), #op, str_right.c_str());           \
1124 | 			auto user_msg = loguru::textprintf(__VA_ARGS__);                                       \
1125 | 			loguru::log_and_abort(0, fail_info.c_str(), __FILE__, __LINE__,                        \
1126 | 			                      LOGURU_FMT(s), user_msg.c_str());                                         \
1127 | 		}                                                                                          \
1128 | 	} while (false)
1129 | 
1130 | #ifndef LOGURU_DEBUG_LOGGING
1131 | 	#ifndef NDEBUG
1132 | 		#define LOGURU_DEBUG_LOGGING 1
1133 | 	#else
1134 | 		#define LOGURU_DEBUG_LOGGING 0
1135 | 	#endif
1136 | #endif
1137 | 
1138 | #if LOGURU_DEBUG_LOGGING
1139 | 	// Debug logging enabled:
1140 | 	#define DLOG_F(verbosity_name, ...)     LOG_F(verbosity_name, __VA_ARGS__)
1141 | 	#define DVLOG_F(verbosity, ...)         VLOG_F(verbosity, __VA_ARGS__)
1142 | 	#define DLOG_IF_F(verbosity_name, ...)  LOG_IF_F(verbosity_name, __VA_ARGS__)
1143 | 	#define DVLOG_IF_F(verbosity, ...)      VLOG_IF_F(verbosity, __VA_ARGS__)
1144 | 	#define DRAW_LOG_F(verbosity_name, ...) RAW_LOG_F(verbosity_name, __VA_ARGS__)
1145 | 	#define DRAW_VLOG_F(verbosity, ...)     RAW_VLOG_F(verbosity, __VA_ARGS__)
1146 | #else
1147 | 	// Debug logging disabled:
1148 | 	#define DLOG_F(verbosity_name, ...)
1149 | 	#define DVLOG_F(verbosity, ...)
1150 | 	#define DLOG_IF_F(verbosity_name, ...)
1151 | 	#define DVLOG_IF_F(verbosity, ...)
1152 | 	#define DRAW_LOG_F(verbosity_name, ...)
1153 | 	#define DRAW_VLOG_F(verbosity, ...)
1154 | #endif
1155 | 
1156 | #define CHECK_EQ_F(a, b, ...) CHECK_OP_F(a, b, ==, ##__VA_ARGS__)
1157 | #define CHECK_NE_F(a, b, ...) CHECK_OP_F(a, b, !=, ##__VA_ARGS__)
1158 | #define CHECK_LT_F(a, b, ...) CHECK_OP_F(a, b, < , ##__VA_ARGS__)
1159 | #define CHECK_GT_F(a, b, ...) CHECK_OP_F(a, b, > , ##__VA_ARGS__)
1160 | #define CHECK_LE_F(a, b, ...) CHECK_OP_F(a, b, <=, ##__VA_ARGS__)
1161 | #define CHECK_GE_F(a, b, ...) CHECK_OP_F(a, b, >=, ##__VA_ARGS__)
1162 | 
1163 | #ifndef LOGURU_DEBUG_CHECKS
1164 | 	#ifndef NDEBUG
1165 | 		#define LOGURU_DEBUG_CHECKS 1
1166 | 	#else
1167 | 		#define LOGURU_DEBUG_CHECKS 0
1168 | 	#endif
1169 | #endif
1170 | 
1171 | #if LOGURU_DEBUG_CHECKS
1172 | 	// Debug checks enabled:
1173 | 	#define DCHECK_F(test, ...)             CHECK_F(test, ##__VA_ARGS__)
1174 | 	#define DCHECK_NOTNULL_F(x, ...)        CHECK_NOTNULL_F(x, ##__VA_ARGS__)
1175 | 	#define DCHECK_EQ_F(a, b, ...)          CHECK_EQ_F(a, b, ##__VA_ARGS__)
1176 | 	#define DCHECK_NE_F(a, b, ...)          CHECK_NE_F(a, b, ##__VA_ARGS__)
1177 | 	#define DCHECK_LT_F(a, b, ...)          CHECK_LT_F(a, b, ##__VA_ARGS__)
1178 | 	#define DCHECK_LE_F(a, b, ...)          CHECK_LE_F(a, b, ##__VA_ARGS__)
1179 | 	#define DCHECK_GT_F(a, b, ...)          CHECK_GT_F(a, b, ##__VA_ARGS__)
1180 | 	#define DCHECK_GE_F(a, b, ...)          CHECK_GE_F(a, b, ##__VA_ARGS__)
1181 | #else
1182 | 	// Debug checks disabled:
1183 | 	#define DCHECK_F(test, ...)
1184 | 	#define DCHECK_NOTNULL_F(x, ...)
1185 | 	#define DCHECK_EQ_F(a, b, ...)
1186 | 	#define DCHECK_NE_F(a, b, ...)
1187 | 	#define DCHECK_LT_F(a, b, ...)
1188 | 	#define DCHECK_LE_F(a, b, ...)
1189 | 	#define DCHECK_GT_F(a, b, ...)
1190 | 	#define DCHECK_GE_F(a, b, ...)
1191 | #endif // NDEBUG
1192 | 
1193 | 
1194 | #if LOGURU_REDEFINE_ASSERT
1195 | 	#undef assert
1196 | 	#ifndef NDEBUG
1197 | 		// Debug:
1198 | 		#define assert(test) CHECK_WITH_INFO_F(!!(test), #test) // HACK
1199 | 	#else
1200 | 		#define assert(test)
1201 | 	#endif
1202 | #endif // LOGURU_REDEFINE_ASSERT
1203 | 
1204 | #endif // LOGURU_HAS_DECLARED_FORMAT_HEADER
1205 | 
1206 | // ----------------------------------------------------------------------------
1207 | // .dP"Y8 888888 88""Yb 888888    db    8b    d8 .dP"Y8
1208 | // `Ybo."   88   88__dP 88__     dPYb   88b  d88 `Ybo."
1209 | // o.`Y8b   88   88"Yb  88""    dP__Yb  88YbdP88 o.`Y8b
1210 | // 8bodP'   88   88  Yb 888888 dP""""Yb 88 YY 88 8bodP'
1211 | 
1212 | #if LOGURU_WITH_STREAMS
1213 | #ifndef LOGURU_HAS_DECLARED_STREAMS_HEADER
1214 | #define LOGURU_HAS_DECLARED_STREAMS_HEADER
1215 | 
1216 | /* This file extends loguru to enable std::stream-style logging, a la Glog.
1217 |    It's an optional feature behind the LOGURU_WITH_STREAMS settings
1218 |    because including it everywhere will slow down compilation times.
1219 | */
1220 | 
1221 | #include <cstdarg>
1222 | #include <sstream> // Adds about 38 kLoC on clang.
1223 | #include <string>
1224 | 
1225 | LOGURU_ANONYMOUS_NAMESPACE_BEGIN
1226 | 
1227 | namespace loguru
1228 | {
1229 | 	// Like sprintf, but returns the formated text.
1230 | 	LOGURU_EXPORT
1231 | 	std::string strprintf(LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(1, 2);
1232 | 
1233 | 	// Like vsprintf, but returns the formated text.
1234 | 	LOGURU_EXPORT
1235 | 	std::string vstrprintf(LOGURU_FORMAT_STRING_TYPE format, va_list) LOGURU_PRINTF_LIKE(1, 0);
1236 | 
1237 | 	class LOGURU_EXPORT StreamLogger
1238 | 	{
1239 | 	public:
1240 | 		StreamLogger(Verbosity verbosity, const char* file, unsigned line) : _verbosity(verbosity), _file(file), _line(line) {}
1241 | 		~StreamLogger() noexcept(false);
1242 | 
1243 | 		template<typename T>
1244 | 		StreamLogger& operator<<(const T& t)
1245 | 		{
1246 | 			_ss << t;
1247 | 			return *this;
1248 | 		}
1249 | 
1250 | 		// std::endl and other iomanip:s.
1251 | 		StreamLogger& operator<<(std::ostream&(*f)(std::ostream&))
1252 | 		{
1253 | 			f(_ss);
1254 | 			return *this;
1255 | 		}
1256 | 
1257 | 	private:
1258 | 		Verbosity   _verbosity;
1259 | 		const char* _file;
1260 | 		unsigned    _line;
1261 | 		std::ostringstream _ss;
1262 | 	};
1263 | 
1264 | 	class LOGURU_EXPORT AbortLogger
1265 | 	{
1266 | 	public:
1267 | 		AbortLogger(const char* expr, const char* file, unsigned line) : _expr(expr), _file(file), _line(line) { }
1268 | 		LOGURU_NORETURN ~AbortLogger() noexcept(false);
1269 | 
1270 | 		template<typename T>
1271 | 		AbortLogger& operator<<(const T& t)
1272 | 		{
1273 | 			_ss << t;
1274 | 			return *this;
1275 | 		}
1276 | 
1277 | 		// std::endl and other iomanip:s.
1278 | 		AbortLogger& operator<<(std::ostream&(*f)(std::ostream&))
1279 | 		{
1280 | 			f(_ss);
1281 | 			return *this;
1282 | 		}
1283 | 
1284 | 	private:
1285 | 		const char*        _expr;
1286 | 		const char*        _file;
1287 | 		unsigned           _line;
1288 | 		std::ostringstream _ss;
1289 | 	};
1290 | 
1291 | 	class LOGURU_EXPORT Voidify
1292 | 	{
1293 | 	public:
1294 | 		Voidify() {}
1295 | 		// This has to be an operator with a precedence lower than << but higher than ?:
1296 | 		void operator&(const StreamLogger&) { }
1297 | 		void operator&(const AbortLogger&)  { }
1298 | 	};
1299 | 
1300 | 	/*  Helper functions for CHECK_OP_S macro.
1301 | 		GLOG trick: The (int, int) specialization works around the issue that the compiler
1302 | 		will not instantiate the template version of the function on values of unnamed enum type. */
1303 | 	#define DEFINE_CHECK_OP_IMPL(name, op)                                                             \
1304 | 		template <typename T1, typename T2>                                                            \
1305 | 		inline std::string* name(const char* expr, const T1& v1, const char* op_str, const T2& v2)     \
1306 | 		{                                                                                              \
1307 | 			if (LOGURU_PREDICT_TRUE(v1 op v2)) { return NULL; }                                        \
1308 | 			std::ostringstream ss;                                                                     \
1309 | 			ss << "CHECK FAILED:  " << expr << "  (" << v1 << " " << op_str << " " << v2 << ")  ";     \
1310 | 			return new std::string(ss.str());                                                          \
1311 | 		}                                                                                              \
1312 | 		inline std::string* name(const char* expr, int v1, const char* op_str, int v2)                 \
1313 | 		{                                                                                              \
1314 | 			return name<int, int>(expr, v1, op_str, v2);                                               \
1315 | 		}
1316 | 
1317 | 	DEFINE_CHECK_OP_IMPL(check_EQ_impl, ==)
1318 | 	DEFINE_CHECK_OP_IMPL(check_NE_impl, !=)
1319 | 	DEFINE_CHECK_OP_IMPL(check_LE_impl, <=)
1320 | 	DEFINE_CHECK_OP_IMPL(check_LT_impl, < )
1321 | 	DEFINE_CHECK_OP_IMPL(check_GE_impl, >=)
1322 | 	DEFINE_CHECK_OP_IMPL(check_GT_impl, > )
1323 | 	#undef DEFINE_CHECK_OP_IMPL
1324 | 
1325 | 	/*  GLOG trick: Function is overloaded for integral types to allow static const integrals
1326 | 		declared in classes and not defined to be used as arguments to CHECK* macros. */
1327 | 	template <class T>
1328 | 	inline const T&           referenceable_value(const T&           t) { return t; }
1329 | 	inline char               referenceable_value(char               t) { return t; }
1330 | 	inline unsigned char      referenceable_value(unsigned char      t) { return t; }
1331 | 	inline signed char        referenceable_value(signed char        t) { return t; }
1332 | 	inline short              referenceable_value(short              t) { return t; }
1333 | 	inline unsigned short     referenceable_value(unsigned short     t) { return t; }
1334 | 	inline int                referenceable_value(int                t) { return t; }
1335 | 	inline unsigned int       referenceable_value(unsigned int       t) { return t; }
1336 | 	inline long               referenceable_value(long               t) { return t; }
1337 | 	inline unsigned long      referenceable_value(unsigned long      t) { return t; }
1338 | 	inline long long          referenceable_value(long long          t) { return t; }
1339 | 	inline unsigned long long referenceable_value(unsigned long long t) { return t; }
1340 | } // namespace loguru
1341 | 
1342 | LOGURU_ANONYMOUS_NAMESPACE_END
1343 | 
1344 | // -----------------------------------------------
1345 | // Logging macros:
1346 | 
1347 | // usage:  LOG_STREAM(INFO) << "Foo " << std::setprecision(10) << some_value;
1348 | #define VLOG_IF_S(verbosity, cond)                                                                 \
1349 | 	((verbosity) > loguru::current_verbosity_cutoff() || (cond) == false)                          \
1350 | 		? (void)0                                                                                  \
1351 | 		: loguru::Voidify() & loguru::StreamLogger(verbosity, __FILE__, __LINE__)
1352 | #define LOG_IF_S(verbosity_name, cond) VLOG_IF_S(loguru::Verbosity_ ## verbosity_name, cond)
1353 | #define VLOG_S(verbosity)              VLOG_IF_S(verbosity, true)
1354 | #define LOG_S(verbosity_name)          VLOG_S(loguru::Verbosity_ ## verbosity_name)
1355 | 
1356 | // -----------------------------------------------
1357 | // ABORT_S macro. Usage:  ABORT_S() << "Causo of error: " << details;
1358 | 
1359 | #define ABORT_S() loguru::Voidify() & loguru::AbortLogger("ABORT: ", __FILE__, __LINE__)
1360 | 
1361 | // -----------------------------------------------
1362 | // CHECK_S macros:
1363 | 
1364 | #define CHECK_WITH_INFO_S(cond, info)                                                              \
1365 | 	LOGURU_PREDICT_TRUE((cond) == true)                                                            \
1366 | 		? (void)0                                                                                  \
1367 | 		: loguru::Voidify() & loguru::AbortLogger("CHECK FAILED:  " info "  ", __FILE__, __LINE__)
1368 | 
1369 | #define CHECK_S(cond) CHECK_WITH_INFO_S(cond, #cond)
1370 | #define CHECK_NOTNULL_S(x) CHECK_WITH_INFO_S((x) != nullptr, #x " != nullptr")
1371 | 
1372 | #define CHECK_OP_S(function_name, expr1, op, expr2)                                                \
1373 | 	while (auto error_string = loguru::function_name(#expr1 " " #op " " #expr2,                    \
1374 | 													 loguru::referenceable_value(expr1), #op,      \
1375 | 													 loguru::referenceable_value(expr2)))          \
1376 | 		loguru::AbortLogger(error_string->c_str(), __FILE__, __LINE__)
1377 | 
1378 | #define CHECK_EQ_S(expr1, expr2) CHECK_OP_S(check_EQ_impl, expr1, ==, expr2)
1379 | #define CHECK_NE_S(expr1, expr2) CHECK_OP_S(check_NE_impl, expr1, !=, expr2)
1380 | #define CHECK_LE_S(expr1, expr2) CHECK_OP_S(check_LE_impl, expr1, <=, expr2)
1381 | #define CHECK_LT_S(expr1, expr2) CHECK_OP_S(check_LT_impl, expr1, < , expr2)
1382 | #define CHECK_GE_S(expr1, expr2) CHECK_OP_S(check_GE_impl, expr1, >=, expr2)
1383 | #define CHECK_GT_S(expr1, expr2) CHECK_OP_S(check_GT_impl, expr1, > , expr2)
1384 | 
1385 | #if LOGURU_DEBUG_LOGGING
1386 | 	// Debug logging enabled:
1387 | 	#define DVLOG_IF_S(verbosity, cond)     VLOG_IF_S(verbosity, cond)
1388 | 	#define DLOG_IF_S(verbosity_name, cond) LOG_IF_S(verbosity_name, cond)
1389 | 	#define DVLOG_S(verbosity)              VLOG_S(verbosity)
1390 | 	#define DLOG_S(verbosity_name)          LOG_S(verbosity_name)
1391 | #else
1392 | 	// Debug logging disabled:
1393 | 	#define DVLOG_IF_S(verbosity, cond)                                                     \
1394 | 		(true || (verbosity) > loguru::current_verbosity_cutoff() || (cond) == false)       \
1395 | 			? (void)0                                                                       \
1396 | 			: loguru::Voidify() & loguru::StreamLogger(verbosity, __FILE__, __LINE__)
1397 | 
1398 | 	#define DLOG_IF_S(verbosity_name, cond) DVLOG_IF_S(loguru::Verbosity_ ## verbosity_name, cond)
1399 | 	#define DVLOG_S(verbosity)              DVLOG_IF_S(verbosity, true)
1400 | 	#define DLOG_S(verbosity_name)          DVLOG_S(loguru::Verbosity_ ## verbosity_name)
1401 | #endif
1402 | 
1403 | #if LOGURU_DEBUG_CHECKS
1404 | 	// Debug checks enabled:
1405 | 	#define DCHECK_S(cond)                  CHECK_S(cond)
1406 | 	#define DCHECK_NOTNULL_S(x)             CHECK_NOTNULL_S(x)
1407 | 	#define DCHECK_EQ_S(a, b)               CHECK_EQ_S(a, b)
1408 | 	#define DCHECK_NE_S(a, b)               CHECK_NE_S(a, b)
1409 | 	#define DCHECK_LT_S(a, b)               CHECK_LT_S(a, b)
1410 | 	#define DCHECK_LE_S(a, b)               CHECK_LE_S(a, b)
1411 | 	#define DCHECK_GT_S(a, b)               CHECK_GT_S(a, b)
1412 | 	#define DCHECK_GE_S(a, b)               CHECK_GE_S(a, b)
1413 | #else
1414 | // Debug checks disabled:
1415 | 	#define DCHECK_S(cond)                  CHECK_S(true || (cond))
1416 | 	#define DCHECK_NOTNULL_S(x)             CHECK_S(true || (x) != nullptr)
1417 | 	#define DCHECK_EQ_S(a, b)               CHECK_S(true || (a) == (b))
1418 | 	#define DCHECK_NE_S(a, b)               CHECK_S(true || (a) != (b))
1419 | 	#define DCHECK_LT_S(a, b)               CHECK_S(true || (a) <  (b))
1420 | 	#define DCHECK_LE_S(a, b)               CHECK_S(true || (a) <= (b))
1421 | 	#define DCHECK_GT_S(a, b)               CHECK_S(true || (a) >  (b))
1422 | 	#define DCHECK_GE_S(a, b)               CHECK_S(true || (a) >= (b))
1423 | #endif
1424 | 
1425 | #if LOGURU_REPLACE_GLOG
1426 | 	#undef LOG
1427 | 	#undef VLOG
1428 | 	#undef LOG_IF
1429 | 	#undef VLOG_IF
1430 | 	#undef CHECK
1431 | 	#undef CHECK_NOTNULL
1432 | 	#undef CHECK_EQ
1433 | 	#undef CHECK_NE
1434 | 	#undef CHECK_LT
1435 | 	#undef CHECK_LE
1436 | 	#undef CHECK_GT
1437 | 	#undef CHECK_GE
1438 | 	#undef DLOG
1439 | 	#undef DVLOG
1440 | 	#undef DLOG_IF
1441 | 	#undef DVLOG_IF
1442 | 	#undef DCHECK
1443 | 	#undef DCHECK_NOTNULL
1444 | 	#undef DCHECK_EQ
1445 | 	#undef DCHECK_NE
1446 | 	#undef DCHECK_LT
1447 | 	#undef DCHECK_LE
1448 | 	#undef DCHECK_GT
1449 | 	#undef DCHECK_GE
1450 | 	#undef VLOG_IS_ON
1451 | 
1452 | 	#define LOG            LOG_S
1453 | 	#define VLOG           VLOG_S
1454 | 	#define LOG_IF         LOG_IF_S
1455 | 	#define VLOG_IF        VLOG_IF_S
1456 | 	#define CHECK(cond)    CHECK_S(!!(cond))
1457 | 	#define CHECK_NOTNULL  CHECK_NOTNULL_S
1458 | 	#define CHECK_EQ       CHECK_EQ_S
1459 | 	#define CHECK_NE       CHECK_NE_S
1460 | 	#define CHECK_LT       CHECK_LT_S
1461 | 	#define CHECK_LE       CHECK_LE_S
1462 | 	#define CHECK_GT       CHECK_GT_S
1463 | 	#define CHECK_GE       CHECK_GE_S
1464 | 	#define DLOG           DLOG_S
1465 | 	#define DVLOG          DVLOG_S
1466 | 	#define DLOG_IF        DLOG_IF_S
1467 | 	#define DVLOG_IF       DVLOG_IF_S
1468 | 	#define DCHECK         DCHECK_S
1469 | 	#define DCHECK_NOTNULL DCHECK_NOTNULL_S
1470 | 	#define DCHECK_EQ      DCHECK_EQ_S
1471 | 	#define DCHECK_NE      DCHECK_NE_S
1472 | 	#define DCHECK_LT      DCHECK_LT_S
1473 | 	#define DCHECK_LE      DCHECK_LE_S
1474 | 	#define DCHECK_GT      DCHECK_GT_S
1475 | 	#define DCHECK_GE      DCHECK_GE_S
1476 | 	#define VLOG_IS_ON(verbosity) ((verbosity) <= loguru::current_verbosity_cutoff())
1477 | 
1478 | #endif // LOGURU_REPLACE_GLOG
1479 | 
1480 | #endif // LOGURU_WITH_STREAMS
1481 | 
1482 | #endif // LOGURU_HAS_DECLARED_STREAMS_HEADER
1483 | 


--------------------------------------------------------------------------------