mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-11-15 16:35:45 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
gabime 2020-04-19 11:33:36 +03:00
parent 5716ab70ec
commit 81444265f4
4 changed files with 110 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/spdlog/details/log_msg-inl.h
View File

@ -12,8 +12,8 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE log_msg::log_msg( SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) spdlog::level::level_enum lvl, spdlog::string_view_t msg)
: logger_name(a_logger_name) : logger_name(a_logger_name)
, level(lvl) , level(lvl)
, time(log_time) , time(log_time)

9
include/spdlog/pattern_formatter-inl.h
View File

@ -95,7 +95,10 @@ struct null_scoped_padder
null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {} null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {}
template<typename T> template<typename T>
static unsigned int count_digits(T /* number */) { return 0;} static unsigned int count_digits(T /* number */)
{
return 0;
}
}; };
template<typename ScopedPadder> template<typename ScopedPadder>
@ -653,7 +656,6 @@ public:
} }
}; };
// Current pid // Current pid
template<typename ScopedPadder> template<typename ScopedPadder>
class pid_formatter final : public flag_formatter class pid_formatter final : public flag_formatter
@ -766,7 +768,7 @@ public:
} }
size_t text_size; size_t text_size;
if(padinfo_.enabled()) if (padinfo_.enabled())
{ {
// calc text size for padding based on "filename:line" // calc text size for padding based on "filename:line"
text_size = std::char_traits<char>::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1; text_size = std::char_traits<char>::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1;
@ -900,7 +902,6 @@ private:
log_clock::time_point last_message_time_; log_clock::time_point last_message_time_;
}; };
// Full info formatter // Full info formatter
// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
class full_formatter final : public flag_formatter class full_formatter final : public flag_formatter

163
src/fmt.cpp
View File

