From 0f76db880e424cf9d8a073ce1fffeacfd3cb500c Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 28 Nov 2015 16:52:02 +0200 Subject: [PATCH] astyle --- include/spdlog/details/async_log_helper.h | 3 +- include/spdlog/details/async_logger_impl.h | 3 +- include/spdlog/details/file_helper.h | 3 +- include/spdlog/details/format.h | 1069 +++++++++++------ include/spdlog/details/logger_impl.h | 6 +- include/spdlog/details/os.h | 4 +- .../spdlog/details/pattern_formatter_impl.h | 2 +- include/spdlog/details/registry.h | 2 +- include/spdlog/sinks/android_sink.h | 34 +- include/spdlog/sinks/dist_sink.h | 2 +- include/spdlog/sinks/file_sinks.h | 2 +- 11 files changed, 748 insertions(+), 382 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 6c7cd0fe..5d301dab 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -249,7 +249,8 @@ inline void spdlog::details::async_log_helper::push_msg(details::async_log_helpe { now = details::os::now(); sleep_or_yield(now, last_op_time); - } while (!_q.enqueue(std::move(new_msg))); + } + while (!_q.enqueue(std::move(new_msg))); } } diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h index 4ab5ff3b..f378f12d 100644 --- a/include/spdlog/details/async_logger_impl.h +++ b/include/spdlog/details/async_logger_impl.h @@ -60,7 +60,8 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms) : - async_logger(logger_name, { + async_logger(logger_name, +{ single_sink }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms) {} diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index 4ba556ac..53e9467e 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -87,7 +87,8 @@ public: } - void flush() { + void flush() + { std::fflush(_fd); } diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 41f593e7..0b8a0a2a 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -62,10 +62,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifdef _MSC_VER # include // _BitScanReverse, _BitScanReverse64 -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ # pragma intrinsic(_BitScanReverse) -inline uint32_t clz(uint32_t x) { +inline uint32_t clz(uint32_t x) +{ unsigned long r = 0; _BitScanReverse(&r, x); return 31 - r; @@ -76,7 +79,8 @@ inline uint32_t clz(uint32_t x) { # pragma intrinsic(_BitScanReverse64) # endif -inline uint32_t clzll(uint64_t x) { +inline uint32_t clzll(uint64_t x) +{ unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); @@ -217,11 +221,15 @@ inline uint32_t clzll(uint64_t x) { # define FMT_ASSERT(condition, message) assert((condition) && message) #endif -namespace fmt { -namespace internal { -struct DummyInt { +namespace fmt +{ +namespace internal +{ +struct DummyInt +{ int data[2]; - operator int() const { + operator int() const + { return 0; } }; @@ -229,51 +237,62 @@ typedef std::numeric_limits FPUtil; // Dummy implementations of system functions such as signbit and ecvt called // if the latter are not available. -inline DummyInt signbit(...) { +inline DummyInt signbit(...) +{ return DummyInt(); } -inline DummyInt _ecvt_s(...) { +inline DummyInt _ecvt_s(...) +{ return DummyInt(); } -inline DummyInt isinf(...) { +inline DummyInt isinf(...) +{ return DummyInt(); } -inline DummyInt _finite(...) { +inline DummyInt _finite(...) +{ return DummyInt(); } -inline DummyInt isnan(...) { +inline DummyInt isnan(...) +{ return DummyInt(); } -inline DummyInt _isnan(...) { +inline DummyInt _isnan(...) +{ return DummyInt(); } // A helper function to suppress bogus "conditional expression is constant" // warnings. template -inline T check(T value) { +inline T check(T value) +{ return value; } } } // namespace fmt -namespace std { +namespace std +{ // Standard permits specialization of std::numeric_limits. This specialization // is used to resolve ambiguity between isinf and std::isinf in glibc: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 // and the same for isnan and signbit. template <> class numeric_limits : - public std::numeric_limits { + public std::numeric_limits +{ public: // Portable version of isinf. template - static bool isinfinity(T x) { + static bool isinfinity(T x) + { using namespace fmt::internal; // The resolution "priority" is: // isinf macro > std::isinf > ::isinf > fmt::internal::isinf if (check(sizeof(isinf(x)) == sizeof(bool) || - sizeof(isinf(x)) == sizeof(int))) { + sizeof(isinf(x)) == sizeof(int))) + { return isinf(x); } return !_finite(static_cast(x)); @@ -281,17 +300,20 @@ public: // Portable version of isnan. template - static bool isnotanumber(T x) { + static bool isnotanumber(T x) + { using namespace fmt::internal; if (check(sizeof(isnan(x)) == sizeof(bool) || - sizeof(isnan(x)) == sizeof(int))) { + sizeof(isnan(x)) == sizeof(int))) + { return isnan(x); } return _isnan(static_cast(x)) != 0; } // Portable version of signbit. - static bool isnegative(double x) { + static bool isnegative(double x) + { using namespace fmt::internal; if (check(sizeof(signbit(x)) == sizeof(int))) return signbit(x); @@ -305,7 +327,8 @@ public: }; } // namespace std -namespace fmt { +namespace fmt +{ // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -353,7 +376,8 @@ format(std::string("{}"), 42); \endrst */ template -class BasicStringRef { +class BasicStringRef +{ private: const Char *data_; std::size_t size_; @@ -384,22 +408,26 @@ public: Converts a string reference to an ``std::string`` object. \endrst */ - std::basic_string to_string() const { + std::basic_string to_string() const + { return std::basic_string(data_, size_); } /** Returns the pointer to a C string. */ - const Char *data() const { + const Char *data() const + { return data_; } /** Returns the string size. */ - std::size_t size() const { + std::size_t size() const + { return size_; } // Lexicographically compare this string reference to other. - int compare(BasicStringRef other) const { + int compare(BasicStringRef other) const + { std::size_t size = std::min(size_, other.size_); int result = std::char_traits::compare(data_, other.data_, size); if (result == 0) @@ -407,22 +435,28 @@ public: return result; } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) == 0; } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) != 0; } - friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) < 0; } - friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) <= 0; } - friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) > 0; } - friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.compare(rhs) >= 0; } }; @@ -456,7 +490,8 @@ format(std::string("{}"), 42); \endrst */ template -class BasicCStringRef { +class BasicCStringRef +{ private: const Char *data_; @@ -472,7 +507,8 @@ public: BasicCStringRef(const std::basic_string &s) : data_(s.c_str()) {} /** Returns the pointer to a C string. */ - const Char *c_str() const { + const Char *c_str() const + { return data_; } }; @@ -483,13 +519,15 @@ typedef BasicCStringRef WCStringRef; /** A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error { +class FormatError : public std::runtime_error +{ public: explicit FormatError(CStringRef message) : std::runtime_error(message.c_str()) {} }; -namespace internal { +namespace internal +{ // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. enum { INLINE_BUFFER_SIZE = 500 }; @@ -497,12 +535,14 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if FMT_SECURE_SCL // Use checked iterator to avoid warnings on MSVC. template -inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) +{ return stdext::checked_array_iterator(ptr, size); } #else template -inline T *make_ptr(T *ptr, std::size_t) { +inline T *make_ptr(T *ptr, std::size_t) +{ return ptr; } #endif @@ -514,7 +554,8 @@ A buffer supporting a subset of ``std::vector``'s operations. \endrst */ template -class Buffer { +class Buffer +{ private: FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); @@ -538,19 +579,22 @@ public: virtual ~Buffer() {} /** Returns the size of this buffer. */ - std::size_t size() const { + std::size_t size() const + { return size_; } /** Returns the capacity of this buffer. */ - std::size_t capacity() const { + std::size_t capacity() const + { return capacity_; } /** Resizes the buffer. If T is a POD type new elements may not be initialized. */ - void resize(std::size_t new_size) { + void resize(std::size_t new_size) + { if (new_size > capacity_) grow(new_size); size_ = new_size; @@ -561,14 +605,16 @@ public: Reserves space to store at least *capacity* elements. \endrst */ - void reserve(std::size_t capacity) { + void reserve(std::size_t capacity) + { if (capacity > capacity_) grow(capacity); } - void clear() FMT_NOEXCEPT{ size_ = 0; } + void clear() FMT_NOEXCEPT { size_ = 0; } - void push_back(const T &value) { + void push_back(const T &value) + { if (size_ == capacity_) grow(size_ + 1); ptr_[size_++] = value; @@ -578,17 +624,20 @@ public: template void append(const U *begin, const U *end); - T &operator[](std::size_t index) { + T &operator[](std::size_t index) + { return ptr_[index]; } - const T &operator[](std::size_t index) const { + const T &operator[](std::size_t index) const + { return ptr_[index]; } }; template template -void Buffer::append(const U *begin, const U *end) { +void Buffer::append(const U *begin, const U *end) +{ assert(begin <= end); std::size_t new_size = size_ + (end - begin); if (new_size > capacity_) @@ -597,17 +646,20 @@ void Buffer::append(const U *begin, const U *end) { size_ = new_size; } -namespace internal { +namespace internal +{ // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer { +class MemoryBuffer : private Allocator, public Buffer +{ private: T data_[SIZE]; // Deallocate memory allocated by the buffer. - void deallocate() { + void deallocate() + { if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); } @@ -617,24 +669,28 @@ protected: public: explicit MemoryBuffer(const Allocator &alloc = Allocator()) : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() { + ~MemoryBuffer() + { deallocate(); } #if FMT_USE_RVALUE_REFERENCES private: // Move data from other to this buffer. - void move(MemoryBuffer &other) { + void move(MemoryBuffer &other) + { Allocator &this_alloc = *this, &other_alloc = other; this_alloc = std::move(other_alloc); this->size_ = other.size_; this->capacity_ = other.capacity_; - if (other.ptr_ == other.data_) { + if (other.ptr_ == other.data_) + { this->ptr_ = data_; std::copy(other.data_, other.data_ + this->size_, make_ptr(data_, this->capacity_)); } - else { + else + { this->ptr_ = other.ptr_; // Set pointer to the inline array so that delete is not called // when deallocating. @@ -643,11 +699,13 @@ private: } public: - MemoryBuffer(MemoryBuffer &&other) { + MemoryBuffer(MemoryBuffer &&other) + { move(other); } - MemoryBuffer &operator=(MemoryBuffer &&other) { + MemoryBuffer &operator=(MemoryBuffer &&other) + { assert(this != &other); deallocate(); move(other); @@ -656,13 +714,15 @@ public: #endif // Returns a copy of the allocator associated with this buffer. - Allocator get_allocator() const { + Allocator get_allocator() const + { return *this; } }; template -void MemoryBuffer::grow(std::size_t size) { +void MemoryBuffer::grow(std::size_t size) +{ std::size_t new_capacity = (std::max)(size, this->capacity_ + this->capacity_ / 2); T *new_ptr = this->allocate(new_capacity); @@ -682,7 +742,8 @@ void MemoryBuffer::grow(std::size_t size) { // A fixed-size buffer. template -class FixedBuffer : public fmt::Buffer { +class FixedBuffer : public fmt::Buffer +{ public: FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} @@ -691,14 +752,16 @@ protected: }; template -class BasicCharTraits { +class BasicCharTraits +{ public: #if FMT_SECURE_SCL typedef stdext::checked_array_iterator CharPtr; #else typedef Char *CharPtr; #endif - static Char cast(wchar_t value) { + static Char cast(wchar_t value) + { return static_cast(value); } }; @@ -707,13 +770,15 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits +{ private: // Conversion from wchar_t to char is not allowed. static char convert(wchar_t); public: - static char convert(char value) { + static char convert(char value) + { return value; } @@ -724,12 +789,15 @@ public: }; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits +{ public: - static wchar_t convert(char value) { + static wchar_t convert(char value) + { return value; } - static wchar_t convert(wchar_t value) { + static wchar_t convert(wchar_t value) + { return value; } @@ -740,17 +808,21 @@ public: // Checks if a number is negative - used to avoid warnings. template -struct SignChecker { +struct SignChecker +{ template - static bool is_negative(T value) { + static bool is_negative(T value) + { return value < 0; } }; template <> -struct SignChecker { +struct SignChecker +{ template - static bool is_negative(T) { + static bool is_negative(T) + { return false; } }; @@ -758,23 +830,27 @@ struct SignChecker { // Returns true if value is negative, false otherwise. // Same as (value < 0) but doesn't produce warnings if T is an unsigned type. template -inline bool is_negative(T value) { +inline bool is_negative(T value) +{ return SignChecker::is_signed>::is_negative(value); } // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. template -struct TypeSelector { +struct TypeSelector +{ typedef uint32_t Type; }; template <> -struct TypeSelector { +struct TypeSelector +{ typedef uint64_t Type; }; template -struct IntTraits { +struct IntTraits +{ // Smallest of uint32_t and uint64_t that is large enough to represent // all values of T. typedef typename @@ -783,7 +859,8 @@ struct IntTraits { // MakeUnsigned::Type gives an unsigned type corresponding to integer type T. template -struct MakeUnsigned { +struct MakeUnsigned +{ typedef T Type; }; @@ -803,7 +880,8 @@ void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct BasicData { +struct BasicData +{ static const uint32_t POWERS_OF_10_32[]; static const uint64_t POWERS_OF_10_64[]; static const char DIGITS[]; @@ -822,7 +900,8 @@ typedef BasicData<> Data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) { +inline unsigned count_digits(uint64_t n) +{ // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; @@ -830,9 +909,11 @@ inline unsigned count_digits(uint64_t n) { } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) { +inline unsigned count_digits(uint64_t n) +{ unsigned count = 1; - for (;;) { + for (;;) + { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -848,7 +929,8 @@ inline unsigned count_digits(uint64_t n) { #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) { +inline unsigned count_digits(uint32_t n) +{ uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; return t - (n < Data::POWERS_OF_10_32[t]) + 1; } @@ -856,9 +938,11 @@ inline unsigned count_digits(uint32_t n) { // Formats a decimal unsigned integer value writing into buffer. template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) +{ buffer += num_digits; - while (value >= 100) { + while (value >= 100) + { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -867,7 +951,8 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { *--buffer = Data::DIGITS[index + 1]; *--buffer = Data::DIGITS[index]; } - if (value < 10) { + if (value < 10) + { *--buffer = static_cast('0' + value); return; } @@ -887,45 +972,55 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { #if FMT_USE_WINDOWS_H // A converter from UTF-8 to UTF-16. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF8ToUTF16 { +class UTF8ToUTF16 +{ private: MemoryBuffer buffer_; public: explicit UTF8ToUTF16(StringRef s); - operator WStringRef() const { + operator WStringRef() const + { return WStringRef(&buffer_[0], size()); } - size_t size() const { + size_t size() const + { return buffer_.size() - 1; } - const wchar_t *c_str() const { + const wchar_t *c_str() const + { return &buffer_[0]; } - std::wstring str() const { + std::wstring str() const + { return std::wstring(&buffer_[0], size()); } }; // A converter from UTF-16 to UTF-8. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF16ToUTF8 { +class UTF16ToUTF8 +{ private: MemoryBuffer buffer_; public: UTF16ToUTF8() {} explicit UTF16ToUTF8(WStringRef s); - operator StringRef() const { + operator StringRef() const + { return StringRef(&buffer_[0], size()); } - size_t size() const { + size_t size() const + { return buffer_.size() - 1; } - const char *c_str() const { + const char *c_str() const + { return &buffer_[0]; } - std::string str() const { + std::string str() const + { return std::string(&buffer_[0], size()); } @@ -943,9 +1038,11 @@ void format_system_error(fmt::Writer &out, int error_code, fmt::StringRef message) FMT_NOEXCEPT; // A formatting argument value. -struct Value { +struct Value +{ template - struct StringValue { + struct StringValue + { const Char *value; std::size_t size; }; @@ -953,12 +1050,14 @@ struct Value { typedef void(*FormatFunc)( void *formatter, const void *arg, void *format_str_ptr); - struct CustomValue { + struct CustomValue + { const void *value; FormatFunc format; }; - union { + union + { int int_value; unsigned uint_value; LongLong long_long_value; @@ -973,7 +1072,8 @@ struct Value { CustomValue custom; }; - enum Type { + enum Type + { NONE, NAMED_ARG, // Integer types should go first, INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, @@ -985,7 +1085,8 @@ struct Value { // A formatting argument. It is a POD type to allow storage in // internal::MemoryBuffer. -struct Arg : Value { +struct Arg : Value +{ Type type; }; @@ -998,13 +1099,15 @@ struct Null {}; // A helper class template to enable or disable overloads taking wide // characters and strings in MakeValue. template -struct WCharHelper { +struct WCharHelper +{ typedef Null Supported; typedef T Unsupported; }; template -struct WCharHelper { +struct WCharHelper +{ typedef T Supported; typedef Null Unsupported; }; @@ -1020,7 +1123,8 @@ No &convert(...); template T &get(); -struct DummyStream : std::ostream { +struct DummyStream : std::ostream +{ // Hide all operator<< overloads from std::ostream. void operator<<(Null<>); }; @@ -1028,33 +1132,40 @@ struct DummyStream : std::ostream { No &operator<<(std::ostream &, int); template -struct ConvertToIntImpl { +struct ConvertToIntImpl +{ enum { value = false }; }; template -struct ConvertToIntImpl { +struct ConvertToIntImpl +{ // Convert to int only if T doesn't have an overloaded operator<<. - enum { + enum + { value = sizeof(convert(get() << get())) == sizeof(No) }; }; template -struct ConvertToIntImpl2 { +struct ConvertToIntImpl2 +{ enum { value = false }; }; template -struct ConvertToIntImpl2 { - enum { +struct ConvertToIntImpl2 +{ + enum + { // Don't convert numeric types. value = ConvertToIntImpl::is_specialized>::value }; }; template -struct ConvertToInt { +struct ConvertToInt +{ enum { enable_conversion = sizeof(convert(get())) == sizeof(Yes) }; enum { value = ConvertToIntImpl2::value }; }; @@ -1072,34 +1183,40 @@ template struct EnableIf {}; template -struct EnableIf { +struct EnableIf +{ typedef T type; }; template -struct Conditional { +struct Conditional +{ typedef T type; }; template -struct Conditional { +struct Conditional +{ typedef F type; }; // For bcc32 which doesn't understand ! in template arguments. template -struct Not { +struct Not +{ enum { value = 0 }; }; template<> -struct Not { +struct Not +{ enum { value = 1 }; }; // Makes an Arg object from any type. template -class MakeValue : public Arg { +class MakeValue : public Arg +{ private: // The following two methods are private to disallow formatting of // arbitrary pointers. If you want to output a pointer cast it to @@ -1123,12 +1240,14 @@ private: MakeValue(typename WCharHelper::Unsupported); MakeValue(typename WCharHelper::Unsupported); - void set_string(StringRef str) { + void set_string(StringRef str) + { string.value = str.data(); string.size = str.size(); } - void set_string(WStringRef str) { + void set_string(WStringRef str) + { wstring.value = str.data(); wstring.size = str.size(); } @@ -1136,7 +1255,8 @@ private: // Formats an argument of a custom type, such as a user-defined class. template static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) { + void *formatter, const void *arg, void *format_str_ptr) + { format(*static_cast*>(formatter), *static_cast(format_str_ptr), *static_cast(arg)); @@ -1158,7 +1278,8 @@ public: FMT_MAKE_VALUE(int, int_value, INT) FMT_MAKE_VALUE(unsigned, uint_value, UINT) - MakeValue(long value) { + MakeValue(long value) + { // To minimize the number of types we need to deal with, long is // translated either to int or to long long depending on its size. if (check(sizeof(long) == sizeof(int))) @@ -1166,17 +1287,20 @@ public: else long_long_value = value; } - static uint64_t type(long) { + static uint64_t type(long) + { return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; } - MakeValue(unsigned long value) { + MakeValue(unsigned long value) + { if (check(sizeof(unsigned long) == sizeof(unsigned))) uint_value = static_cast(value); else ulong_long_value = value; } - static uint64_t type(unsigned long) { + static uint64_t type(unsigned long) + { return sizeof(unsigned long) == sizeof(unsigned) ? Arg::UINT : Arg::ULONG_LONG; } @@ -1191,10 +1315,12 @@ public: FMT_MAKE_VALUE(char, int_value, CHAR) #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) - MakeValue(typename WCharHelper::Supported value) { + MakeValue(typename WCharHelper::Supported value) + { int_value = value; } - static uint64_t type(wchar_t) { + static uint64_t type(wchar_t) + { return Arg::CHAR; } #endif @@ -1228,42 +1354,49 @@ public: template MakeValue(const T &value, typename EnableIf::value>::value, int>::type = 0) { + ConvertToInt::value>::value, int>::type = 0) + { custom.value = &value; custom.format = &format_custom_arg; } template MakeValue(const T &value, - typename EnableIf::value, int>::type = 0) { + typename EnableIf::value, int>::type = 0) + { int_value = value; } template - static uint64_t type(const T &) { + static uint64_t type(const T &) + { return ConvertToInt::value ? Arg::INT : Arg::CUSTOM; } // Additional template param `Char_` is needed here because make_type always // uses MakeValue. template - MakeValue(const NamedArg &value) { + MakeValue(const NamedArg &value) + { pointer = &value; } template - static uint64_t type(const NamedArg &) { + static uint64_t type(const NamedArg &) + { return Arg::NAMED_ARG; } }; template -struct NamedArg : Arg { +struct NamedArg : Arg +{ BasicStringRef name; template NamedArg(BasicStringRef argname, const T &value) - : Arg(MakeValue(value)), name(argname) { + : Arg(MakeValue(value)), name(argname) + { type = static_cast(MakeValue::type(value)); } }; @@ -1291,67 +1424,86 @@ struct NamedArg : Arg { // ArgVisitor uses the curiously recurring template pattern: // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern template -class ArgVisitor { +class ArgVisitor +{ public: void report_unhandled_arg() {} - Result visit_unhandled_arg() { + Result visit_unhandled_arg() + { FMT_DISPATCH(report_unhandled_arg()); return Result(); } - Result visit_int(int value) { + Result visit_int(int value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_long_long(LongLong value) { + Result visit_long_long(LongLong value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_uint(unsigned value) { + Result visit_uint(unsigned value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_ulong_long(ULongLong value) { + Result visit_ulong_long(ULongLong value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_bool(bool value) { + Result visit_bool(bool value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_char(int value) { + Result visit_char(int value) + { return FMT_DISPATCH(visit_any_int(value)); } template - Result visit_any_int(T) { + Result visit_any_int(T) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_double(double value) { + Result visit_double(double value) + { return FMT_DISPATCH(visit_any_double(value)); } - Result visit_long_double(long double value) { + Result visit_long_double(long double value) + { return FMT_DISPATCH(visit_any_double(value)); } template - Result visit_any_double(T) { + Result visit_any_double(T) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_cstring(const char *) { + Result visit_cstring(const char *) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_string(Arg::StringValue) { + Result visit_string(Arg::StringValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_wstring(Arg::StringValue) { + Result visit_wstring(Arg::StringValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_pointer(const void *) { + Result visit_pointer(const void *) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_custom(Arg::CustomValue) { + Result visit_custom(Arg::CustomValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit(const Arg &arg) { - switch (arg.type) { + Result visit(const Arg &arg) + { + switch (arg.type) + { default: FMT_ASSERT(false, "invalid argument type"); return Result(); @@ -1385,7 +1537,8 @@ public: } }; -class RuntimeError : public std::runtime_error { +class RuntimeError : public std::runtime_error +{ protected: RuntimeError() : std::runtime_error("") {} }; @@ -1401,12 +1554,14 @@ class ArgMap; } // namespace internal /** An argument list. */ -class ArgList { +class ArgList +{ private: // To reduce compiled code size per formatting function call, types of first // MAX_PACKED_ARGS arguments are passed in the types_ field. uint64_t types_; - union { + union + { // If the number of arguments is less than MAX_PACKED_ARGS, the argument // values are stored in values_, otherwise they are stored in args_. // This is done to reduce compiled code size as storing larger objects @@ -1416,7 +1571,8 @@ private: const internal::Arg *args_; }; - internal::Arg::Type type(unsigned index) const { + internal::Arg::Type type(unsigned index) const + { unsigned shift = index * 4; uint64_t mask = 0xf; return static_cast( @@ -1438,11 +1594,13 @@ public: : types_(types), args_(args) {} /** Returns the argument at specified index. */ - internal::Arg operator[](unsigned index) const { + internal::Arg operator[](unsigned index) const + { using internal::Arg; Arg arg; bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE; - if (index < MAX_PACKED_ARGS) { + if (index < MAX_PACKED_ARGS) + { Arg::Type arg_type = type(index); internal::Value &val = arg; if (arg_type != Arg::NONE) @@ -1450,13 +1608,15 @@ public: arg.type = arg_type; return arg; } - if (use_values) { + if (use_values) + { // The index is greater than the number of arguments that can be stored // in values, so return a "none" argument. arg.type = Arg::NONE; return arg; } - for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) { + for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) + { if (args_[i].type == Arg::NONE) return args_[i]; } @@ -1466,10 +1626,12 @@ public: struct FormatSpec; -namespace internal { +namespace internal +{ template -class ArgMap { +class ArgMap +{ private: typedef std::map, internal::Arg> MapType; typedef typename MapType::value_type Pair; @@ -1479,13 +1641,15 @@ private: public: void init(const ArgList &args); - const internal::Arg* find(const fmt::BasicStringRef &name) const { + const internal::Arg* find(const fmt::BasicStringRef &name) const + { typename MapType::const_iterator it = map_.find(name); return it != map_.end() ? &it->second : 0; } }; -class FormatterBase { +class FormatterBase +{ private: ArgList args_; int next_arg_index_; @@ -1494,11 +1658,13 @@ private: Arg do_get_arg(unsigned arg_index, const char *&error); protected: - const ArgList &args() const { + const ArgList &args() const + { return args_; } - explicit FormatterBase(const ArgList &args) { + explicit FormatterBase(const ArgList &args) + { args_ = args; next_arg_index_ = 0; } @@ -1513,7 +1679,8 @@ protected: bool check_no_auto_index(const char *&error); template - void write(BasicWriter &w, const Char *start, const Char *end) { + void write(BasicWriter &w, const Char *start, const Char *end) + { if (start != end) w << BasicStringRef(start, end - start); } @@ -1521,7 +1688,8 @@ protected: // A printf formatter. template -class PrintfFormatter : private FormatterBase { +class PrintfFormatter : private FormatterBase +{ private: void parse_flags(FormatSpec &spec, const Char *&s); @@ -1541,7 +1709,8 @@ public: // A formatter. template -class BasicFormatter : private internal::FormatterBase { +class BasicFormatter : private internal::FormatterBase +{ private: BasicWriter &writer_; internal::ArgMap map_; @@ -1564,7 +1733,8 @@ public: BasicFormatter(const ArgList &args, BasicWriter &w) : internal::FormatterBase(args), writer_(w) {} - BasicWriter &writer() { + BasicWriter &writer() + { return writer_; } @@ -1573,12 +1743,14 @@ public: const Char *format(const Char *&format_str, const internal::Arg &arg); }; -enum Alignment { +enum Alignment +{ ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC }; // Flags. -enum { +enum +{ SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. }; @@ -1588,29 +1760,37 @@ struct EmptySpec {}; // A type specifier. template -struct TypeSpec : EmptySpec { - Alignment align() const { +struct TypeSpec : EmptySpec +{ + Alignment align() const + { return ALIGN_DEFAULT; } - unsigned width() const { + unsigned width() const + { return 0; } - int precision() const { + int precision() const + { return -1; } - bool flag(unsigned) const { + bool flag(unsigned) const + { return false; } - char type() const { + char type() const + { return TYPE; } - char fill() const { + char fill() const + { return ' '; } }; // A width specifier. -struct WidthSpec { +struct WidthSpec +{ unsigned width_; // Fill is always wchar_t and cast to char if necessary to avoid having // two specialization of WidthSpec and its subclasses. @@ -1618,45 +1798,54 @@ struct WidthSpec { WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} - unsigned width() const { + unsigned width() const + { return width_; } - wchar_t fill() const { + wchar_t fill() const + { return fill_; } }; // An alignment specifier. -struct AlignSpec : WidthSpec { +struct AlignSpec : WidthSpec +{ Alignment align_; AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) : WidthSpec(width, fill), align_(align) {} - Alignment align() const { + Alignment align() const + { return align_; } - int precision() const { + int precision() const + { return -1; } }; // An alignment and type specifier. template -struct AlignTypeSpec : AlignSpec { +struct AlignTypeSpec : AlignSpec +{ AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} - bool flag(unsigned) const { + bool flag(unsigned) const + { return false; } - char type() const { + char type() const + { return TYPE; } }; // A full format specifier. -struct FormatSpec : AlignSpec { +struct FormatSpec : AlignSpec +{ unsigned flags_; int precision_; char type_; @@ -1665,20 +1854,24 @@ struct FormatSpec : AlignSpec { unsigned width = 0, char type = 0, wchar_t fill = ' ') : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} - bool flag(unsigned f) const { + bool flag(unsigned f) const + { return (flags_ & f) != 0; } - int precision() const { + int precision() const + { return precision_; } - char type() const { + char type() const + { return type_; } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT { +class IntFormatSpec : public SpecT +{ private: T value_; @@ -1686,25 +1879,29 @@ public: IntFormatSpec(T val, const SpecT &spec = SpecT()) : SpecT(spec), value_(val) {} - T value() const { + T value() const + { return value_; } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec { +class StrFormatSpec : public AlignSpec +{ private: const Char *str_; public: template StrFormatSpec(const Char *str, unsigned width, FillChar fill) - : AlignSpec(width, fill), str_(str) { + : AlignSpec(width, fill), str_(str) + { internal::CharTraits::convert(FillChar()); } - const Char *str() const { + const Char *str() const + { return str_; } }; @@ -1819,12 +2016,14 @@ std::string s = str(MemoryWriter() << pad("abc", 8)); */ template inline StrFormatSpec pad( - const Char *str, unsigned width, Char fill = ' ') { + const Char *str, unsigned width, Char fill = ' ') +{ return StrFormatSpec(str, width, fill); } inline StrFormatSpec pad( - const wchar_t *str, unsigned width, char fill = ' ') { + const wchar_t *str, unsigned width, char fill = ' ') +{ return StrFormatSpec(str, width, fill); } @@ -1847,18 +2046,22 @@ inline StrFormatSpec pad( # define FMT_GEN14(f) FMT_GEN13(f), f(13) # define FMT_GEN15(f) FMT_GEN14(f), f(14) -namespace internal { -inline uint64_t make_type() { +namespace internal +{ +inline uint64_t make_type() +{ return 0; } template -inline uint64_t make_type(const T &arg) { +inline uint64_t make_type(const T &arg) +{ return MakeValue::type(arg); } template -struct ArgArray { +struct ArgArray +{ // Computes the argument array size by adding 1 to N, which is the number of // arguments, if N is zero, because array of zero size is invalid, or if N // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra @@ -1871,27 +2074,31 @@ struct ArgArray { #if FMT_USE_VARIADIC_TEMPLATES template -inline uint64_t make_type(const Arg &first, const Args & ... tail) { +inline uint64_t make_type(const Arg &first, const Args & ... tail) +{ return make_type(first) | (make_type(tail...) << 4); } inline void do_set_types(Arg *) {} template -inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) { +inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) +{ args->type = static_cast(MakeValue::type(arg)); do_set_types(args + 1, tail...); } template -inline void set_types(Arg *array, const Args & ... args) { +inline void set_types(Arg *array, const Args & ... args) +{ if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS)) do_set_types(array, args...); array[sizeof...(Args)].type = Arg::NONE; } template -inline void set_types(Value *, const Args & ...) { +inline void set_types(Value *, const Args & ...) +{ // Do nothing as types are passed separately from values. } @@ -1899,7 +2106,8 @@ template inline void store_args(Value *) {} template -inline void store_args(Arg *args, const T &arg, const Args & ... tail) { +inline void store_args(Arg *args, const T &arg, const Args & ... tail) +{ // Assign only the Value subobject of Arg and don't overwrite type (if any) // that is assigned by set_types. Value &value = *args; @@ -1909,7 +2117,8 @@ inline void store_args(Arg *args, const T &arg, const Args & ... tail) { template ArgList make_arg_list(typename ArgArray::Type array, - const Args & ... args) { + const Args & ... args) +{ if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS)) set_types(array, args...); store_args(array, args...); @@ -1917,7 +2126,8 @@ ArgList make_arg_list(typename ArgArray::Type array, } #else -struct ArgType { +struct ArgType +{ uint64_t type; ArgType() : type(0) {} @@ -1928,7 +2138,8 @@ struct ArgType { # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() -inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) +{ return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | @@ -1937,7 +2148,8 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { #endif template -class FormatBuf : public std::basic_streambuf { +class FormatBuf : public std::basic_streambuf +{ private: typedef typename std::basic_streambuf::int_type int_type; typedef typename std::basic_streambuf::traits_type traits_type; @@ -1946,12 +2158,15 @@ private: Char *start_; public: - FormatBuf(Buffer &buffer) : buffer_(buffer), start_(&buffer[0]) { + FormatBuf(Buffer &buffer) : buffer_(buffer), start_(&buffer[0]) + { this->setp(start_, start_ + buffer_.capacity()); } - int_type overflow(int_type ch = traits_type::eof()) { - if (!traits_type::eq_int_type(ch, traits_type::eof())) { + int_type overflow(int_type ch = traits_type::eof()) + { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + { size_t size = this->pptr() - start_; buffer_.resize(size); buffer_.reserve(size * 2); @@ -1963,7 +2178,8 @@ public: return ch; } - size_t size() const { + size_t size() const + { return this->pptr() - start_; } }; @@ -2064,7 +2280,8 @@ public: An error returned by an operating system or a language runtime, for example a file opening error. */ -class SystemError : public internal::RuntimeError { +class SystemError : public internal::RuntimeError +{ private: void init(int err_code, CStringRef format_str, ArgList args); @@ -2101,12 +2318,14 @@ public: throw fmt::SystemError(errno, "cannot open file '{}'", filename); \endrst */ - SystemError(int error_code, CStringRef message) { + SystemError(int error_code, CStringRef message) + { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) - int error_code() const { + int error_code() const + { return error_code_; } }; @@ -2130,7 +2349,8 @@ You can use one of the following typedefs for common character types: \endrst */ template -class BasicWriter { +class BasicWriter +{ private: // Output buffer. Buffer &buffer_; @@ -2141,11 +2361,13 @@ private: #if FMT_SECURE_SCL // Returns pointer value. - static Char *get(CharPtr p) { + static Char *get(CharPtr p) + { return p.base(); } #else - static Char *get(Char *p) { + static Char *get(Char *p) + { return p; } #endif @@ -2157,7 +2379,8 @@ private: // Grows the buffer by n characters and returns a pointer to the newly // allocated area. - CharPtr grow_buffer(std::size_t n) { + CharPtr grow_buffer(std::size_t n) + { std::size_t size = buffer_.size(); buffer_.resize(size + n); return internal::make_ptr(&buffer_[size], n); @@ -2165,7 +2388,8 @@ private: // Writes an unsigned decimal integer. template - Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) { + Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) + { unsigned num_digits = internal::count_digits(value); Char *ptr = get(grow_buffer(prefix_size + num_digits)); internal::format_decimal(ptr + prefix_size, value, num_digits); @@ -2174,20 +2398,24 @@ private: // Writes a decimal integer. template - void write_decimal(Int value) { + void write_decimal(Int value) + { typename internal::IntTraits::MainType abs_value = value; - if (internal::is_negative(value)) { + if (internal::is_negative(value)) + { abs_value = 0 - abs_value; *write_unsigned_decimal(abs_value, 1) = '-'; } - else { + else + { write_unsigned_decimal(abs_value, 0); } } // Prepare a buffer for integer formatting. CharPtr prepare_int_buffer(unsigned num_digits, - const EmptySpec &, const char *prefix, unsigned prefix_size) { + const EmptySpec &, const char *prefix, unsigned prefix_size) + { unsigned size = prefix_size + num_digits; CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); @@ -2225,7 +2453,8 @@ private: // Appends floating-point length specifier to the format string. // The second argument is only used for overload resolution. - void append_float_length(Char *&format_ptr, long double) { + void append_float_length(Char *&format_ptr, long double) + { *format_ptr++ = 'L'; } @@ -2254,7 +2483,8 @@ public: /** Returns the total number of characters written. */ - std::size_t size() const { + std::size_t size() const + { return buffer_.size(); } @@ -2262,7 +2492,8 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const Char *data() const FMT_NOEXCEPT { + const Char *data() const FMT_NOEXCEPT + { return &buffer_[0]; } @@ -2270,7 +2501,8 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const Char *c_str() const { + const Char *c_str() const + { std::size_t size = buffer_.size(); buffer_.reserve(size + 1); buffer_[size] = '\0'; @@ -2282,7 +2514,8 @@ public: Returns the content of the output buffer as an `std::string`. \endrst */ - std::basic_string str() const { + std::basic_string str() const + { return std::basic_string(&buffer_[0], buffer_.size()); } @@ -2311,26 +2544,32 @@ public: See also :ref:`syntax`. \endrst */ - void write(BasicCStringRef format, ArgList args) { + void write(BasicCStringRef format, ArgList args) + { BasicFormatter(args, *this).format(format); } FMT_VARIADIC_VOID(write, BasicCStringRef) - BasicWriter &operator<<(int value) { + BasicWriter &operator<<(int value) + { write_decimal(value); return *this; } - BasicWriter &operator<<(unsigned value) { + BasicWriter &operator<<(unsigned value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(long value) { + BasicWriter &operator<<(long value) + { write_decimal(value); return *this; } - BasicWriter &operator<<(unsigned long value) { + BasicWriter &operator<<(unsigned long value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(LongLong value) { + BasicWriter &operator<<(LongLong value) + { write_decimal(value); return *this; } @@ -2340,11 +2579,13 @@ public: Formats *value* and writes it to the stream. \endrst */ - BasicWriter &operator<<(ULongLong value) { + BasicWriter &operator<<(ULongLong value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(double value) { + BasicWriter &operator<<(double value) + { write_double(value, FormatSpec()); return *this; } @@ -2355,7 +2596,8 @@ public: (``'g'``) and writes it to the stream. \endrst */ - BasicWriter &operator<<(long double value) { + BasicWriter &operator<<(long double value) + { write_double(value, FormatSpec()); return *this; } @@ -2363,13 +2605,15 @@ public: /** Writes a character to the stream. */ - BasicWriter &operator<<(char value) { + BasicWriter &operator<<(char value) + { buffer_.push_back(value); return *this; } BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) { + typename internal::WCharHelper::Supported value) + { buffer_.push_back(value); return *this; } @@ -2379,56 +2623,66 @@ public: Writes *value* to the stream. \endrst */ - BasicWriter &operator<<(fmt::BasicStringRef value) { + BasicWriter &operator<<(fmt::BasicStringRef value) + { const Char *str = value.data(); buffer_.append(str, str + value.size()); return *this; } BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) { + typename internal::WCharHelper::Supported value) + { const char *str = value.data(); buffer_.append(str, str + value.size()); return *this; } template - BasicWriter &operator<<(IntFormatSpec spec) { + BasicWriter &operator<<(IntFormatSpec spec) + { internal::CharTraits::convert(FillChar()); write_int(spec.value(), spec); return *this; } template - BasicWriter &operator<<(const StrFormatSpec &spec) { + BasicWriter &operator<<(const StrFormatSpec &spec) + { const StrChar *s = spec.str(); write_str(s, std::char_traits::length(s), spec); return *this; } - void clear() FMT_NOEXCEPT{ buffer_.clear(); } + void clear() FMT_NOEXCEPT { buffer_.clear(); } }; template template typename BasicWriter::CharPtr BasicWriter::write_str( - const StrChar *s, std::size_t size, const AlignSpec &spec) { + const StrChar *s, std::size_t size, const AlignSpec &spec) +{ CharPtr out = CharPtr(); - if (spec.width() > size) { + if (spec.width() > size) + { out = grow_buffer(spec.width()); Char fill = internal::CharTraits::cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) { + if (spec.align() == ALIGN_RIGHT) + { std::fill_n(out, spec.width() - size, fill); out += spec.width() - size; } - else if (spec.align() == ALIGN_CENTER) { + else if (spec.align() == ALIGN_CENTER) + { out = fill_padding(out, spec.width(), size, fill); } - else { + else + { std::fill_n(out + size, spec.width() - size, fill); } } - else { + else + { out = grow_buffer(size); } std::copy(s, s + size, out); @@ -2439,7 +2693,8 @@ template typename BasicWriter::CharPtr BasicWriter::fill_padding( CharPtr buffer, unsigned total_size, - std::size_t content_size, wchar_t fill) { + std::size_t content_size, wchar_t fill) +{ std::size_t padding = total_size - content_size; std::size_t left_padding = padding / 2; Char fill_char = internal::CharTraits::cast(fill); @@ -2455,11 +2710,13 @@ template typename BasicWriter::CharPtr BasicWriter::prepare_int_buffer( unsigned num_digits, const Spec &spec, - const char *prefix, unsigned prefix_size) { + const char *prefix, unsigned prefix_size) +{ unsigned width = spec.width(); Alignment align = spec.align(); Char fill = internal::CharTraits::cast(spec.fill()); - if (spec.precision() > static_cast(num_digits)) { + if (spec.precision() > static_cast(num_digits)) + { // Octal prefix '0' is counted as a digit, so ignore it if precision // is specified. if (prefix_size > 0 && prefix[prefix_size - 1] == '0') @@ -2470,44 +2727,53 @@ BasicWriter::prepare_int_buffer( return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); buffer_.reserve(width); unsigned fill_size = width - number_size; - if (align != ALIGN_LEFT) { + if (align != ALIGN_LEFT) + { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } CharPtr result = prepare_int_buffer( num_digits, subspec, prefix, prefix_size); - if (align == ALIGN_LEFT) { + if (align == ALIGN_LEFT) + { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } return result; } unsigned size = prefix_size + num_digits; - if (width <= size) { + if (width <= size) + { CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); return p + size - 1; } CharPtr p = grow_buffer(width); CharPtr end = p + width; - if (align == ALIGN_LEFT) { + if (align == ALIGN_LEFT) + { std::copy(prefix, prefix + prefix_size, p); p += size; std::fill(p, end, fill); } - else if (align == ALIGN_CENTER) { + else if (align == ALIGN_CENTER) + { p = fill_padding(p, width, size, fill); std::copy(prefix, prefix + prefix_size, p); p += size; } - else { - if (align == ALIGN_NUMERIC) { - if (prefix_size != 0) { + else + { + if (align == ALIGN_NUMERIC) + { + if (prefix_size != 0) + { p = std::copy(prefix, prefix + prefix_size, p); size -= prefix_size; } } - else { + else + { std::copy(prefix, prefix + prefix_size, end - size); } std::fill(p, end - size, fill); @@ -2518,23 +2784,28 @@ BasicWriter::prepare_int_buffer( template template -void BasicWriter::write_int(T value, Spec spec) { +void BasicWriter::write_int(T value, Spec spec) +{ unsigned prefix_size = 0; typedef typename internal::IntTraits::MainType UnsignedType; UnsignedType abs_value = value; char prefix[4] = ""; - if (internal::is_negative(value)) { + if (internal::is_negative(value)) + { prefix[0] = '-'; ++prefix_size; abs_value = 0 - abs_value; } - else if (spec.flag(SIGN_FLAG)) { + else if (spec.flag(SIGN_FLAG)) + { prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; ++prefix_size; } - switch (spec.type()) { + switch (spec.type()) + { case 0: - case 'd': { + case 'd': + { unsigned num_digits = internal::count_digits(abs_value); CharPtr p = prepare_int_buffer( num_digits, spec, prefix, prefix_size) + 1 - num_digits; @@ -2542,57 +2813,74 @@ void BasicWriter::write_int(T value, Spec spec) { break; } case 'x': - case 'X': { + case 'X': + { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) { + if (spec.flag(HASH_FLAG)) + { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 4) != 0); + } + while ((n >>= 4) != 0); Char *p = get(prepare_int_buffer( num_digits, spec, prefix, prefix_size)); n = abs_value; const char *digits = spec.type() == 'x' ? "0123456789abcdef" : "0123456789ABCDEF"; - do { + do + { *p-- = digits[n & 0xf]; - } while ((n >>= 4) != 0); + } + while ((n >>= 4) != 0); break; } case 'b': - case 'B': { + case 'B': + { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) { + if (spec.flag(HASH_FLAG)) + { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 1) != 0); + } + while ((n >>= 1) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do { + do + { *p-- = static_cast('0' + (n & 1)); - } while ((n >>= 1) != 0); + } + while ((n >>= 1) != 0); break; } - case 'o': { + case 'o': + { UnsignedType n = abs_value; if (spec.flag(HASH_FLAG)) prefix[prefix_size++] = '0'; unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 3) != 0); + } + while ((n >>= 3) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do { + do + { *p-- = static_cast('0' + (n & 7)); - } while ((n >>= 3) != 0); + } + while ((n >>= 3) != 0); break; } default: @@ -2605,11 +2893,13 @@ void BasicWriter::write_int(T value, Spec spec) { template template void BasicWriter::write_double( - T value, const FormatSpec &spec) { + T value, const FormatSpec &spec) +{ // Check type. char type = spec.type(); bool upper = false; - switch (type) { + switch (type) + { case 0: type = 'g'; break; @@ -2623,7 +2913,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': @@ -2637,20 +2927,24 @@ void BasicWriter::write_double( char sign = 0; // Use isnegative instead of value < 0 because the latter is always // false for NaN. - if (internal::FPUtil::isnegative(static_cast(value))) { + if (internal::FPUtil::isnegative(static_cast(value))) + { sign = '-'; value = -value; } - else if (spec.flag(SIGN_FLAG)) { + else if (spec.flag(SIGN_FLAG)) + { sign = spec.flag(PLUS_FLAG) ? '+' : ' '; } - if (internal::FPUtil::isnotanumber(value)) { + if (internal::FPUtil::isnotanumber(value)) + { // Format NaN ourselves because sprintf's output is not consistent // across platforms. std::size_t nan_size = 4; const char *nan = upper ? " NAN" : " nan"; - if (!sign) { + if (!sign) + { --nan_size; ++nan; } @@ -2660,12 +2954,14 @@ void BasicWriter::write_double( return; } - if (internal::FPUtil::isinfinity(value)) { + if (internal::FPUtil::isinfinity(value)) + { // Format infinity ourselves because sprintf's output is not consistent // across platforms. std::size_t inf_size = 4; const char *inf = upper ? " INF" : " inf"; - if (!sign) { + if (!sign) + { --inf_size; ++inf; } @@ -2677,7 +2973,8 @@ void BasicWriter::write_double( std::size_t offset = buffer_.size(); unsigned width = spec.width(); - if (sign) { + if (sign) + { buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); if (width > 0) --width; @@ -2692,16 +2989,19 @@ void BasicWriter::write_double( unsigned width_for_sprintf = width; if (spec.flag(HASH_FLAG)) *format_ptr++ = '#'; - if (spec.align() == ALIGN_CENTER) { + if (spec.align() == ALIGN_CENTER) + { width_for_sprintf = 0; } - else { + else + { if (spec.align() == ALIGN_LEFT) *format_ptr++ = '-'; if (width != 0) *format_ptr++ = '*'; } - if (spec.precision() >= 0) { + if (spec.precision() >= 0) + { *format_ptr++ = '.'; *format_ptr++ = '*'; } @@ -2712,13 +3012,15 @@ void BasicWriter::write_double( // Format using snprintf. Char fill = internal::CharTraits::cast(spec.fill()); - for (;;) { + for (;;) + { std::size_t buffer_size = buffer_.capacity() - offset; #ifdef _MSC_VER // MSVC's vsnprintf_s doesn't work with zero size, so reserve // space for at least one extra character to make the size non-zero. // Note that the buffer's capacity will increase by more than 1. - if (buffer_size == 0) { + if (buffer_size == 0) + { buffer_.reserve(offset + 1); buffer_size = buffer_.capacity() - offset; } @@ -2726,27 +3028,33 @@ void BasicWriter::write_double( Char *start = &buffer_[offset]; int n = internal::CharTraits::format_float( start, buffer_size, format, width_for_sprintf, spec.precision(), value); - if (n >= 0 && offset + n < buffer_.capacity()) { - if (sign) { + if (n >= 0 && offset + n < buffer_.capacity()) + { + if (sign) + { if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || - *start != ' ') { + *start != ' ') + { *(start - 1) = sign; sign = 0; } - else { + else + { *(start - 1) = fill; } ++n; } if (spec.align() == ALIGN_CENTER && - spec.width() > static_cast(n)) { + spec.width() > static_cast(n)) + { width = spec.width(); CharPtr p = grow_buffer(width); std::copy(p, p + n, p + (width - n) / 2); fill_padding(p, spec.width(), n, fill); return; } - if (spec.fill() != ' ' || sign) { + if (spec.fill() != ' ' || sign) + { while (*start == ' ') *start++ = fill; if (sign) @@ -2796,7 +3104,8 @@ accessed as a C string with ``out.c_str()``. \endrst */ template > -class BasicMemoryWriter : public BasicWriter { +class BasicMemoryWriter : public BasicWriter +{ private: internal::MemoryBuffer buffer_; @@ -2812,7 +3121,8 @@ public: \endrst */ BasicMemoryWriter(BasicMemoryWriter &&other) - : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) + { } /** @@ -2820,7 +3130,8 @@ public: Moves the content of the other ``BasicMemoryWriter`` object to this one. \endrst */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) + { buffer_ = std::move(other.buffer_); return *this; } @@ -2851,7 +3162,8 @@ You can use one of the following typedefs for common character types: \endrst */ template -class BasicArrayWriter : public BasicWriter { +class BasicArrayWriter : public BasicWriter +{ private: internal::FixedBuffer buffer_; @@ -2881,7 +3193,8 @@ typedef BasicArrayWriter WArrayWriter; // Formats a value. template -void format(BasicFormatter &f, const Char *&format_str, const T &value) { +void format(BasicFormatter &f, const Char *&format_str, const T &value) +{ internal::MemoryBuffer buffer; internal::FormatBuf format_buf(buffer); @@ -2902,7 +3215,8 @@ void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT; #if FMT_USE_WINDOWS_H /** A Windows error. */ -class WindowsError : public SystemError { +class WindowsError : public SystemError +{ private: void init(int error_code, CStringRef format_str, ArgList args); @@ -2935,7 +3249,8 @@ public: } \endrst */ - WindowsError(int error_code, CStringRef message) { + WindowsError(int error_code, CStringRef message) + { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) @@ -2966,13 +3281,15 @@ Formats arguments and returns the result as a string. std::string message = format("The answer is {}", 42); \endrst */ -inline std::string format(CStringRef format_str, ArgList args) { +inline std::string format(CStringRef format_str, ArgList args) +{ MemoryWriter w; w.write(format_str, args); return w.str(); } -inline std::wstring format(WCStringRef format_str, ArgList args) { +inline std::wstring format(WCStringRef format_str, ArgList args) +{ WMemoryWriter w; w.write(format_str, args); return w.str(); @@ -3001,7 +3318,8 @@ print("Elapsed time: {0:.2f} seconds", 1.23); void print(CStringRef format_str, ArgList args); template -void printf(BasicWriter &w, BasicCStringRef format, ArgList args) { +void printf(BasicWriter &w, BasicCStringRef format, ArgList args) +{ internal::PrintfFormatter(args).format(w, format); } @@ -3014,13 +3332,15 @@ Formats arguments and returns the result as a string. std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ -inline std::string sprintf(CStringRef format, ArgList args) { +inline std::string sprintf(CStringRef format, ArgList args) +{ MemoryWriter w; printf(w, format, args); return w.str(); } -inline std::wstring sprintf(WCStringRef format, ArgList args) { +inline std::wstring sprintf(WCStringRef format, ArgList args) +{ WMemoryWriter w; printf(w, format, args); return w.str(); @@ -3046,14 +3366,16 @@ Prints formatted data to ``stdout``. fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ -inline int printf(CStringRef format, ArgList args) { +inline int printf(CStringRef format, ArgList args) +{ return fprintf(stdout, format, args); } /** Fast integer formatter. */ -class FormatInt { +class FormatInt +{ private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. @@ -3062,9 +3384,11 @@ private: char *str_; // Formats value in reverse and returns the number of digits. - char *format_decimal(ULongLong value) { + char *format_decimal(ULongLong value) + { char *buffer_end = buffer_ + BUFFER_SIZE - 1; - while (value >= 100) { + while (value >= 100) + { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -3073,7 +3397,8 @@ private: *--buffer_end = internal::Data::DIGITS[index + 1]; *--buffer_end = internal::Data::DIGITS[index]; } - if (value < 10) { + if (value < 10) + { *--buffer_end = static_cast('0' + value); return buffer_end; } @@ -3083,7 +3408,8 @@ private: return buffer_end; } - void FormatSigned(LongLong value) { + void FormatSigned(LongLong value) + { ULongLong abs_value = static_cast(value); bool negative = value < 0; if (negative) @@ -3094,13 +3420,16 @@ private: } public: - explicit FormatInt(int value) { + explicit FormatInt(int value) + { FormatSigned(value); } - explicit FormatInt(long value) { + explicit FormatInt(long value) + { FormatSigned(value); } - explicit FormatInt(LongLong value) { + explicit FormatInt(LongLong value) + { FormatSigned(value); } explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} @@ -3110,7 +3439,8 @@ public: /** Returns the number of characters written to the output buffer. */ - std::size_t size() const { + std::size_t size() const + { return buffer_ - str_ + BUFFER_SIZE - 1; } @@ -3118,7 +3448,8 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const char *data() const { + const char *data() const + { return str_; } @@ -3126,7 +3457,8 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const char *c_str() const { + const char *c_str() const + { buffer_[BUFFER_SIZE - 1] = '\0'; return str_; } @@ -3136,7 +3468,8 @@ public: Returns the content of the output buffer as an ``std::string``. \endrst */ - std::string str() const { + std::string str() const + { return std::string(str_, size()); } }; @@ -3145,14 +3478,18 @@ public: // a pointer to the end of the formatted string. This function doesn't // write a terminating null character. template -inline void format_decimal(char *&buffer, T value) { +inline void format_decimal(char *&buffer, T value) +{ typename internal::IntTraits::MainType abs_value = value; - if (internal::is_negative(value)) { + if (internal::is_negative(value)) + { *buffer++ = '-'; abs_value = 0 - abs_value; } - if (abs_value < 100) { - if (abs_value < 10) { + if (abs_value < 100) + { + if (abs_value < 10) + { *buffer++ = static_cast('0' + abs_value); return; } @@ -3177,12 +3514,14 @@ print("Elapsed time: {s:.2f} seconds", arg("s", 1.23)); \endrst */ template -inline internal::NamedArg arg(StringRef name, const T &arg) { +inline internal::NamedArg arg(StringRef name, const T &arg) +{ return internal::NamedArg(name, arg); } template -inline internal::NamedArg arg(WStringRef name, const T &arg) { +inline internal::NamedArg arg(WStringRef name, const T &arg) +{ return internal::NamedArg(name, arg); } @@ -3319,7 +3658,8 @@ print("point: ({x}, {y})", FMT_CAPTURE(x, y)); #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) -namespace fmt { +namespace fmt +{ FMT_VARIADIC(std::string, format, CStringRef) FMT_VARIADIC_W(std::wstring, format, WCStringRef) FMT_VARIADIC(void, print, CStringRef) @@ -3347,33 +3687,40 @@ FMT_VARIADIC(void, print, std::ostream &, CStringRef) } // namespace fmt #if FMT_USE_USER_DEFINED_LITERALS -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ template -struct UdlFormat { +struct UdlFormat +{ const Char *str; template auto operator()(Args && ... args) const - -> decltype(format(str, std::forward(args)...)) { + -> decltype(format(str, std::forward(args)...)) + { return format(str, std::forward(args)...); } }; template -struct UdlArg { +struct UdlArg +{ const Char *str; template - NamedArg operator=(T &&value) const { - return{ str, std::forward(value) }; + NamedArg operator=(T &&value) const + { + return { str, std::forward(value) }; } }; } // namespace internal -inline namespace literals { +inline namespace literals +{ /** \rst @@ -3386,12 +3733,14 @@ std::string message = "The answer is {}"_format(42); \endrst */ inline internal::UdlFormat -operator"" _format(const char *s, std::size_t) { - return{ s }; +operator"" _format(const char *s, std::size_t) +{ + return { s }; } inline internal::UdlFormat -operator"" _format(const wchar_t *s, std::size_t) { - return{ s }; +operator"" _format(const wchar_t *s, std::size_t) +{ + return { s }; } /** @@ -3405,12 +3754,14 @@ print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); \endrst */ inline internal::UdlArg -operator"" _a(const char *s, std::size_t) { - return{ s }; +operator"" _a(const char *s, std::size_t) +{ + return { s }; } inline internal::UdlArg -operator"" _a(const wchar_t *s, std::size_t) { - return{ s }; +operator"" _a(const wchar_t *s, std::size_t) +{ + return { s }; } } // inline namespace literals diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h index d658ac03..7ecfb9f8 100644 --- a/include/spdlog/details/logger_impl.h +++ b/include/spdlog/details/logger_impl.h @@ -50,7 +50,8 @@ inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list si // ctor with single sink inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) : - logger(logger_name, { + logger(logger_name, +{ single_sink }) {} @@ -314,7 +315,8 @@ inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter) _formatter = msg_formatter; } -inline void spdlog::logger::flush() { +inline void spdlog::logger::flush() +{ for (auto& sink : _sinks) sink->flush(); } \ No newline at end of file diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index ea078876..7a0d2b0b 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -167,8 +167,8 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) #ifdef _WIN32 (void)tm; // avoid unused param warning #if _WIN32_WINNT < _WIN32_WINNT_WS08 - TIME_ZONE_INFORMATION tzinfo; - auto rv = GetTimeZoneInformation(&tzinfo); + TIME_ZONE_INFORMATION tzinfo; + auto rv = GetTimeZoneInformation(&tzinfo); #else DYNAMIC_TIME_ZONE_INFORMATION tzinfo; auto rv = GetDynamicTimeZoneInformation(&tzinfo); diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 99476921..24c53f31 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -500,7 +500,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; diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index fd8e4be9..49753f8b 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -158,7 +158,7 @@ private: throw spdlog_ex("logger with name " + logger_name + " already exists"); _loggers[logger->name()] = logger; } - registry_t(){} + registry_t() {} registry_t(const registry_t&) = delete; registry_t& operator=(const registry_t&) = delete; Mutex _mutex; diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h index 583baf53..617b3890 100644 --- a/include/spdlog/sinks/android_sink.h +++ b/include/spdlog/sinks/android_sink.h @@ -58,8 +58,8 @@ protected: const android_LogPriority priority = convert_to_android(msg.level); const int expected_size = msg.formatted.size(); const int size = __android_log_write( - priority, _tag.c_str(), msg.formatted.c_str() - ); + priority, _tag.c_str(), msg.formatted.c_str() + ); if (size > expected_size) { // Will write a little bit more than original message @@ -75,16 +75,26 @@ private: { switch(level) { - case spdlog::level::trace: return ANDROID_LOG_VERBOSE; - case spdlog::level::debug: return ANDROID_LOG_DEBUG; - case spdlog::level::info: return ANDROID_LOG_INFO; - case spdlog::level::notice: return ANDROID_LOG_INFO; - case spdlog::level::warn: return ANDROID_LOG_WARN; - case spdlog::level::err: return ANDROID_LOG_ERROR; - case spdlog::level::critical: return ANDROID_LOG_FATAL; - case spdlog::level::alert: return ANDROID_LOG_FATAL; - case spdlog::level::emerg: return ANDROID_LOG_FATAL; - default: throw spdlog_ex("Incorrect level value"); + case spdlog::level::trace: + return ANDROID_LOG_VERBOSE; + case spdlog::level::debug: + return ANDROID_LOG_DEBUG; + case spdlog::level::info: + return ANDROID_LOG_INFO; + case spdlog::level::notice: + return ANDROID_LOG_INFO; + case spdlog::level::warn: + return ANDROID_LOG_WARN; + case spdlog::level::err: + return ANDROID_LOG_ERROR; + case spdlog::level::critical: + return ANDROID_LOG_FATAL; + case spdlog::level::alert: + return ANDROID_LOG_FATAL; + case spdlog::level::emerg: + return ANDROID_LOG_FATAL; + default: + throw spdlog_ex("Incorrect level value"); } } diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 45cb8d7a..c1c3edee 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/include/spdlog/sinks/dist_sink.h @@ -69,7 +69,7 @@ public: { std::lock_guard lock(base_sink::_mutex); if (sink && - _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink)) + _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink)) { _sinks.push_back(sink); } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 6c8f2df0..37f07ee1 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -230,4 +230,4 @@ private: typedef daily_file_sink daily_file_sink_mt; typedef daily_file_sink daily_file_sink_st; } -} \ No newline at end of file +}