From d817994bd251ff29da9c6528e38dc66735bf6079 Mon Sep 17 00:00:00 2001 From: gabi Date: Tue, 9 Dec 2014 00:01:11 +0200 Subject: [PATCH] Moved namespace fmt to be under spdlog::details to minimize namespace pollution for the users --- include/spdlog/details/format.cc | 215 +++++++++--------- include/spdlog/details/format.h | 15 +- .../spdlog/details/pattern_formatter_impl.h | 6 +- include/spdlog/sinks/file_sinks.h | 4 +- 4 files changed, 125 insertions(+), 115 deletions(-) diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc index 8ef64ab9..070bf614 100644 --- a/include/spdlog/details/format.cc +++ b/include/spdlog/details/format.cc @@ -1,5 +1,8 @@ /* -Formatting library for C++ + +Modified version of cppformat formatting library + +Orginal license: Copyright (c) 2012 - 2014, Victor Zverovich All rights reserved. @@ -49,9 +52,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # undef ERROR #endif -using fmt::LongLong; -using fmt::ULongLong; -using fmt::internal::Arg; +using spdlog::details::fmt::LongLong; +using spdlog::details::fmt::ULongLong; +using spdlog::details::fmt::internal::Arg; // Check if exceptions are disabled. #if __GNUC__ && !__EXCEPTIONS @@ -127,7 +130,7 @@ struct IntChecker { const char RESET_COLOR[] = "\x1b[0m"; -typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef); +typedef void(*FormatFunc)(spdlog::details::fmt::Writer &, int, spdlog::details::fmt::StringRef); // Portable thread-safe version of strerror. // Sets buffer to point to a string describing the error code. @@ -166,27 +169,27 @@ FMT_FUNC int safe_strerror( return result; } -FMT_FUNC void format_error_code(fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void format_error_code(spdlog::details::fmt::Writer &out, int error_code, + spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { // Report error code making sure that the output fits into // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential // bad_alloc. out.clear(); static const char SEP[] = ": "; static const char ERROR[] = "error "; - fmt::internal::IntTraits::MainType ec_value = error_code; + spdlog::details::fmt::internal::IntTraits::MainType ec_value = error_code; // Subtract 2 to account for terminating null characters in SEP and ERROR. std::size_t error_code_size = - sizeof(SEP) + sizeof(ERROR) + fmt::internal::count_digits(ec_value) - 2; - if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size) + sizeof(SEP) + sizeof(ERROR) + spdlog::details::fmt::internal::count_digits(ec_value) - 2; + if (message.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE - error_code_size) out << message << SEP; out << ERROR << error_code; - assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE); + assert(out.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE); } FMT_FUNC void report_error(FormatFunc func, - int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) { - fmt::MemoryWriter full_message; + int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { + spdlog::details::fmt::MemoryWriter full_message; func(full_message, error_code, message); // Use Writer::data instead of Writer::c_str to avoid potential memory // allocation. @@ -195,7 +198,7 @@ FMT_FUNC void report_error(FormatFunc func, } // IsZeroInt::visit(arg) returns true iff arg is a zero integer. -class IsZeroInt : public fmt::internal::ArgVisitor { +class IsZeroInt : public spdlog::details::fmt::internal::ArgVisitor { public: template bool visit_any_int(T value) { @@ -219,15 +222,15 @@ FMT_FUNC int parse_nonnegative_int(const Char *&s) { value = new_value; } while ('0' <= *s && *s <= '9'); if (value > INT_MAX) - FMT_THROW(fmt::FormatError("number is too big")); + FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); return value; } inline void require_numeric_argument(const Arg &arg, char spec) { if (arg.type > Arg::LAST_NUMERIC_TYPE) { std::string message = - fmt::format("format specifier '{}' requires numeric argument", spec); - FMT_THROW(fmt::FormatError(message)); + spdlog::details::fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(spdlog::details::fmt::FormatError(message)); } } @@ -236,71 +239,71 @@ FMT_FUNC void check_sign(const Char *&s, const Arg &arg) { char sign = static_cast(*s); require_numeric_argument(arg, sign); if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { - FMT_THROW(fmt::FormatError(fmt::format( - "format specifier '{}' requires signed argument", sign))); + FMT_THROW(spdlog::details::fmt::FormatError(spdlog::details::fmt::format( + "format specifier '{}' requires signed argument", sign))); } ++s; } // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -class WidthHandler : public fmt::internal::ArgVisitor { +class WidthHandler : public spdlog::details::fmt::internal::ArgVisitor { private: - fmt::FormatSpec &spec_; + spdlog::details::fmt::FormatSpec &spec_; public: - explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} + explicit WidthHandler(spdlog::details::fmt::FormatSpec &spec) : spec_(spec) {} unsigned visit_unhandled_arg() { - FMT_THROW(fmt::FormatError("width is not integer")); + FMT_THROW(spdlog::details::fmt::FormatError("width is not integer")); return 0; } template unsigned visit_any_int(T value) { - typedef typename fmt::internal::IntTraits::MainType UnsignedType; + typedef typename spdlog::details::fmt::internal::IntTraits::MainType UnsignedType; UnsignedType width = value; - if (fmt::internal::is_negative(value)) { - spec_.align_ = fmt::ALIGN_LEFT; + if (spdlog::details::fmt::internal::is_negative(value)) { + spec_.align_ = spdlog::details::fmt::ALIGN_LEFT; width = 0 - width; } if (width > INT_MAX) - FMT_THROW(fmt::FormatError("number is too big")); + FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); return static_cast(width); } }; class PrecisionHandler : - public fmt::internal::ArgVisitor { + public spdlog::details::fmt::internal::ArgVisitor { public: unsigned visit_unhandled_arg() { - FMT_THROW(fmt::FormatError("precision is not integer")); + FMT_THROW(spdlog::details::fmt::FormatError("precision is not integer")); return 0; } template int visit_any_int(T value) { if (!IntChecker::is_signed>::fits_in_int(value)) - FMT_THROW(fmt::FormatError("number is too big")); + FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); return static_cast(value); } }; // Converts an integer argument to an integral type T for printf. template -class ArgConverter : public fmt::internal::ArgVisitor, void> { +class ArgConverter : public spdlog::details::fmt::internal::ArgVisitor, void> { private: - fmt::internal::Arg &arg_; + spdlog::details::fmt::internal::Arg &arg_; wchar_t type_; public: - ArgConverter(fmt::internal::Arg &arg, wchar_t type) + ArgConverter(spdlog::details::fmt::internal::Arg &arg, wchar_t type) : arg_(arg), type_(type) {} template void visit_any_int(U value) { bool is_signed = type_ == 'd' || type_ == 'i'; - using fmt::internal::Arg; + using spdlog::details::fmt::internal::Arg; if (sizeof(T) <= sizeof(int)) { // Extra casts are used to silence warnings. if (is_signed) { @@ -310,31 +313,31 @@ public: else { arg_.type = Arg::UINT; arg_.uint_value = static_cast( - static_cast::Type>(value)); + static_cast::Type>(value)); } } else { if (is_signed) { arg_.type = Arg::LONG_LONG; arg_.long_long_value = - static_cast::Type>(value); + static_cast::Type>(value); } else { arg_.type = Arg::ULONG_LONG; arg_.ulong_long_value = - static_cast::Type>(value); + static_cast::Type>(value); } } } }; // Converts an integer argument to char for printf. -class CharConverter : public fmt::internal::ArgVisitor { +class CharConverter : public spdlog::details::fmt::internal::ArgVisitor { private: - fmt::internal::Arg &arg_; + spdlog::details::fmt::internal::Arg &arg_; public: - explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {} + explicit CharConverter(spdlog::details::fmt::internal::Arg &arg) : arg_(arg) {} template void visit_any_int(T value) { @@ -362,7 +365,7 @@ inline Arg::StringValue ignore_incompatible_str( } } // namespace -FMT_FUNC void fmt::SystemError::init( +FMT_FUNC void spdlog::details::fmt::SystemError::init( int error_code, StringRef format_str, ArgList args) { error_code_ = error_code; MemoryWriter w; @@ -372,7 +375,7 @@ FMT_FUNC void fmt::SystemError::init( } template -FMT_FUNC int fmt::internal::CharTraits::format_float( +FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, T value) { if (width == 0) { @@ -386,7 +389,7 @@ FMT_FUNC int fmt::internal::CharTraits::format_float( } template -FMT_FUNC int fmt::internal::CharTraits::format_float( +FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, T value) { if (width == 0) { @@ -400,7 +403,7 @@ FMT_FUNC int fmt::internal::CharTraits::format_float( } template -const char fmt::internal::BasicData::DIGITS[] = +const char spdlog::details::fmt::internal::BasicData::DIGITS[] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" @@ -419,12 +422,12 @@ const char fmt::internal::BasicData::DIGITS[] = factor * 1000000000 template -const uint32_t fmt::internal::BasicData::POWERS_OF_10_32[] = { +const uint32_t spdlog::details::fmt::internal::BasicData::POWERS_OF_10_32[] = { 0, FMT_POWERS_OF_10(1) }; template -const uint64_t fmt::internal::BasicData::POWERS_OF_10_64[] = { +const uint64_t spdlog::details::fmt::internal::BasicData::POWERS_OF_10_64[] = { 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(ULongLong(1000000000)), @@ -433,19 +436,19 @@ const uint64_t fmt::internal::BasicData::POWERS_OF_10_64[] = { ULongLong(1000000000) * ULongLong(1000000000) * 10 }; -FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) { +FMT_FUNC void spdlog::details::fmt::internal::report_unknown_type(char code, const char *type) { if (std::isprint(static_cast(code))) { - FMT_THROW(fmt::FormatError( - fmt::format("unknown format code '{}' for {}", code, type))); + FMT_THROW(spdlog::details::fmt::FormatError( + spdlog::details::fmt::format("unknown format code '{}' for {}", code, type))); } - FMT_THROW(fmt::FormatError( - fmt::format("unknown format code '\\x{:02x}' for {}", - static_cast(code), type))); + FMT_THROW(spdlog::details::fmt::FormatError( + spdlog::details::fmt::format("unknown format code '\\x{:02x}' for {}", + static_cast(code), type))); } #ifdef _WIN32 -FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) { +FMT_FUNC spdlog::details::fmt::internal::UTF8ToUTF16::UTF8ToUTF16(spdlog::details::fmt::StringRef s) { int length = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0); static const char ERROR[] = "cannot convert string from UTF-8 to UTF-16"; @@ -458,14 +461,14 @@ FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) { FMT_THROW(WindowsError(GetLastError(), ERROR)); } -FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) { +FMT_FUNC spdlog::details::fmt::internal::UTF16ToUTF8::UTF16ToUTF8(spdlog::details::fmt::WStringRef s) { if (int error_code = convert(s)) { FMT_THROW(WindowsError(error_code, "cannot convert string from UTF-16 to UTF-8")); } } -FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) { +FMT_FUNC int spdlog::details::fmt::internal::UTF16ToUTF8::convert(spdlog::details::fmt::WStringRef s) { int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0); if (length == 0) return GetLastError(); @@ -477,7 +480,7 @@ FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) { return 0; } -FMT_FUNC void fmt::WindowsError::init( +FMT_FUNC void spdlog::details::fmt::WindowsError::init( int error_code, StringRef format_str, ArgList args) { error_code_ = error_code; MemoryWriter w; @@ -488,9 +491,9 @@ FMT_FUNC void fmt::WindowsError::init( #endif -FMT_FUNC void fmt::internal::format_system_error( - fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void spdlog::details::fmt::internal::format_system_error( + spdlog::details::fmt::Writer &out, int error_code, + spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { FMT_TRY { MemoryBuffer buffer; buffer.resize(INLINE_BUFFER_SIZE); @@ -510,9 +513,9 @@ FMT_FUNC void fmt::internal::format_system_error( } #ifdef _WIN32 -FMT_FUNC void fmt::internal::format_windows_error( - fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void spdlog::details::fmt::internal::format_windows_error( + spdlog::details::fmt::Writer &out, int error_code, + spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { class String { private: LPWSTR str_; @@ -548,17 +551,17 @@ FMT_FUNC void fmt::internal::format_windows_error( // An argument formatter. template -class fmt::internal::ArgFormatter : - public fmt::internal::ArgVisitor, void> { +class spdlog::details::fmt::internal::ArgFormatter : + public spdlog::details::fmt::internal::ArgVisitor, void> { private: - fmt::BasicFormatter &formatter_; - fmt::BasicWriter &writer_; - fmt::FormatSpec &spec_; + spdlog::details::fmt::BasicFormatter &formatter_; + spdlog::details::fmt::BasicWriter &writer_; + spdlog::details::fmt::FormatSpec &spec_; const Char *format_; public: ArgFormatter( - fmt::BasicFormatter &f, fmt::FormatSpec &s, const Char *fmt) + spdlog::details::fmt::BasicFormatter &f, spdlog::details::fmt::FormatSpec &s, const Char *fmt) : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} template @@ -579,16 +582,16 @@ public: } if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) FMT_THROW(FormatError("invalid format specifier for char")); - typedef typename fmt::BasicWriter::CharPtr CharPtr; + typedef typename spdlog::details::fmt::BasicWriter::CharPtr CharPtr; CharPtr out = CharPtr(); if (spec_.width_ > 1) { Char fill = static_cast(spec_.fill()); out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == fmt::ALIGN_RIGHT) { + if (spec_.align_ == spdlog::details::fmt::ALIGN_RIGHT) { std::fill_n(out, spec_.width_ - 1, fill); out += spec_.width_ - 1; } - else if (spec_.align_ == fmt::ALIGN_CENTER) { + else if (spec_.align_ == spdlog::details::fmt::ALIGN_CENTER) { out = writer_.fill_padding(out, spec_.width_, 1, fill); } else { @@ -610,8 +613,8 @@ public: void visit_pointer(const void *value) { if (spec_.type_ && spec_.type_ != 'p') - fmt::internal::report_unknown_type(spec_.type_, "pointer"); - spec_.flags_ = fmt::HASH_FLAG; + spdlog::details::fmt::internal::report_unknown_type(spec_.type_, "pointer"); + spec_.flags_ = spdlog::details::fmt::HASH_FLAG; spec_.type_ = 'x'; writer_.write_int(reinterpret_cast(value), spec_); } @@ -623,7 +626,7 @@ public: template template -FMT_FUNC void fmt::BasicWriter::write_str( +FMT_FUNC void spdlog::details::fmt::BasicWriter::write_str( const Arg::StringValue &str, const FormatSpec &spec) { // Check if StrChar is convertible to Char. internal::CharTraits::convert(StrChar()); @@ -641,7 +644,7 @@ FMT_FUNC void fmt::BasicWriter::write_str( } template -inline Arg fmt::BasicFormatter::parse_arg_index(const Char *&s) { +inline Arg spdlog::details::fmt::BasicFormatter::parse_arg_index(const Char *&s) { const char *error = 0; Arg arg = *s < '0' || *s > '9' ? next_arg(error) : get_arg(parse_nonnegative_int(s), error); @@ -652,7 +655,7 @@ inline Arg fmt::BasicFormatter::parse_arg_index(const Char *&s) { return arg; } -FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg( +FMT_FUNC Arg spdlog::details::fmt::internal::FormatterBase::do_get_arg( unsigned arg_index, const char *&error) { Arg arg = args_[arg_index]; if (arg.type == Arg::NONE) @@ -660,14 +663,14 @@ FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg( return arg; } -inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) { +inline Arg spdlog::details::fmt::internal::FormatterBase::next_arg(const char *&error) { if (next_arg_index_ >= 0) return do_get_arg(next_arg_index_++, error); error = "cannot switch from manual to automatic argument indexing"; return Arg(); } -inline Arg fmt::internal::FormatterBase::get_arg( +inline Arg spdlog::details::fmt::internal::FormatterBase::get_arg( unsigned arg_index, const char *&error) { if (next_arg_index_ <= 0) { next_arg_index_ = -1; @@ -678,7 +681,7 @@ inline Arg fmt::internal::FormatterBase::get_arg( } template -FMT_FUNC void fmt::internal::PrintfFormatter::parse_flags( +FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::parse_flags( FormatSpec &spec, const Char *&s) { for (;;) { switch (*s++) { @@ -705,7 +708,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter::parse_flags( } template -FMT_FUNC Arg fmt::internal::PrintfFormatter::get_arg( +FMT_FUNC Arg spdlog::details::fmt::internal::PrintfFormatter::get_arg( const Char *s, unsigned arg_index) { const char *error = 0; Arg arg = arg_index == UINT_MAX ? @@ -716,7 +719,7 @@ FMT_FUNC Arg fmt::internal::PrintfFormatter::get_arg( } template -FMT_FUNC unsigned fmt::internal::PrintfFormatter::parse_header( +FMT_FUNC unsigned spdlog::details::fmt::internal::PrintfFormatter::parse_header( const Char *&s, FormatSpec &spec) { unsigned arg_index = UINT_MAX; Char c = *s; @@ -752,7 +755,7 @@ FMT_FUNC unsigned fmt::internal::PrintfFormatter::parse_header( } template -FMT_FUNC void fmt::internal::PrintfFormatter::format( +FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format, const ArgList &args) { const Char *start = format.c_str(); @@ -806,7 +809,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter::format( break; case 'l': if (*s == 'l') - ArgConverter(arg, *++s).visit(arg); + ArgConverter(arg, *++s).visit(arg); else ArgConverter(arg, *s).visit(arg); break; @@ -923,7 +926,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter::format( } template -FMT_FUNC const Char *fmt::BasicFormatter::format( +FMT_FUNC const Char *spdlog::details::fmt::BasicFormatter::format( const Char *&format_str, const Arg &arg) { const Char *s = format_str; FormatSpec spec; @@ -1063,7 +1066,7 @@ FMT_FUNC const Char *fmt::BasicFormatter::format( } template -FMT_FUNC void fmt::BasicFormatter::format( +FMT_FUNC void spdlog::details::fmt::BasicFormatter::format( BasicStringRef format_str, const ArgList &args) { const Char *s = start_ = format_str.c_str(); set_args(args); @@ -1084,35 +1087,35 @@ FMT_FUNC void fmt::BasicFormatter::format( write(writer_, start_, s); } -FMT_FUNC void fmt::report_system_error( - int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void spdlog::details::fmt::report_system_error( + int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { report_error(internal::format_system_error, error_code, message); } #ifdef _WIN32 -FMT_FUNC void fmt::report_windows_error( - int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void spdlog::details::fmt::report_windows_error( + int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { report_error(internal::format_windows_error, error_code, message); } #endif -FMT_FUNC void fmt::print(std::FILE *f, StringRef format_str, ArgList args) { +FMT_FUNC void spdlog::details::fmt::print(std::FILE *f, StringRef format_str, ArgList args) { MemoryWriter w; w.write(format_str, args); std::fwrite(w.data(), 1, w.size(), f); } -FMT_FUNC void fmt::print(StringRef format_str, ArgList args) { +FMT_FUNC void spdlog::details::fmt::print(StringRef format_str, ArgList args) { print(stdout, format_str, args); } -FMT_FUNC void fmt::print(std::ostream &os, StringRef format_str, ArgList args) { +FMT_FUNC void spdlog::details::fmt::print(std::ostream &os, StringRef format_str, ArgList args) { MemoryWriter w; w.write(format_str, args); os.write(w.data(), w.size()); } -FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) { +FMT_FUNC void spdlog::details::fmt::print_colored(Color c, StringRef format, ArgList args) { char escape[] = "\x1b[30m"; escape[3] = '0' + static_cast(c); std::fputs(escape, stdout); @@ -1120,7 +1123,7 @@ FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) { std::fputs(RESET_COLOR, stdout); } -FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { +FMT_FUNC int spdlog::details::fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { MemoryWriter w; printf(w, format, args); std::size_t size = w.size(); @@ -1129,40 +1132,40 @@ FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { // Explicit instantiations for char. -template const char *fmt::BasicFormatter::format( - const char *&format_str, const fmt::internal::Arg &arg); +template const char *spdlog::details::fmt::BasicFormatter::format( + const char *&format_str, const spdlog::details::fmt::internal::Arg &arg); -template void fmt::BasicFormatter::format( +template void spdlog::details::fmt::BasicFormatter::format( BasicStringRef format, const ArgList &args); -template void fmt::internal::PrintfFormatter::format( +template void spdlog::details::fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format, const ArgList &args); -template int fmt::internal::CharTraits::format_float( +template int spdlog::details::fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, double value); -template int fmt::internal::CharTraits::format_float( +template int spdlog::details::fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, long double value); // Explicit instantiations for wchar_t. -template const wchar_t *fmt::BasicFormatter::format( - const wchar_t *&format_str, const fmt::internal::Arg &arg); +template const wchar_t *spdlog::details::fmt::BasicFormatter::format( + const wchar_t *&format_str, const spdlog::details::fmt::internal::Arg &arg); -template void fmt::BasicFormatter::format( +template void spdlog::details::fmt::BasicFormatter::format( BasicStringRef format, const ArgList &args); -template void fmt::internal::PrintfFormatter::format( +template void spdlog::details::fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format, const ArgList &args); -template int fmt::internal::CharTraits::format_float( +template int spdlog::details::fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, double value); -template int fmt::internal::CharTraits::format_float( +template int spdlog::details::fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, long double value); diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 82f65058..337b4ab8 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -115,7 +115,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ TypeName(const TypeName&); \ void operator=(const TypeName&) - +namespace spdlog { +namespace details { namespace fmt { @@ -1053,7 +1054,7 @@ public: { default: assert(false); - // Fall through. + // Fall through. case Arg::INT: return FMT_DISPATCH(visit_int(arg.int_value)); case Arg::UINT: @@ -2222,7 +2223,7 @@ void BasicWriter::write_double( // MSVC's printf doesn't support 'F'. type = 'f'; #endif - // Fall through. + // Fall through. case 'E': case 'G': case 'A': @@ -2739,7 +2740,9 @@ inline void format_decimal(char *&buffer, T value) internal::format_decimal(buffer, abs_value, num_digits); buffer += num_digits; } -} +} // ns fmt +} // ns deatils +} // ns spdlog #if FMT_GCC_VERSION // Use the system_header pragma to suppress warnings about variadic macros @@ -2846,6 +2849,8 @@ fmt::print(format, args...); #define FMT_VARIADIC_W(ReturnType, func, ...) \ FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) +namespace spdlog { +namespace details { namespace fmt { FMT_VARIADIC(std::string, format, StringRef) @@ -2858,6 +2863,8 @@ FMT_VARIADIC(std::string, sprintf, StringRef) FMT_VARIADIC(int, printf, StringRef) FMT_VARIADIC(int, fprintf, std::FILE *, StringRef) } +} +} // Restore warnings. #if FMT_GCC_VERSION >= 406 diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 0d36da0d..1b31ced4 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -458,7 +458,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) { switch (flag) { - // logger name + // logger name case 'n': _formatters.push_back(std::unique_ptr(new details::name_formatter())); break; @@ -582,8 +582,8 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg) //write eol msg.formatted << details::os::eol(); } - catch(const fmt::FormatError& e) + catch(const details::fmt::FormatError& e) { - throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what())); + throw spdlog_ex(details::fmt::format("formatting error while processing format string: {}", e.what())); } } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 26d5d0e1..37a3abc7 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -99,7 +99,7 @@ protected: private: static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension) { - fmt::MemoryWriter w; + details::fmt::MemoryWriter w; if (index) w.write("{}.{}.{}", filename, index, extension); else @@ -196,7 +196,7 @@ private: static std::string calc_filename(const std::string& basename, const std::string& extension) { std::tm tm = spdlog::details::os::localtime(); - fmt::MemoryWriter w; + details::fmt::MemoryWriter w; w.write("{}.{:04d}-{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension); return w.str(); }