mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-12-25 18:11:33 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
gabime 2019-03-23 16:39:32 +02:00
parent c29b7d22d9
commit 1d72edcc4f
8 changed files with 183 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/spdlog/common.h
View File

@ -128,7 +128,10 @@ enum level_enum
static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
#if !defined(SPDLOG_SHORT_LEVEL_NAMES)
#define SPDLOG_SHORT_LEVEL_NAMES {"T", "D", "I", "W", "E", "C", "O"}
#define SPDLOG_SHORT_LEVEL_NAMES \
{ \
"T", "D", "I", "W", "E", "C", "O" \
}
#endif
static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES;

4
include/spdlog/sinks/rotating_file_sink.h
View File

@ -31,7 +31,7 @@ template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex>
{
public:
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open=false)
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false)
: base_filename_(std::move(base_filename))
, max_size_(max_size)
, max_files_(max_files)
@ -150,7 +150,7 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
template<typename Factory = default_factory>
inline std::shared_ptr<logger> rotating_logger_mt(
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open=false)
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false)
{
return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files, rotate_on_open);
}

48
include/spdlog/sinks/systemd_sink.h
View File

@ -18,22 +18,24 @@
namespace spdlog {
namespace sinks {
inline int syslog_level(level::level_enum l) {
switch(l) {
case level::off:
case level::trace:
case level::debug:
return LOG_DEBUG;
case level::info:
return LOG_INFO;
case level::warn:
return LOG_WARNING;
case level::err:
return LOG_ERR;
case level::critical:
return LOG_CRIT;
default:
throw std::invalid_argument("systemd_sink.h syslog_level()");
inline int syslog_level(level::level_enum l)
{
switch (l)
{
case level::off:
case level::trace:
case level::debug:
return LOG_DEBUG;
case level::info:
return LOG_INFO;
case level::warn:
return LOG_WARNING;
case level::err:
return LOG_ERR;
case level::critical:
return LOG_CRIT;
default:
throw std::invalid_argument("systemd_sink.h syslog_level()");
}
}
@ -57,13 +59,7 @@ public:
protected:
void sink_it_(const details::log_msg &msg) override
{
if( sd_journal_print(
syslog_level(msg.level),
"%.*s",
static_cast<int>(msg.payload.size()),
msg.payload.data()
)
)
if (sd_journal_print(syslog_level(msg.level), "%.*s", static_cast<int>(msg.payload.size()), msg.payload.data()))
throw spdlog_ex("Failed writing to systemd");
}
@ -76,15 +72,13 @@ using systemd_sink_st = systemd_sink<details::null_mutex>;
// Create and register a syslog logger
template<typename Factory = default_factory>
inline std::shared_ptr<logger> systemd_logger_mt(
const std::string &logger_name)
inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name)
{
return Factory::template create<sinks::systemd_sink_mt>(logger_name);
}
template<typename Factory = default_factory>
inline std::shared_ptr<logger> systemd_logger_st(
const std::string &logger_name)
inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name)
{
return Factory::template create<sinks::systemd_sink_st>(logger_name);
}

8
lite-example/create_lite.cpp
View File

@ -1,15 +1,13 @@
#include "logger.h"
#include "spdlog/spdlog.h"
spdlog::lite::logger spdlog::create_lite(void* ctx)
spdlog::lite::logger spdlog::create_lite(void *ctx)
{
if(ctx) {
if (ctx)
{
//..
}
auto logger_impl = spdlog::default_logger();
logger_impl->set_level(spdlog::level::trace);
return spdlog::lite::logger(logger_impl);
}

5
lite-example/example.cpp
View File

@ -3,9 +3,8 @@
int main()
{
//auto l = spdlog::create_lite();
//spdlog::lite::info("HELLO info {}", 123);
// auto l = spdlog::create_lite();
// spdlog::lite::info("HELLO info {}", 123);
SPDLITE_TRACE("SOME MACRO {}", 123);
SPDLITE_INFO("SOME MACRO {}", "HHHHH");
}

8
lite/logger.cpp
View File

@ -2,9 +2,9 @@
#include "spdlog/spdlog.h"
#include "spdlog/logger.h"
static spdlog::level::level_enum to_spdlog_level(spdlog::lite::level level)
static spdlog::level::level_enum to_spdlog_level(spdlog::lite::level level)
{
return static_cast<spdlog::level::level_enum >(level);
return static_cast<spdlog::level::level_enum>(level);
}
static spdlog::lite::level to_lite_level(spdlog::level::level_enum level)
@ -20,7 +20,7 @@ spdlog::lite::logger::logger(std::shared_ptr<spdlog::logger> impl)
bool spdlog::lite::logger::should_log(spdlog::lite::level level) const SPDLOG_NOEXCEPT
{
auto spd_level = to_spdlog_level(level);
return impl_->should_log(spd_level);//TODO level
return impl_->should_log(spd_level); // TODO level
}
void spdlog::lite::logger::log_formatted_(spdlog::lite::level level, const fmt::memory_buffer &formatted)
@ -29,7 +29,6 @@ void spdlog::lite::logger::log_formatted_(spdlog::lite::level level, const fmt::
impl_->log(spd_level, spdlog::details::fmt_helper::to_string_view(formatted));
}
void spdlog::lite::logger::log_formatted_src(const spdlog::lite::src_loc &src, spdlog::lite::level lvl, const fmt::memory_buffer &formatted)
{
auto spd_level = to_spdlog_level(lvl);
@ -75,7 +74,6 @@ void spdlog::lite::logger::set_pattern(std::string pattern)
impl_->set_pattern(std::move(pattern));
}
spdlog::lite::logger &spdlog::lite::default_logger()
{
static spdlog::lite::logger s_default(spdlog::default_logger());

294
lite/logger.h
View File

@ -21,8 +21,8 @@
#define SPDLITE_LEVEL_CRITICAL 5
#define SPDLITE_LEVEL_OFF 6
#define SPDLITE_LOGGER_CALL(logger, level, ...) \
if (logger.should_log(level)) \
#define SPDLITE_LOGGER_CALL(logger, level, ...) \
if (logger.should_log(level)) \
logger.log(level, __VA_ARGS__)
#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_TRACE
@ -73,169 +73,169 @@
#define SPDLITE_CRITICAL(...) (void)0
#endif
namespace spdlog {
class logger;
class logger;
namespace lite {
enum class level{
trace = SPDLITE_LEVEL_TRACE,
debug =SPDLITE_LEVEL_DEBUG,
info = SPDLITE_LEVEL_INFO,
warn = SPDLITE_LEVEL_WARN,
err = SPDLITE_LEVEL_ERROR,
critical = SPDLITE_LEVEL_CRITICAL,
off = SPDLITE_LEVEL_OFF
};
namespace lite {
enum class level
{
trace = SPDLITE_LEVEL_TRACE,
debug = SPDLITE_LEVEL_DEBUG,
info = SPDLITE_LEVEL_INFO,
warn = SPDLITE_LEVEL_WARN,
err = SPDLITE_LEVEL_ERROR,
critical = SPDLITE_LEVEL_CRITICAL,
off = SPDLITE_LEVEL_OFF
};
struct src_loc {
const char *filename;
int line;
const char* funcname;
};
struct src_loc
{
const char *filename;
int line;
const char *funcname;
};
class logger {
public:
logger() = default;
class logger
{
public:
logger() = default;
logger(std::shared_ptr<spdlog::logger> impl);
logger(const logger&) = default;
logger(logger&&) = default;
logger& operator=(const logger&) = default;
logger(std::shared_ptr<spdlog::logger> impl);
logger(const logger &) = default;
logger(logger &&) = default;
logger &operator=(const logger &) = default;
~logger() = default;
~logger() = default;
bool should_log(spdlog::lite::level lvl) const noexcept;
bool should_log(spdlog::lite::level lvl) const noexcept;
template<typename... Args>
void log(spdlog::lite::level lvl, const char *fmt, const Args &... args) {
if (!should_log(lvl)) {
return;
}
fmt::memory_buffer formatted_buf;
fmt::format_to(formatted_buf, fmt, args...);
log_formatted_(lvl, formatted_buf);
}
template<typename... Args>
void log(const spdlog::lite::src_loc& src, spdlog::lite::level lvl, const char *fmt, const Args &... args) {
if (!should_log(lvl)) {
return;
}
fmt::memory_buffer formatted_buf;
fmt::format_to(formatted_buf, fmt, args...);
log_formatted_src(src, lvl, formatted_buf);
}
template<typename... Args>
void trace(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::trace, fmt, args...);
}
template<typename... Args>
void trace(const char* source_file, int source_line, const char* source_func, const char *fmt, const Args &... args)
{
spdlog::lite::src_loc src{source_file, source_line, source_func};
log(src, spdlog::lite::level::trace, fmt, args...);
}
template<typename... Args>
void debug(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::debug, fmt, args...);
}
template<typename... Args>
void info(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::info, fmt, args...);
}
template<typename... Args>
void warn(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::warn, fmt, args...);
}
template<typename... Args>
void error(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::err, fmt, args...);
}
template<typename... Args>
void critical(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::critical, fmt, args...);
}
std::string name() const;
// level
void set_level(lite::level level);
lite::level get_level() const;
// flush
void flush();
void flush_on(spdlog::lite::level log_level);
spdlog::lite::level flush_level() const;
// pattern
void set_pattern(std::string pattern);
protected:
std::shared_ptr<spdlog::logger> impl_;
void log_formatted_(spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
void log_formatted_src(const spdlog::lite::src_loc& src, spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
};
spdlog::lite::logger& default_logger();
template<typename... Args>
void trace(const char *fmt, const Args &... args)
template<typename... Args>
void log(spdlog::lite::level lvl, const char *fmt, const Args &... args)
{
if (!should_log(lvl))
{
default_logger().trace(fmt, args...);
return;
}
template<typename... Args>
void debug(const char *fmt, const Args &... args)
fmt::memory_buffer formatted_buf;
fmt::format_to(formatted_buf, fmt, args...);
log_formatted_(lvl, formatted_buf);
}
template<typename... Args>
void log(const spdlog::lite::src_loc &src, spdlog::lite::level lvl, const char *fmt, const Args &... args)
{
if (!should_log(lvl))
{
default_logger().debug(fmt, args...);
return;
}
fmt::memory_buffer formatted_buf;
fmt::format_to(formatted_buf, fmt, args...);
log_formatted_src(src, lvl, formatted_buf);
}
template<typename... Args>
void info(const char *fmt, const Args &... args)
{
default_logger().info(fmt, args...);
}
template<typename... Args>
void trace(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::trace, fmt, args...);
}
template<typename... Args>
void warn(const char *fmt, const Args &... args)
{
default_logger().warn(fmt, args...);
}
template<typename... Args>
void trace(const char *source_file, int source_line, const char *source_func, const char *fmt, const Args &... args)
{
spdlog::lite::src_loc src{source_file, source_line, source_func};
log(src, spdlog::lite::level::trace, fmt, args...);
}
template<typename... Args>
void error(const char *fmt, const Args &... args)
{
default_logger().error(fmt, args...);
}
template<typename... Args>
void debug(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::debug, fmt, args...);
}
template<typename... Args>
void critical(const char *fmt, const Args &... args)
{
default_logger().critical(fmt, args...);
}
template<typename... Args>
void info(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::info, fmt, args...);
}
template<typename... Args>
void warn(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::warn, fmt, args...);
}
} // namespace lite
template<typename... Args>
void error(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::err, fmt, args...);
}
// factory to create lite logger
// implement it in a dedicated compilation unit for fast compiles
spdlog::lite::logger create_lite(void* ctx = nullptr);
template<typename... Args>
void critical(const char *fmt, const Args &... args)
{
log(spdlog::lite::level::critical, fmt, args...);
}
std::string name() const;
// level
void set_level(lite::level level);
lite::level get_level() const;
// flush
void flush();
void flush_on(spdlog::lite::level log_level);
spdlog::lite::level flush_level() const;
// pattern
void set_pattern(std::string pattern);
protected:
std::shared_ptr<spdlog::logger> impl_;
void log_formatted_(spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
void log_formatted_src(const spdlog::lite::src_loc &src, spdlog::lite::level lvl, const fmt::memory_buffer &formatted);
};
spdlog::lite::logger &default_logger();
template<typename... Args>
void trace(const char *fmt, const Args &... args)
{
default_logger().trace(fmt, args...);
}
template<typename... Args>
void debug(const char *fmt, const Args &... args)
{
default_logger().debug(fmt, args...);
}
template<typename... Args>
void info(const char *fmt, const Args &... args)
{
default_logger().info(fmt, args...);
}
template<typename... Args>
void warn(const char *fmt, const Args &... args)
{
default_logger().warn(fmt, args...);
}
template<typename... Args>
void error(const char *fmt, const Args &... args)
{
default_logger().error(fmt, args...);
}
template<typename... Args>
void critical(const char *fmt, const Args &... args)
{
default_logger().critical(fmt, args...);
}
} // namespace lite
// factory to create lite logger
// implement it in a dedicated compilation unit for fast compiles
spdlog::lite::logger create_lite(void *ctx = nullptr);
} // namespace spdlog

2
tests/test_file_logging.cpp
View File

@ -69,7 +69,7 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
logger->info("Test message {}", i);
}
// drop causes the logger destructor to be called, which is required so the
// next logger can rename the first output file.
// next logger can rename the first output file.
spdlog::drop(logger->name());
}