TeaSpeak/spdlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Moved lite source to folders|

Browse Source
This commit is contained in:
gabime 2019-03-30 16:49:02 +03:00
parent c2b0e223fa
commit f36be4d5e4
11 changed files with 412 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

333
CMakeLists.txt
View File

@ -1,167 +1,166 @@
# #
# Copyright(c) 2015 Ruslan Baratov. # Copyright(c) 2015 Ruslan Baratov.
# Distributed under the MIT License (http://opensource.org/licenses/MIT) # Distributed under the MIT License (http://opensource.org/licenses/MIT)
# #
cmake_minimum_required(VERSION 3.1) cmake_minimum_required(VERSION 3.1)
project(spdlog VERSION 1.3.1 LANGUAGES CXX) project(spdlog VERSION 1.3.1 LANGUAGES CXX)
include(CMakeDependentOption) include(CMakeDependentOption)
include(GNUInstallDirs) include(GNUInstallDirs)
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
# set default build to release # set default build to release
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
if(NOT CMAKE_BUILD_TYPE) if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
endif() endif()
message(STATUS "Build type: " ${CMAKE_BUILD_TYPE}) message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
# compiler config # compiler config
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_EXTENSIONS OFF)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
add_compile_options("-Wall") add_compile_options("-Wall")
add_compile_options("-Wextra") add_compile_options("-Wextra")
add_compile_options("-Wconversion") add_compile_options("-Wconversion")
add_compile_options("-pedantic") add_compile_options("-pedantic")
add_compile_options("-Wfatal-errors") add_compile_options("-Wfatal-errors")
endif() endif()
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
# address sanitizers check # address sanitizers check
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
include(cmake/sanitizers.cmake) include(cmake/sanitizers.cmake)
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
# spdlog target # spdlog target
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
add_library(spdlog INTERFACE) add_library(spdlog INTERFACE)
add_library(spdlog::spdlog ALIAS spdlog) add_library(spdlog::spdlog ALIAS spdlog)
# Check if spdlog is being used directly or via add_subdirectory # Check if spdlog is being used directly or via add_subdirectory
set(SPDLOG_MASTER_PROJECT OFF) set(SPDLOG_MASTER_PROJECT OFF)
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
set(SPDLOG_MASTER_PROJECT ON) set(SPDLOG_MASTER_PROJECT ON)
endif() endif()
option(SPDLOG_BUILD_EXAMPLES "Build examples" ${SPDLOG_MASTER_PROJECT}) option(SPDLOG_BUILD_EXAMPLES "Build examples" ${SPDLOG_MASTER_PROJECT})
option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF) option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
option(SPDLOG_BUILD_TESTS "Build tests" ${SPDLOG_MASTER_PROJECT}) option(SPDLOG_BUILD_TESTS "Build tests" ${SPDLOG_MASTER_PROJECT})
option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF) option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
option(SPDLOG_INSTALL "Generate the install target." ${SPDLOG_MASTER_PROJECT}) option(SPDLOG_INSTALL "Generate the install target." ${SPDLOG_MASTER_PROJECT})
option(SPDLOG_BUILD_LITE "Build spdlog lite" ${SPDLOG_MASTER_PROJECT}) option(SPDLOG_BUILD_LITE "Build spdlog lite" ${SPDLOG_MASTER_PROJECT})
if(SPDLOG_FMT_EXTERNAL AND NOT TARGET fmt::fmt) if(SPDLOG_FMT_EXTERNAL AND NOT TARGET fmt::fmt)
find_package(fmt REQUIRED CONFIG) find_package(fmt REQUIRED CONFIG)
endif() endif()
target_include_directories( target_include_directories(
spdlog spdlog
INTERFACE INTERFACE
"$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>" "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>" "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
) )
if(SPDLOG_FMT_EXTERNAL) if(SPDLOG_FMT_EXTERNAL)
target_compile_definitions(spdlog INTERFACE SPDLOG_FMT_EXTERNAL) target_compile_definitions(spdlog INTERFACE SPDLOG_FMT_EXTERNAL)
target_link_libraries(spdlog INTERFACE fmt::fmt) target_link_libraries(spdlog INTERFACE fmt::fmt)
endif() endif()
set(HEADER_BASE "${CMAKE_CURRENT_SOURCE_DIR}/include") set(HEADER_BASE "${CMAKE_CURRENT_SOURCE_DIR}/include")
if(SPDLOG_BUILD_EXAMPLES) if(SPDLOG_BUILD_EXAMPLES)
add_subdirectory(example) add_subdirectory(example)
endif() endif()
if(SPDLOG_BUILD_TESTS) if(SPDLOG_BUILD_TESTS)
include(CTest) include(CTest)
add_subdirectory(tests) add_subdirectory(tests)
endif() endif()
if(SPDLOG_BUILD_BENCH) if(SPDLOG_BUILD_BENCH)
add_subdirectory(bench) add_subdirectory(bench)
endif() endif()
if(SPDLOG_BUILD_LITE) if(SPDLOG_BUILD_LITE)
add_subdirectory(lite) add_subdirectory(spdlite)
add_subdirectory(lite-example) endif()
endif()
#---------------------------------------------------------------------------------------
#--------------------------------------------------------------------------------------- # Install/export targets and files
# Install/export targets and files #---------------------------------------------------------------------------------------
#--------------------------------------------------------------------------------------- if(SPDLOG_INSTALL)
if(SPDLOG_INSTALL) # set files and directories
# set files and directories set(config_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
set(config_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") set(include_install_dir "${CMAKE_INSTALL_INCLUDEDIR}")
set(include_install_dir "${CMAKE_INSTALL_INCLUDEDIR}") set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig") set(version_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
set(version_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake") set(project_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake")
set(project_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake") set(targets_config "${PROJECT_NAME}Targets.cmake")
set(targets_config "${PROJECT_NAME}Targets.cmake") set(pkg_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc")
set(pkg_config "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc") set(targets_export_name "${PROJECT_NAME}Targets")
set(targets_export_name "${PROJECT_NAME}Targets") set(namespace "${PROJECT_NAME}::")
set(namespace "${PROJECT_NAME}::")
# generate package version file
# generate package version file include(CMakePackageConfigHelpers)
include(CMakePackageConfigHelpers) write_basic_package_version_file(
write_basic_package_version_file( "${version_config}" COMPATIBILITY SameMajorVersion
"${version_config}" COMPATIBILITY SameMajorVersion )
)
# configure pkg config file
# configure pkg config file configure_file("cmake/spdlog.pc.in" "${pkg_config}" @ONLY)
configure_file("cmake/spdlog.pc.in" "${pkg_config}" @ONLY) # configure spdlogConfig.cmake file
# configure spdlogConfig.cmake file configure_file("cmake/Config.cmake.in" "${project_config}" @ONLY)
configure_file("cmake/Config.cmake.in" "${project_config}" @ONLY)
# install targets
# install targets install(
install( TARGETS spdlog
TARGETS spdlog EXPORT "${targets_export_name}"
EXPORT "${targets_export_name}" )
)
# install headers
# install headers install(
install( DIRECTORY "${HEADER_BASE}/${PROJECT_NAME}"
DIRECTORY "${HEADER_BASE}/${PROJECT_NAME}" DESTINATION "${include_install_dir}"
DESTINATION "${include_install_dir}" )
)
# install project config and version file
# install project config and version file install(
install( FILES "${project_config}" "${version_config}"
FILES "${project_config}" "${version_config}" DESTINATION "${config_install_dir}"
DESTINATION "${config_install_dir}" )
)
# install pkg config file
# install pkg config file install(
install( FILES "${pkg_config}"
FILES "${pkg_config}" DESTINATION "${pkgconfig_install_dir}"
DESTINATION "${pkgconfig_install_dir}" )
)
# install targets config file
# install targets config file install(
install( EXPORT "${targets_export_name}"
EXPORT "${targets_export_name}" NAMESPACE "${namespace}"
NAMESPACE "${namespace}" DESTINATION "${config_install_dir}"
DESTINATION "${config_install_dir}" FILE ${targets_config}
FILE ${targets_config} )
)
# export build directory targets file
# export build directory targets file export(
export( EXPORT ${targets_export_name}
EXPORT ${targets_export_name} NAMESPACE "${namespace}"
NAMESPACE "${namespace}" FILE ${targets_config}
FILE ${targets_config} )
)
# register project in CMake user registry
# register project in CMake user registry export(PACKAGE ${PROJECT_NAME})
export(PACKAGE ${PROJECT_NAME})
endif()
endif()
file(GLOB_RECURSE spdlog_include_SRCS "${HEADER_BASE}/*.h")
file(GLOB_RECURSE spdlog_include_SRCS "${HEADER_BASE}/*.h") add_custom_target(spdlog_headers_for_ide SOURCES ${spdlog_include_SRCS})
add_custom_target(spdlog_headers_for_ide SOURCES ${spdlog_include_SRCS})

