clang format

include/spdlog/details/pattern_formatter.h

@@ -339,9 +339,9 @@ public:
             dest.push_back('+');
         }
 
-        fmt_helper::pad2(total_minutes / 60, dest); //hours
+        fmt_helper::pad2(total_minutes / 60, dest); // hours
         dest.push_back(':');
-        fmt_helper::pad2(total_minutes % 60, dest); //minutes
+        fmt_helper::pad2(total_minutes % 60, dest); // minutes
     }
 
 private:

include/spdlog/fmt/bundled/ostream.h

@@ -14,18 +14,22 @@
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-template <class Char>
-class formatbuf : public std::basic_streambuf<Char> {
- private:
+template<class Char>
+class formatbuf : public std::basic_streambuf<Char>
+{
+private:
     typedef typename std::basic_streambuf<Char>::int_type int_type;
     typedef typename std::basic_streambuf<Char>::traits_type traits_type;
 
     basic_buffer<Char> &buffer_;
 
- public:
-  formatbuf(basic_buffer<Char> &buffer) : buffer_(buffer) {}
+public:
+    formatbuf(basic_buffer<Char> &buffer)
+        : buffer_(buffer)
+    {
+    }
 
- protected:
+protected:
     // The put-area is actually always empty. This makes the implementation
     // simpler and has the advantage that the streambuf and the buffer are always
     // in sync and sputc never writes into uninitialized memory. The obvious
@@ -33,41 +37,43 @@ class formatbuf : public std::basic_streambuf<Char> {
     // to overflow. There is no disadvantage here for sputn since this always
     // results in a call to xsputn.
 
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
+    {
         if (!traits_type::eq_int_type(ch, traits_type::eof()))
             buffer_.push_back(static_cast<Char>(ch));
         return ch;
     }
 
-  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
+    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
+    {
         buffer_.append(s, s + count);
         return count;
     }
 };
 
-template <typename Char>
-struct test_stream : std::basic_ostream<Char> {
- private:
+template<typename Char>
+struct test_stream : std::basic_ostream<Char>
+{
+private:
     struct null;
     // Hide all operator<< from std::basic_ostream<Char>.
     void operator<<(null);
 };
 
 // Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
-template <typename T, typename Char>
-class is_streamable {
- private:
-  template <typename U>
-  static decltype(
-    internal::declval<test_stream<Char>&>()
-      << internal::declval<U>(), std::true_type()) test(int);
-
-  template <typename>
+template<typename T, typename Char>
+class is_streamable
+{
+private:
+    template<typename U>
+    static decltype(internal::declval<test_stream<Char> &>() << internal::declval<U>(), std::true_type()) test(int);
+
+    template<typename>
     static std::false_type test(...);
 
     typedef decltype(test<T>(0)) result;
 
- public:
+public:
     // std::string operator<< is not considered user-defined because we handle strings
     // specially.
     static const bool value = result::value && !std::is_same<T, std::string>::value;
@@ -75,22 +81,23 @@ class is_streamable {
 
 // Disable conversion to int if T has an overloaded operator<< which is a free
 // function (not a member of std::ostream).
-template <typename T, typename Char>
-class convert_to_int<T, Char, true> {
- public:
-  static const bool value =
-    convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+template<typename T, typename Char>
+class convert_to_int<T, Char, true>
+{
+public:
+    static const bool value = convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
 };
 
 // Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
+template<typename Char>
+void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
+{
     const Char *data = buf.data();
     typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
     UnsignedStreamSize size = buf.size();
-  UnsignedStreamSize max_size =
-      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
+    UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
+    do
+    {
         UnsignedStreamSize n = size <= max_size ? size : max_size;
         os.write(data, static_cast<std::streamsize>(n));
         data += n;
@@ -98,8 +105,9 @@ void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
     } while (size != 0);
 }
 
-template <typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value) {
+template<typename Char, typename T>
+void format_value(basic_buffer<Char> &buffer, const T &value)
+{
     internal::formatbuf<Char> format_buf(buffer);
     std::basic_ostream<Char> output(&format_buf);
     output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
@@ -108,19 +116,20 @@ void format_value(basic_buffer<Char> &buffer, const T &value) {
 }
 
 // Disable builtin formatting of enums and use operator<< instead.
-template <typename T>
-struct format_enum<T,
-    typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type {};
+template<typename T>
+struct format_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type
+{
+};
 } // namespace internal
 
 // Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct formatter<T, Char,
-    typename std::enable_if<internal::is_streamable<T, Char>::value>::type>
-    : formatter<basic_string_view<Char>, Char> {
+template<typename T, typename Char>
+struct formatter<T, Char, typename std::enable_if<internal::is_streamable<T, Char>::value>::type> : formatter<basic_string_view<Char>, Char>
+{
 
-  template <typename Context>
-  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
+    template<typename Context>
+    auto format(const T &value, Context &ctx) -> decltype(ctx.out())
+    {
         basic_memory_buffer<Char> buffer;
         internal::format_value(buffer, value);
         basic_string_view<Char> str(buffer.data(), buffer.size());
@@ -129,10 +138,10 @@ struct formatter<T, Char,
     }
 };
 
-template <typename Char>
-inline void vprint(std::basic_ostream<Char> &os,
-                   basic_string_view<Char> format_str,
-                   basic_format_args<typename buffer_context<Char>::type> args) {
+template<typename Char>
+inline void vprint(
+    std::basic_ostream<Char> &os, basic_string_view<Char> format_str, basic_format_args<typename buffer_context<Char>::type> args)
+{
     basic_memory_buffer<Char> buffer;
     vformat_to(buffer, format_str, args);
     internal::write(os, buffer);
@@ -146,15 +155,15 @@ inline void vprint(std::basic_ostream<Char> &os,
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-template <typename... Args>
-inline void print(std::ostream &os, string_view format_str,
-                  const Args & ... args) {
+template<typename... Args>
+inline void print(std::ostream &os, string_view format_str, const Args &... args)
+{
     vprint<char>(os, format_str, make_format_args<format_context>(args...));
 }
 
-template <typename... Args>
-inline void print(std::wostream &os, wstring_view format_str,
-                  const Args & ... args) {
+template<typename... Args>
+inline void print(std::wostream &os, wstring_view format_str, const Args &... args)
+{
     vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
 }
 FMT_END_NAMESPACE

include/spdlog/fmt/bundled/time.h

@@ -13,39 +13,66 @@
 
 FMT_BEGIN_NAMESPACE
 
-namespace internal{
-inline null<> localtime_r(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
+namespace internal {
+inline null<> localtime_r(...)
+{
+    return null<>();
+}
+inline null<> localtime_s(...)
+{
+    return null<>();
+}
+inline null<> gmtime_r(...)
+{
+    return null<>();
+}
+inline null<> gmtime_s(...)
+{
+    return null<>();
 }
+} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm localtime(std::time_t time)
+{
+    struct dispatcher
+    {
         std::time_t time_;
         std::tm tm_;
 
-    dispatcher(std::time_t t): time_(t) {}
+        dispatcher(std::time_t t)
+            : time_(t)
+        {
+        }
 
-    bool run() {
+        bool run()
+        {
             using namespace fmt::internal;
             return handle(localtime_r(&time_, &tm_));
         }
 
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+        bool handle(std::tm *tm)
+        {
+            return tm != FMT_NULL;
+        }
 
-    bool handle(internal::null<>) {
+        bool handle(internal::null<>)
+        {
             using namespace fmt::internal;
             return fallback(localtime_s(&tm_, &time_));
         }
 
-    bool fallback(int res) { return res == 0; }
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
 
-    bool fallback(internal::null<>) {
+        bool fallback(internal::null<>)
+        {
             using namespace fmt::internal;
             std::tm *tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
+            if (tm)
+                tm_ = *tm;
             return tm != FMT_NULL;
         }
     };
@@ -57,30 +84,45 @@ inline std::tm localtime(std::time_t time) {
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct dispatcher {
+inline std::tm gmtime(std::time_t time)
+{
+    struct dispatcher
+    {
         std::time_t time_;
         std::tm tm_;
 
-    dispatcher(std::time_t t): time_(t) {}
+        dispatcher(std::time_t t)
+            : time_(t)
+        {
+        }
 
-    bool run() {
+        bool run()
+        {
             using namespace fmt::internal;
             return handle(gmtime_r(&time_, &tm_));
         }
 
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+        bool handle(std::tm *tm)
+        {
+            return tm != FMT_NULL;
+        }
 
-    bool handle(internal::null<>) {
+        bool handle(internal::null<>)
+        {
             using namespace fmt::internal;
             return fallback(gmtime_s(&tm_, &time_));
         }
 
-    bool fallback(int res) { return res == 0; }
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
 
-    bool fallback(internal::null<>) {
+        bool fallback(internal::null<>)
+        {
             std::tm *tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
+            if (tm)
+                tm_ = *tm;
             return tm != FMT_NULL;
         }
     };
@@ -92,21 +134,23 @@ inline std::tm gmtime(std::time_t time) {
 }
 
 namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format,
-                            const std::tm *time) {
+inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
+{
     return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t *str, std::size_t count,
-                            const wchar_t *format, const std::tm *time) {
+inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time)
+{
     return std::wcsftime(str, count, format, time);
 }
-}
-
-template <typename Char>
-struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+} // namespace internal
+
+template<typename Char>
+struct formatter<std::tm, Char>
+{
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
         auto it = internal::null_terminating_iterator<Char>(ctx);
         if (*it == ':')
             ++it;
@@ -120,19 +164,22 @@ struct formatter<std::tm, Char> {
         return pointer_from(end);
     }
 
-  template <typename FormatContext>
-  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
+    template<typename FormatContext>
+    auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
+    {
         internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
         std::size_t start = buf.size();
-    for (;;) {
+        for (;;)
+        {
             std::size_t size = buf.capacity() - start;
-      std::size_t count =
-        internal::strftime(&buf[start], size, &tm_format[0], &tm);
-      if (count != 0) {
+            std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
+            if (count != 0)
+            {
                 buf.resize(start + count);
                 break;
             }
-      if (size >= tm_format.size() * 256) {
+            if (size >= tm_format.size() * 256)
+            {
                 // If the buffer is 256 times larger than the format string, assume
                 // that `strftime` gives an empty result. There doesn't seem to be a
                 // better way to distinguish the two cases:

include/spdlog/sinks/sink.h

@@ -20,7 +20,6 @@ public:
     {
     }
 
-
     virtual ~sink() = default;
 
     virtual void log(const details::log_msg &msg) = 0;