@ -2,7 +2,6 @@
// Copyright (c) 2012 - 2016, Victor Zverovich // Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved. // All rights reserved.
#ifndef SPDLOG_COMPILED_LIB #ifndef SPDLOG_COMPILED_LIB
#error Please define SPDLOG_COMPILED_LIB to compile this file. #error Please define SPDLOG_COMPILED_LIB to compile this file.
#endif #endif
@ -10,53 +9,63 @@
#if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
#include <spdlog/fmt/bundled/format-inl.h> #include <spdlog/fmt/bundled/format-inl.h>
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace internal { namespace internal {
template <typename T> template<typename T>
int format_float(char* buf, std::size_t size, const char* format, int precision, int format_float(char *buf, std::size_t size, const char *format, int precision, T value)
T value) { {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (precision > 100000) if (precision > 100000)
throw std::runtime_error( throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf");
"fuzz mode - avoid large allocation inside snprintf");
#endif #endif
// Suppress the warning about nonliteral format string. // Suppress the warning about nonliteral format string.
int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF; int (*snprintf_ptr)(char *, size_t, const char *, ...) = FMT_SNPRINTF;
return precision < 0 ? snprintf_ptr(buf, size, format, value) return precision < 0 ? snprintf_ptr(buf, size, format, value) : snprintf_ptr(buf, size, format, precision, value);
: snprintf_ptr(buf, size, format, precision, value);
} }
struct sprintf_specs { struct sprintf_specs
{
int precision; int precision;
char type; char type;
bool alt : 1; bool alt : 1;
template <typename Char> template<typename Char>
constexpr sprintf_specs(basic_format_specs<Char> specs) constexpr sprintf_specs(basic_format_specs<Char> specs)
: precision(specs.precision), type(specs.type), alt(specs.alt) {} : precision(specs.precision)
, type(specs.type)
, alt(specs.alt)
{}
constexpr bool has_precision() const { return precision >= 0; } constexpr bool has_precision() const
{
return precision >= 0;
}
}; };
// This is deprecated and is kept only to preserve ABI compatibility. // This is deprecated and is kept only to preserve ABI compatibility.
template <typename Double> template<typename Double>
char* sprintf_format(Double value, internal::buffer<char>& buf, char *sprintf_format(Double value, internal::buffer<char> &buf, sprintf_specs specs)
sprintf_specs specs) { {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() != 0, "empty buffer"); FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// Build format string. // Build format string.
enum { max_format_size = 10 }; // longest format: %#-*.*Lg enum
{
max_format_size = 10
}; // longest format: %#-*.*Lg
char format[max_format_size]; char format[max_format_size];
char* format_ptr = format; char *format_ptr = format;
*format_ptr++ = '%'; *format_ptr++ = '%';
if (specs.alt || !specs.type) *format_ptr++ = '#'; if (specs.alt || !specs.type)
if (specs.precision >= 0) { *format_ptr++ = '#';
if (specs.precision >= 0)
{
*format_ptr++ = '.'; *format_ptr++ = '.';
*format_ptr++ = '*'; *format_ptr++ = '*';
} }
if (std::is_same<Double, long double>::value) *format_ptr++ = 'L'; if (std::is_same<Double, long double>::value)
*format_ptr++ = 'L';
char type = specs.type; char type = specs.type;
@ -65,51 +74,66 @@ char* sprintf_format(Double value, internal::buffer<char>& buf,
else if (type == 0 || type == 'n') else if (type == 0 || type == 'n')
type = 'g'; type = 'g';
#if FMT_MSC_VER #if FMT_MSC_VER
if (type == 'F') { if (type == 'F')
// MSVC's printf doesn't support 'F'. {
type = 'f'; // MSVC's printf doesn't support 'F'.
} type = 'f';
}
#endif #endif
*format_ptr++ = type; *format_ptr++ = type;
*format_ptr = '\0'; *format_ptr = '\0';
// Format using snprintf. // Format using snprintf.
char* start = nullptr; char *start = nullptr;
char* decimal_point_pos = nullptr; char *decimal_point_pos = nullptr;
for (;;) { for (;;)
{
std::size_t buffer_size = buf.capacity(); std::size_t buffer_size = buf.capacity();
start = &buf[0]; start = &buf[0];
int result = int result = format_float(start, buffer_size, format, specs.precision, value);
format_float(start, buffer_size, format, specs.precision, value); if (result >= 0)
if (result >= 0) { {
unsigned n = internal::to_unsigned(result); unsigned n = internal::to_unsigned(result);
if (n < buf.capacity()) { if (n < buf.capacity())
{
// Find the decimal point. // Find the decimal point.
auto p = buf.data(), end = p + n; auto p = buf.data(), end = p + n;
if (*p == '+' || *p == '-') ++p; if (*p == '+' || *p == '-')
if (specs.type != 'a' && specs.type != 'A') { ++p;
while (p < end && *p >= '0' && *p <= '9') ++p; if (specs.type != 'a' && specs.type != 'A')
if (p < end && *p != 'e' && *p != 'E') { {
while (p < end && *p >= '0' && *p <= '9')
++p;
if (p < end && *p != 'e' && *p != 'E')
{
decimal_point_pos = p; decimal_point_pos = p;
if (!specs.type) { if (!specs.type)
{
// Keep only one trailing zero after the decimal point. // Keep only one trailing zero after the decimal point.
++p; ++p;
if (*p == '0') ++p; if (*p == '0')
while (p != end && *p >= '1' && *p <= '9') ++p; ++p;
char* where = p; while (p != end && *p >= '1' && *p <= '9')
while (p != end && *p == '0') ++p; ++p;
if (p == end || *p < '0' || *p > '9') { char *where = p;
if (p != end) std::memmove(where, p, to_unsigned(end - p)); while (p != end && *p == '0')
++p;
if (p == end || *p < '0' || *p > '9')
{
if (p != end)
std::memmove(where, p, to_unsigned(end - p));
n -= static_cast<unsigned>(p - where); n -= static_cast<unsigned>(p - where);
} }
} }
} }
} }
buf.resize(n); buf.resize(n);
break; // The buffer is large enough - continue with formatting. break; // The buffer is large enough - continue with formatting.
} }
buf.reserve(n + 1); buf.reserve(n + 1);
} else { }
else
{
// If result is negative we ask to increase the capacity by at least 1, // If result is negative we ask to increase the capacity by at least 1,
// but as std::vector, the buffer grows exponentially. // but as std::vector, the buffer grows exponentially.
buf.reserve(buf.capacity() + 1); buf.reserve(buf.capacity() + 1);
@ -117,23 +141,18 @@ char* sprintf_format(Double value, internal::buffer<char>& buf,
} }
return decimal_point_pos; return decimal_point_pos;
} }
} // namespace internal } // namespace internal
template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&, template FMT_API char *internal::sprintf_format(double, internal::buffer<char> &, sprintf_specs);
sprintf_specs); template FMT_API char *internal::sprintf_format(long double, internal::buffer<char> &, sprintf_specs);
template FMT_API char* internal::sprintf_format(long double,
internal::buffer<char>&,
sprintf_specs);
template struct FMT_INSTANTIATION_DEF_API internal::basic_data<void>; template struct FMT_INSTANTIATION_DEF_API internal::basic_data<void>;
// Workaround a bug in MSVC2013 that prevents instantiation of format_float. // Workaround a bug in MSVC2013 that prevents instantiation of format_float.
int (*instantiate_format_float)(double, int, internal::float_specs, int (*instantiate_format_float)(double, int, internal::float_specs, internal::buffer<char> &) = internal::format_float;
internal::buffer<char>&) =
internal::format_float;
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template FMT_API internal::locale_ref::locale_ref(const std::locale& loc); template FMT_API internal::locale_ref::locale_ref(const std::locale &loc);
template FMT_API std::locale internal::locale_ref::get<std::locale>() const; template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
#endif #endif
@ -143,28 +162,18 @@ template FMT_API std::string internal::grouping_impl<char>(locale_ref);
template FMT_API char internal::thousands_sep_impl(locale_ref); template FMT_API char internal::thousands_sep_impl(locale_ref);
template FMT_API char internal::decimal_point_impl(locale_ref); template FMT_API char internal::decimal_point_impl(locale_ref);
template FMT_API void internal::buffer<char>::append(const char*, const char*); template FMT_API void internal::buffer<char>::append(const char *, const char *);
template FMT_API void internal::arg_map<format_context>::init( template FMT_API void internal::arg_map<format_context>::init(const basic_format_args<format_context> &args);
const basic_format_args<format_context>& args);
template FMT_API std::string internal::vformat<char>( template FMT_API std::string internal::vformat<char>(string_view, basic_format_args<format_context>);
string_view, basic_format_args<format_context>);
template FMT_API format_context::iterator internal::vformat_to( template FMT_API format_context::iterator internal::vformat_to(internal::buffer<char> &, string_view, basic_format_args<format_context>);
internal::buffer<char>&, string_view, basic_format_args<format_context>);
template FMT_API int internal::snprintf_float(double, int, template FMT_API int internal::snprintf_float(double, int, internal::float_specs, internal::buffer<char> &);
internal::float_specs, template FMT_API int internal::snprintf_float(long double, int, internal::float_specs, internal::buffer<char> &);
internal::buffer<char>&); template FMT_API int internal::format_float(double, int, internal::float_specs, internal::buffer<char> &);
template FMT_API int internal::snprintf_float(long double, int, template FMT_API int internal::format_float(long double, int, internal::float_specs, internal::buffer<char> &);
internal::float_specs,
internal::buffer<char>&);
template FMT_API int internal::format_float(double, int, internal::float_specs,
internal::buffer<char>&);
template FMT_API int internal::format_float(long double, int,
internal::float_specs,
internal::buffer<char>&);
// Explicit instantiations for wchar_t. // Explicit instantiations for wchar_t.
@ -172,11 +181,9 @@ template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
template FMT_API wchar_t internal::thousands_sep_impl(locale_ref); template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
template FMT_API wchar_t internal::decimal_point_impl(locale_ref); template FMT_API wchar_t internal::decimal_point_impl(locale_ref);
template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*, template FMT_API void internal::buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
const wchar_t*);
template FMT_API std::wstring internal::vformat<wchar_t>( template FMT_API std::wstring internal::vformat<wchar_t>(wstring_view, basic_format_args<wformat_context>);
wstring_view, basic_format_args<wformat_context>);
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // !SPDLOG_FMT_EXTERNAL #endif // !SPDLOG_FMT_EXTERNAL

33
tests/test_time_point.cpp
View File

@ -4,28 +4,29 @@
TEST_CASE("time_point1", "[time_point log_msg]") TEST_CASE("time_point1", "[time_point log_msg]")
{ {
std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st); std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
spdlog::logger logger("test-time_point", test_sink); spdlog::logger logger("test-time_point", test_sink);
spdlog::source_loc source{}; spdlog::source_loc source{};
std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()}; std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()};
test_sink->set_pattern("%T.%F"); // interested in the time_point test_sink->set_pattern("%T.%F"); // interested in the time_point
// all the following should have the same time // all the following should have the same time
test_sink->set_delay(std::chrono::milliseconds(10)); test_sink->set_delay(std::chrono::milliseconds(10));
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++)
spdlog::details::log_msg msg{tp,source,"test_logger", spdlog::level::info, "message"}; {
spdlog::details::log_msg msg{tp, source, "test_logger", spdlog::level::info, "message"};
test_sink->log(msg); test_sink->log(msg);
} }
logger.log(tp,source,spdlog::level::info,"formatted message"); logger.log(tp, source, spdlog::level::info, "formatted message");
logger.log(tp,source,spdlog::level::info,"formatted message"); logger.log(tp, source, spdlog::level::info, "formatted message");
logger.log(tp,source,spdlog::level::info,"formatted message"); logger.log(tp, source, spdlog::level::info, "formatted message");
logger.log(tp,source,spdlog::level::info,"formatted message"); logger.log(tp, source, spdlog::level::info, "formatted message");
logger.log(source,spdlog::level::info,"formatted message"); // last line has different time_point logger.log(source, spdlog::level::info, "formatted message"); // last line has different time_point
// now the real test... that the times are the same. // now the real test... that the times are the same.
std::vector<std::string> lines = test_sink->lines(); std::vector<std::string> lines = test_sink->lines();
REQUIRE(lines[0] == lines[1]); REQUIRE(lines[0] == lines[1]);
REQUIRE(lines[2] == lines[3]); REQUIRE(lines[2] == lines[3]);
REQUIRE(lines[4] == lines[5]); REQUIRE(lines[4] == lines[5]);