6
lite/CMakeLists.txt
View File

@ -1,6 +0,0 @@
cmake_minimum_required(VERSION 3.1)
project(spdlog_lite)
add_library(spdlog_lite spdlite.cpp spdlite.h spdlite_global.cpp spdlite_global.h spdlite_macros.h)
target_link_libraries(spdlog_lite spdlog::spdlog)

14
spdlite/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 3.1)
project(spdlite)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_FILES ${PROJECT_SOURCE_DIR}/src/*.cpp)
file(GLOB HEADER_FILES ${PROJECT_SOURCE_DIR}/include/*.h)
add_library(spdlite ${SRC_FILES} ${HEADER_FILES})
target_link_libraries(spdlite spdlog::spdlog)
add_subdirectory(example)

8
lite-example/CMakeLists.txt → spdlite/example/CMakeLists.txt
View File

@ -1,13 +1,11 @@
project(spdlog-lite-example CXX) project(spdlite-example CXX)
find_package(Threads REQUIRED)
set(LITE_SOURCES example.cpp create_logger.cpp) set(LITE_SOURCES example.cpp create_logger.cpp)
add_executable(${PROJECT_NAME} ${LITE_SOURCES}) add_executable(${PROJECT_NAME} ${LITE_SOURCES})
include_directories(../lite) find_package(Threads)
target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads) target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
target_link_libraries(${PROJECT_NAME} PRIVATE spdlog_lite) target_link_libraries(${PROJECT_NAME} PRIVATE spdlite)

2
lite-example/create_logger.cpp → spdlite/example/create_logger.cpp
View File

@ -1,7 +1,7 @@
// Copyright(c) 2015-present Gabi Melman. // Copyright(c) 2015-present Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
#include "spdlite.h" #include "spdlite/spdlite.h"
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#include "spdlog/sinks/basic_file_sink.h" #include "spdlog/sinks/basic_file_sink.h"

22
lite-example/example.cpp → spdlite/example/example.cpp
View File

@ -1,12 +1,12 @@
// Copyright(c) 2015-present Gabi Melman. // Copyright(c) 2015-present Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
#include "spdlite.h" #include "spdlite/spdlite.h"
#include "spdlite_global.h" #include "spdlite/spdlite_global.h"
#define SPDLITE_ACTIVE_LEVEL SPDLITE_LEVEL_TRACE #define SPDLITE_ACTIVE_LEVEL SPDLITE_LEVEL_TRACE
#include "spdlite_macros.h" #include "spdlite/spdlite_macros.h"
int main() int main()
{ {
SPDLITE_TRACE("SOME INFO {}", 123); SPDLITE_TRACE("SOME INFO {}", 123);
} }

0
lite/spdlite.h → spdlite/include/spdlite/spdlite.h
View File

0
lite/spdlite_global.h → spdlite/include/spdlite/spdlite_global.h
View File

0
lite/spdlite_macros.h → spdlite/include/spdlite/spdlite_macros.h
View File

310
lite/spdlite.cpp → spdlite/src/spdlite.cpp
View File

@ -1,155 +1,155 @@
// //
// Copyright(c) 2019-present spdlog // Copyright(c) 2019-present spdlog
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
// //
#include "spdlite.h" #include "spdlite/spdlite.h"
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
static spdlog::level::level_enum to_spdlog_level(spdlite::level level) static spdlog::level::level_enum to_spdlog_level(spdlite::level level)
{ {
return static_cast<spdlog::level::level_enum>(level); return static_cast<spdlog::level::level_enum>(level);
} }
static spdlite::level to_lite_level(spdlog::level::level_enum level) static spdlite::level to_lite_level(spdlog::level::level_enum level)
{ {
return static_cast<spdlite::level>(level); return static_cast<spdlite::level>(level);
} }
spdlite::logger::logger(std::shared_ptr<spdlog::logger> impl) spdlite::logger::logger(std::shared_ptr<spdlog::logger> impl)
{ {
impl_ = std::move(impl); impl_ = std::move(impl);
} }
void spdlite::logger::set_impl(std::shared_ptr<spdlog::logger> impl) void spdlite::logger::set_impl(std::shared_ptr<spdlog::logger> impl)
{ {
impl_ = std::move(impl); impl_ = std::move(impl);
} }
bool spdlite::logger::should_log(spdlite::level level) const SPDLOG_NOEXCEPT bool spdlite::logger::should_log(spdlite::level level) const SPDLOG_NOEXCEPT
{ {
auto spd_level = to_spdlog_level(level); auto spd_level = to_spdlog_level(level);
return impl_->should_log(spd_level); // TODO avoid the call using local level member? return impl_->should_log(spd_level); // TODO avoid the call using local level member?
} }
void spdlite::logger::log(spdlite::level lvl, const string_view_t &sv) void spdlite::logger::log(spdlite::level lvl, const string_view_t &sv)
{ {
auto spd_level = to_spdlog_level(lvl); auto spd_level = to_spdlog_level(lvl);
impl_->log(spd_level, sv); impl_->log(spd_level, sv);
} }
void spdlite::logger::log_printf(spdlite::level lvl, const char *format, va_list args) void spdlite::logger::log_printf(spdlite::level lvl, const char *format, va_list args)
{ {
char buffer[256]; char buffer[256];
auto size = vsnprintf(buffer, sizeof(buffer), format, args); auto size = vsnprintf(buffer, sizeof(buffer), format, args);
if (size < 0) if (size < 0)
{ {
size = snprintf(buffer, sizeof(buffer), "invalid format (%s)", format); size = snprintf(buffer, sizeof(buffer), "invalid format (%s)", format);
} }
log(lvl, string_view_t{buffer, static_cast<size_t>(size)}); log(lvl, string_view_t{buffer, static_cast<size_t>(size)});
} }
void spdlite::logger::trace_printf(const char *format, ...) void spdlite::logger::trace_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::trace, format, args); log_printf(spdlite::level::trace, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::debug_printf(const char *format, ...) void spdlite::logger::debug_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::debug, format, args); log_printf(spdlite::level::debug, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::info_printf(const char *format, ...) void spdlite::logger::info_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::info, format, args); log_printf(spdlite::level::info, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::warn_printf(const char *format, ...) void spdlite::logger::warn_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::warn, format, args); log_printf(spdlite::level::warn, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::error_printf(const char *format, ...) void spdlite::logger::error_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::err, format, args); log_printf(spdlite::level::err, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::critical_printf(const char *format, ...) void spdlite::logger::critical_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(spdlite::level::critical, format, args); log_printf(spdlite::level::critical, format, args);
va_end(args); va_end(args);
} }
void spdlite::logger::set_level(spdlite::level level) noexcept void spdlite::logger::set_level(spdlite::level level) noexcept
{ {
auto spd_level = to_spdlog_level(level); auto spd_level = to_spdlog_level(level);
impl_->set_level(spd_level); impl_->set_level(spd_level);
} }
spdlite::level spdlite::logger::level() const noexcept spdlite::level spdlite::logger::level() const noexcept
{ {
return to_lite_level(impl_->level()); return to_lite_level(impl_->level());
} }
std::string spdlite::logger::name() const noexcept std::string spdlite::logger::name() const noexcept
{ {
return impl_->name(); return impl_->name();
} }
void spdlite::logger::flush() void spdlite::logger::flush()
{ {
impl_->flush(); impl_->flush();
} }
void spdlite::logger::flush_on(spdlite::level level) void spdlite::logger::flush_on(spdlite::level level)
{ {
auto spd_level = to_spdlog_level(level); auto spd_level = to_spdlog_level(level);
impl_->flush_on(spd_level); impl_->flush_on(spd_level);
} }
spdlite::level spdlite::logger::flush_level() const noexcept spdlite::level spdlite::logger::flush_level() const noexcept
{ {
return to_lite_level(impl_->flush_level()); return to_lite_level(impl_->flush_level());
} }
// pattern // pattern
void spdlite::logger::set_pattern(std::string pattern) noexcept void spdlite::logger::set_pattern(std::string pattern) noexcept
{ {
impl_->set_pattern(std::move(pattern)); impl_->set_pattern(std::move(pattern));
} }
spdlite::logger spdlite::logger::clone(std::string logger_name) spdlite::logger spdlite::logger::clone(std::string logger_name)
{ {
return spdlite::logger(impl_->clone(std::move(logger_name))); return spdlite::logger(impl_->clone(std::move(logger_name)));
} }
void spdlite::logger::log_formatted_(spdlite::level lvl, const fmt::memory_buffer &formatted) void spdlite::logger::log_formatted_(spdlite::level lvl, const fmt::memory_buffer &formatted)
{ {
auto spd_level = to_spdlog_level(lvl); auto spd_level = to_spdlog_level(lvl);
impl_->log(spd_level, spdlog::details::fmt_helper::to_string_view(formatted)); impl_->log(spd_level, spdlog::details::fmt_helper::to_string_view(formatted));
} }
spdlite::logger &spdlite::logger::default_logger() spdlite::logger &spdlite::logger::default_logger()
{ {
static spdlite::logger default_inst_ = spdlite::logger(spdlog::default_logger()); static spdlite::logger default_inst_ = spdlite::logger(spdlog::default_logger());
return default_inst_; return default_inst_;
} }

124
lite/spdlite_global.cpp → spdlite/src/spdlite_global.cpp
View File

@ -1,63 +1,63 @@
// Copyright(c) 2015-present Gabi Melman. // Copyright(c) 2015-present Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // Distributed under the MIT License (http://opensource.org/licenses/MIT)
#include "spdlite_global.h" #include "spdlite/spdlite_global.h"
spdlite::logger &spdlite::default_logger() spdlite::logger &spdlite::default_logger()
{ {
return spdlite::logger::default_logger(); return spdlite::logger::default_logger();
} }
// printf // printf
void spdlite::log_printf(spdlite::level lvl, const char *format, va_list args) void spdlite::log_printf(spdlite::level lvl, const char *format, va_list args)
{ {
default_logger().log_printf(lvl, format, args); default_logger().log_printf(lvl, format, args);
} }
void spdlite::trace_printf(const char *format, ...) void spdlite::trace_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::trace, format, args); log_printf(level::trace, format, args);
va_end(args); va_end(args);
} }
void spdlite::debug_printf(const char *format, ...) void spdlite::debug_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::debug, format, args); log_printf(level::debug, format, args);
va_end(args); va_end(args);
} }
void spdlite::info_printf(const char *format, ...) void spdlite::info_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::info, format, args); log_printf(level::info, format, args);
va_end(args); va_end(args);
} }
void spdlite::warn_printf(const char *format, ...) void spdlite::warn_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::warn, format, args); log_printf(level::warn, format, args);
va_end(args); va_end(args);
} }
void spdlite::error_printf(const char *format, ...) void spdlite::error_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::err, format, args); log_printf(level::err, format, args);
va_end(args); va_end(args);
} }
void spdlite::critical_printf(const char *format, ...) void spdlite::critical_printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_printf(level::critical, format, args); log_printf(level::critical, format, args);
va_end(args); va_end(args);
} }