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; static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
#if !defined(SPDLOG_SHORT_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 #endif
static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; 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> class rotating_file_sink final : public base_sink<Mutex>
{ {
public: 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)) : base_filename_(std::move(base_filename))
, max_size_(max_size) , max_size_(max_size)
, max_files_(max_files) , max_files_(max_files)
@ -150,7 +150,7 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
template<typename Factory = default_factory> template<typename Factory = default_factory>
inline std::shared_ptr<logger> rotating_logger_mt( 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); 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 spdlog {
namespace sinks { namespace sinks {
inline int syslog_level(level::level_enum l) { inline int syslog_level(level::level_enum l)
switch(l) { {
case level::off: switch (l)
case level::trace: {
case level::debug: case level::off:
return LOG_DEBUG; case level::trace:
case level::info: case level::debug:
return LOG_INFO; return LOG_DEBUG;
case level::warn: case level::info:
return LOG_WARNING; return LOG_INFO;
case level::err: case level::warn:
return LOG_ERR; return LOG_WARNING;
case level::critical: case level::err:
return LOG_CRIT; return LOG_ERR;
default: case level::critical:
throw std::invalid_argument("systemd_sink.h syslog_level()"); return LOG_CRIT;
default:
throw std::invalid_argument("systemd_sink.h syslog_level()");
} }
} }
@ -57,13 +59,7 @@ public:
protected: protected:
void sink_it_(const details::log_msg &msg) override void sink_it_(const details::log_msg &msg) override
{ {
if( sd_journal_print( if (sd_journal_print(syslog_level(msg.level), "%.*s", static_cast<int>(msg.payload.size()), msg.payload.data()))
syslog_level(msg.level),
"%.*s",
static_cast<int>(msg.payload.size()),
msg.payload.data()
)
)
throw spdlog_ex("Failed writing to systemd"); 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 // Create and register a syslog logger
template<typename Factory = default_factory> template<typename Factory = default_factory>
inline std::shared_ptr<logger> systemd_logger_mt( inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name)
const std::string &logger_name)
{ {
return Factory::template create<sinks::systemd_sink_mt>(logger_name); return Factory::template create<sinks::systemd_sink_mt>(logger_name);
} }
template<typename Factory = default_factory> template<typename Factory = default_factory>
inline std::shared_ptr<logger> systemd_logger_st( inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name)
const std::string &logger_name)
{ {
return Factory::template create<sinks::systemd_sink_st>(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 "logger.h"
#include "spdlog/spdlog.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(); auto logger_impl = spdlog::default_logger();
logger_impl->set_level(spdlog::level::trace); logger_impl->set_level(spdlog::level::trace);
return spdlog::lite::logger(logger_impl); return spdlog::lite::logger(logger_impl);
} }

5
lite-example/example.cpp
View File

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

8
lite/logger.cpp
View File

@ -2,9 +2,9 @@
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#include "spdlog/logger.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) 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 bool spdlog::lite::logger::should_log(spdlog::lite::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 level return impl_->should_log(spd_level); // TODO level
} }
void spdlog::lite::logger::log_formatted_(spdlog::lite::level level, const fmt::memory_buffer &formatted) 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)); 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) 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); 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)); impl_->set_pattern(std::move(pattern));
} }
spdlog::lite::logger &spdlog::lite::default_logger() spdlog::lite::logger &spdlog::lite::default_logger()
{ {
static spdlog::lite::logger s_default(spdlog::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_CRITICAL 5
#define SPDLITE_LEVEL_OFF 6 #define SPDLITE_LEVEL_OFF 6
#define SPDLITE_LOGGER_CALL(logger, level, ...) \ #define SPDLITE_LOGGER_CALL(logger, level, ...) \
if (logger.should_log(level)) \ if (logger.should_log(level)) \
logger.log(level, __VA_ARGS__) logger.log(level, __VA_ARGS__)
#if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_TRACE #if SPDLITE_ACTIVE_LEVEL <= SPDLITE_LEVEL_TRACE
@ -73,169 +73,169 @@
#define SPDLITE_CRITICAL(...) (void)0 #define SPDLITE_CRITICAL(...) (void)0
#endif #endif
namespace spdlog { namespace spdlog {
class logger; class logger;
namespace lite { namespace lite {
enum class level{ enum class level
trace = SPDLITE_LEVEL_TRACE, {
debug =SPDLITE_LEVEL_DEBUG, trace = SPDLITE_LEVEL_TRACE,
info = SPDLITE_LEVEL_INFO, debug = SPDLITE_LEVEL_DEBUG,
warn = SPDLITE_LEVEL_WARN, info = SPDLITE_LEVEL_INFO,
err = SPDLITE_LEVEL_ERROR, warn = SPDLITE_LEVEL_WARN,
critical = SPDLITE_LEVEL_CRITICAL, err = SPDLITE_LEVEL_ERROR,
off = SPDLITE_LEVEL_OFF critical = SPDLITE_LEVEL_CRITICAL,
}; off = SPDLITE_LEVEL_OFF
};
struct src_loc { struct src_loc
const char *filename; {
int line; const char *filename;
const char* funcname; int line;
}; const char *funcname;
};
class logger { class logger
public: {
logger() = default; public:
logger() = default;
logger(std::shared_ptr<spdlog::logger> impl); logger(std::shared_ptr<spdlog::logger> impl);
logger(const logger&) = default; logger(const logger &) = default;
logger(logger&&) = default; logger(logger &&) = default;
logger& operator=(const 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> template<typename... Args>
void log(spdlog::lite::level lvl, const char *fmt, const Args &... args) { void log(spdlog::lite::level lvl, const char *fmt, const Args &... args)
if (!should_log(lvl)) { {
return; if (!should_log(lvl))
}
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)
{ {
default_logger().trace(fmt, args...); return;
} }
template<typename... Args> fmt::memory_buffer formatted_buf;
void debug(const char *fmt, const Args &... args) 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> template<typename... Args>
void info(const char *fmt, const Args &... args) void trace(const char *fmt, const Args &... args)
{ {
default_logger().info(fmt, args...); log(spdlog::lite::level::trace, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void warn(const char *fmt, const Args &... args) void trace(const char *source_file, int source_line, const char *source_func, const char *fmt, const Args &... args)
{ {
default_logger().warn(fmt, args...); spdlog::lite::src_loc src{source_file, source_line, source_func};
} log(src, spdlog::lite::level::trace, fmt, args...);
}
template<typename... Args> template<typename... Args>
void error(const char *fmt, const Args &... args) void debug(const char *fmt, const Args &... args)
{ {
default_logger().error(fmt, args...); log(spdlog::lite::level::debug, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void critical(const char *fmt, const Args &... args) void info(const char *fmt, const Args &... args)
{ {
default_logger().critical(fmt, 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 template<typename... Args>
// implement it in a dedicated compilation unit for fast compiles void critical(const char *fmt, const Args &... args)
spdlog::lite::logger create_lite(void* ctx = nullptr); {
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 } // 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); logger->info("Test message {}", i);
} }
// drop causes the logger destructor to be called, which is required so the // 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()); spdlog::drop(logger->name());
} }