astyle

3afabcd1 · gabime · d2a367fa · 3afabcd1 · 3afabcd1 · 3afabcd1
Commit 3afabcd1 authored Sep 02, 2016 by gabime
5 changed files
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -25,7 +25,7 @@ int main(int, char*[])
        auto console = spd::stdout_logger_mt("console", true);
        console->info("Welcome to spdlog!");
        console->error("An error message example {}..", 1);
        // Formatting examples
        console->warn("Easy padding in numbers like {:08d}", 12);
        console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -56,8 +56,8 @@ int main(int, char*[])
        // Create a daily logger - a new file is created every day on 2:30am
        auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
-		// trigger flush if the log severity is error or higher
+        // trigger flush if the log severity is error or higher
-		daily_logger->flush_on(spd::level::err);
+        daily_logger->flush_on(spd::level::err);
        daily_logger->info(123.44);
        // Customize msg format for all messages
@@ -104,7 +104,7 @@ void async_example()
    size_t q_size = 4096; //queue size must be power of 2
    spdlog::set_async_mode(q_size);
    auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
    for (int i = 0; i < 100; ++i)
        async_file->info("Async message #{}", i);
 }

--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
 //
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 #pragma once
 // Async Logger implementation
 // Use an async_sink (queue per logger) to perform the logging in a worker thread
 #include <spdlog/details/async_log_helper.h>
 #include <spdlog/async_logger.h>
 #include <string>
 #include <functional>
 #include <chrono>
 #include <memory>
 template<class It>
 inline spdlog::async_logger::async_logger(const std::string& logger_name,
        const It& begin,
        const It& end,
        size_t queue_size,
        const  async_overflow_policy overflow_policy,
        const std::function<void()>& worker_warmup_cb,
        const std::chrono::milliseconds& flush_interval_ms,
        const std::function<void()>& worker_teardown_cb) :
    logger(logger_name, begin, end),
    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
 {
 }
 inline spdlog::async_logger::async_logger(const std::string& logger_name,
        sinks_init_list sinks,
        size_t queue_size,
        const  async_overflow_policy overflow_policy,
        const std::function<void()>& worker_warmup_cb,
        const std::chrono::milliseconds& flush_interval_ms,
        const std::function<void()>& worker_teardown_cb) :
    async_logger(logger_name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
 inline spdlog::async_logger::async_logger(const std::string& logger_name,
        sink_ptr single_sink,
        size_t queue_size,
        const  async_overflow_policy overflow_policy,
        const std::function<void()>& worker_warmup_cb,
        const std::chrono::milliseconds& flush_interval_ms,
        const std::function<void()>& worker_teardown_cb) :
    async_logger(logger_name,
 {
    single_sink
 }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
 inline void spdlog::async_logger::flush()
 {
    _async_log_helper->flush();
 }
 inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
 {
    _formatter = msg_formatter;
    _async_log_helper->set_formatter(_formatter);
 }
 inline void spdlog::async_logger::_set_pattern(const std::string& pattern)
 {
    _formatter = std::make_shared<pattern_formatter>(pattern);
    _async_log_helper->set_formatter(_formatter);
 }
 inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
 {
    try
    {
        _async_log_helper->log(msg);
-		if (_should_flush_on(msg))
+        if (_should_flush_on(msg))
-			flush();
+            flush();
    }
    catch (const std::exception &ex)
    {
        _err_handler(ex.what());
    }
    catch (...)
    {
        _err_handler("Unknown exception");
    }
 }
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
 //
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 #pragma once
 #include <spdlog/logger.h>
 #include <spdlog/sinks/stdout_sinks.h>
 #include <memory>
 #include <string>
 // create logger with given name, sinks and the default pattern formatter
 // all other ctors will call this one
 template<class It>
 inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
    _name(logger_name),
    _sinks(begin, end),
    _formatter(std::make_shared<pattern_formatter>("%+"))
 {
    _level = level::info;
    _flush_level = level::off;
    _last_err_time = 0;
    _err_handler = [this](const std::string &msg)
    {
        this->_default_err_handler(msg);
    };
 }
 // ctor with sinks as init list
 inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
    logger(logger_name, sinks_list.begin(), sinks_list.end())
 {}
 // ctor with single sink
 inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
    logger(logger_name,
 {
    single_sink
 })
 {}
 inline spdlog::logger::~logger() = default;
 inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
 {
    _set_formatter(msg_formatter);
 }
 inline void spdlog::logger::set_pattern(const std::string& pattern)
 {
    _set_pattern(pattern);
 }
 template <typename... Args>
 inline void spdlog::logger::log(level::level_enum lvl, const char* fmt, const Args&... args)
 {
    if (!should_log(lvl)) return;
    try
    {
        details::log_msg log_msg(&_name, lvl);
        log_msg.raw.write(fmt, args...);
        _sink_it(log_msg);
    }
    catch (const std::exception &ex)
    {
        _err_handler(ex.what());
    }
    catch (...)
    {
        _err_handler("Unknown exception");
    }
 }
 template <typename... Args>
 inline void spdlog::logger::log(level::level_enum lvl, const char* msg)
 {
    if (!should_log(lvl)) return;
    try
    {
        details::log_msg log_msg(&_name, lvl);
        log_msg.raw << msg;
        _sink_it(log_msg);
    }
    catch (const std::exception &ex)
    {
        _err_handler(ex.what());
    }
    catch (...)
    {
        _err_handler("Unknown exception");
    }
 }
 template<typename T>
 inline void spdlog::logger::log(level::level_enum lvl, const T& msg)
 {
    if (!should_log(lvl)) return;
    try
    {
        details::log_msg log_msg(&_name, lvl);
        log_msg.raw << msg;
        _sink_it(log_msg);
    }
    catch (const std::exception &ex)
    {
        _err_handler(ex.what());
    }
    catch (...)
    {
        _err_handler("Unknown exception");
    }
 }
 template <typename... Args>
 inline void spdlog::logger::trace(const char* fmt, const Args&... args)
 {
    log(level::trace, fmt, args...);
 }
 template <typename... Args>
 inline void spdlog::logger::debug(const char* fmt, const Args&... args)
 {
    log(level::debug, fmt, args...);
 }
 template <typename... Args>
 inline void spdlog::logger::info(const char* fmt, const Args&... args)
 {
    log(level::info, fmt, args...);
 }
 template <typename... Args>
 inline void spdlog::logger::warn(const char* fmt, const Args&... args)
 {
    log(level::warn, fmt, args...);
 }
 template <typename... Args>
 inline void spdlog::logger::error(const char* fmt, const Args&... args)
 {
    log(level::err, fmt, args...);
 }
 template <typename... Args>
 inline void spdlog::logger::critical(const char* fmt, const Args&... args)
 {
    log(level::critical, fmt, args...);
 }
 template<typename T>
 inline void spdlog::logger::trace(const T& msg)
 {
    log(level::trace, msg);
 }
 template<typename T>
 inline void spdlog::logger::debug(const T& msg)
 {
    log(level::debug, msg);
 }
 template<typename T>
 inline void spdlog::logger::info(const T& msg)
 {
    log(level::info, msg);
 }
 template<typename T>
 inline void spdlog::logger::warn(const T& msg)
 {
    log(level::warn, msg);
 }
 template<typename T>
 inline void spdlog::logger::error(const T& msg)
 {
    log(level::err, msg);
 }
 template<typename T>
 inline void spdlog::logger::critical(const T& msg)
 {
    log(level::critical, msg);
 }
 //
 // name and level
 //
 inline const std::string& spdlog::logger::name() const
 {
    return _name;
 }
 inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
 {
    _level.store(log_level);
 }
 inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
 {
    _err_handler = err_handler;
 }
 inline spdlog::log_err_handler spdlog::logger::error_handler()
 {
    return _err_handler;
 }
 inline void spdlog::logger::flush_on(level::level_enum log_level)
 {
    _flush_level.store(log_level);
 }
 inline spdlog::level::level_enum spdlog::logger::level() const
 {
    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
 }
 inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
 {
    return msg_level >= _level.load(std::memory_order_relaxed);
 }
 //
 // protected virtual called at end of each user log call (if enabled) by the line_logger
 //
 inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
    _formatter->format(msg);
    for (auto &sink : _sinks)
        sink->log(msg);
    if(_should_flush_on(msg))
        flush();
 }
 inline void spdlog::logger::_set_pattern(const std::string& pattern)
 {
    _formatter = std::make_shared<pattern_formatter>(pattern);
 }
 inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
 {
    _formatter = msg_formatter;
 }
 inline void spdlog::logger::flush()
 {
    for (auto& sink : _sinks)
        sink->flush();
 }
 inline void spdlog::logger::_default_err_handler(const std::string &msg)
 {
    auto now = time(nullptr);
    if (now - _last_err_time < 60)
        return;
    auto tm_time = details::os::localtime(now);
    char date_buf[100];
    std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
    details::log_msg  err_msg;
    err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol);
    sinks::stderr_sink_mt::instance()->log(err_msg);
    _last_err_time = now;
 }
 inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg)
 {
-	const auto flush_level = _flush_level.load(std::memory_order_relaxed);
+    const auto flush_level = _flush_level.load(std::memory_order_relaxed);
-	return (msg.level >= flush_level) && (msg.level != level::off);
+    return (msg.level >= flush_level) && (msg.level != level::off);
 }
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
 //
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 #pragma once
 // Thread safe logger
 // Has name, log level, vector of std::shared sink pointers and formatter
 // Upon each log write the logger:
 // 1. Checks if its log level is enough to log the message
 // 2. Format the message using the formatter function
 // 3. Pass the formatted message to its sinks to performa the actual logging
 #include <spdlog/sinks/base_sink.h>
 #include <spdlog/common.h>
 #include <vector>
 #include <memory>
 #include <string>
 namespace spdlog
 {
 class logger
 {
 public:
    logger(const std::string& logger_name, sink_ptr single_sink);
    logger(const std::string& name, sinks_init_list);
    template<class It>
    logger(const std::string& name, const It& begin, const It& end);
    virtual ~logger();
    logger(const logger&) = delete;
    logger& operator=(const logger&) = delete;
    template <typename... Args> void log(level::level_enum lvl, const char* fmt, const Args&... args);
    template <typename... Args> void log(level::level_enum lvl, const char* msg);
    template <typename... Args> void trace(const char* fmt, const Args&... args);
    template <typename... Args> void debug(const char* fmt, const Args&... args);
    template <typename... Args> void info(const char* fmt, const Args&... args);
    template <typename... Args> void warn(const char* fmt, const Args&... args);
    template <typename... Args> void error(const char* fmt, const Args&... args);
    template <typename... Args> void critical(const char* fmt, const Args&... args);
    template <typename T> void log(level::level_enum lvl, const T&);
    template <typename T> void trace(const T&);
    template <typename T> void debug(const T&);
    template <typename T> void info(const T&);
    template <typename T> void warn(const T&);
    template <typename T> void error(const T&);
    template <typename T> void critical(const T&);
    bool should_log(level::level_enum) const;
    void set_level(level::level_enum);
    level::level_enum level() const;
    const std::string& name() const;
    void set_pattern(const std::string&);
    void set_formatter(formatter_ptr);
    // error handler
    void set_error_handler(log_err_handler);
    log_err_handler error_handler();
    // automatically call flush() if message level >= log_level
    void flush_on(level::level_enum log_level);
    virtual void flush();
 protected:
    virtual void _sink_it(details::log_msg&);
    virtual void _set_pattern(const std::string&);
    virtual void _set_formatter(formatter_ptr);
    // default error handler: print the error to stderr with the max rate of 1 message/minute
    virtual void _default_err_handler(const std::string &msg);
-	// return true if the given message level should trigger a flush
+    // return true if the given message level should trigger a flush
-	bool _should_flush_on(const details::log_msg&);
+    bool _should_flush_on(const details::log_msg&);
    const std::string _name;
    std::vector<sink_ptr> _sinks;
    formatter_ptr _formatter;
    spdlog::level_t _level;
    spdlog::level_t _flush_level;
    log_err_handler _err_handler;
    std::atomic<time_t> _last_err_time;
 };
 }
 #include <spdlog/details/logger_impl.h>
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -26,7 +26,7 @@ TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
    prepare_logdir();
    std::string basename = "logs/rotating_log";
    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0);
-	logger->flush_on(spdlog::level::info);
+    logger->flush_on(spdlog::level::info);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);
@@ -70,7 +70,7 @@ TEST_CASE("daily_logger", "[daily_logger]]")
    w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.txt", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);
    auto logger = spdlog::daily_logger_mt("logger", basename, 0, 0);
-	logger->flush_on(spdlog::level::info);
+    logger->flush_on(spdlog::level::info);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);