astyle

include/spdlog/details/async_log_helper.h

@@ -253,7 +253,7 @@ inline void spdlog::details::async_log_helper::push_msg(details::async_log_helpe
 inline void spdlog::details::async_log_helper::flush(bool wait_for_q)
 {
     push_msg(async_msg(async_msg_type::flush));
-    if(wait_for_q) 
+    if(wait_for_q)
         wait_empty_q(); //return only make after the above flush message was processed
 }
 
@@ -303,8 +303,10 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
             log_msg incoming_log_msg;
             incoming_async_msg.fill_log_msg(incoming_log_msg);
             _formatter->format(incoming_log_msg);
-            for (auto &s : _sinks){
-                if(s->should_log( incoming_log_msg.level)){
+            for (auto &s : _sinks)
+            {
+                if(s->should_log( incoming_log_msg.level))
+                {
                     s->log(incoming_log_msg);
                 }
             }

include/spdlog/details/logger_impl.h

@@ -245,8 +245,10 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
 inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
     _formatter->format(msg);
-    for (auto &sink : _sinks){
-        if( sink->should_log( msg.level)){
+    for (auto &sink : _sinks)
+    {
+        if( sink->should_log( msg.level))
+        {
             sink->log(msg);
         }
     }

include/spdlog/details/spdlog_impl.h

@@ -108,7 +108,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string&
 #if defined(__ANDROID__)
 inline std::shared_ptr<spdlog::logger> spdlog::android_logger(const std::string& logger_name, const std::string& tag)
 {
-  return create<spdlog::sinks::android_sink>(logger_name, tag);
+    return create<spdlog::sinks::android_sink>(logger_name, tag);
 }
 #endif
 

include/spdlog/fmt/bundled/ostream.h

@@ -14,58 +14,68 @@
 // #include "fmt/format.h"
 #include <ostream>
 
-namespace fmt {
+namespace fmt
+{
 
-namespace internal {
+namespace internal
+{
 
 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;
-
-  Buffer<Char> &buffer_;
-  Char *start_;
-
- public:
-  FormatBuf(Buffer<Char> &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())) {
-      size_t buf_size = size();
-      buffer_.resize(buf_size);
-      buffer_.reserve(buf_size * 2);
-
-      start_ = &buffer_[0];
-      start_[buf_size] = traits_type::to_char_type(ch);
-      this->setp(start_+ buf_size + 1, start_ + buf_size * 2);
+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;
+
+    Buffer<Char> &buffer_;
+    Char *start_;
+
+public:
+    FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0])
+    {
+        this->setp(start_, start_ + buffer_.capacity());
     }
-    return ch;
-  }
 
-  size_t size() const {
-    return to_unsigned(this->pptr() - start_);
-  }
+    int_type overflow(int_type ch = traits_type::eof())
+    {
+        if (!traits_type::eq_int_type(ch, traits_type::eof()))
+        {
+            size_t buf_size = size();
+            buffer_.resize(buf_size);
+            buffer_.reserve(buf_size * 2);
+
+            start_ = &buffer_[0];
+            start_[buf_size] = traits_type::to_char_type(ch);
+            this->setp(start_+ buf_size + 1, start_ + buf_size * 2);
+        }
+        return ch;
+    }
+
+    size_t size() const
+    {
+        return to_unsigned(this->pptr() - start_);
+    }
 };
 
 Yes &convert(std::ostream &);
 
-struct DummyStream : std::ostream {
-  DummyStream();  // Suppress a bogus warning in MSVC.
-  // Hide all operator<< overloads from std::ostream.
-  void operator<<(Null<>);
+struct DummyStream : std::ostream
+{
+    DummyStream();  // Suppress a bogus warning in MSVC.
+    // Hide all operator<< overloads from std::ostream.
+    void operator<<(Null<>);
 };
 
 No &operator<<(std::ostream &, int);
 
 template<typename T>
-struct ConvertToIntImpl<T, true> {
-  // Convert to int only if T doesn't have an overloaded operator<<.
-  enum {
-    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-  };
+struct ConvertToIntImpl<T, true>
+{
+    // Convert to int only if T doesn't have an overloaded operator<<.
+    enum
+    {
+        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
+    };
 };
 
 // Write the content of w to os.
@@ -75,16 +85,17 @@ void write(std::ostream &os, Writer &w);
 // Formats a value.
 template <typename Char, typename ArgFormatter, typename T>
 void format_arg(BasicFormatter<Char, ArgFormatter> &f,
-                const Char *&format_str, const T &value) {
-  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
+                const Char *&format_str, const T &value)
+{
+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
 
-  internal::FormatBuf<Char> format_buf(buffer);
-  std::basic_ostream<Char> output(&format_buf);
-  output << value;
+    internal::FormatBuf<Char> format_buf(buffer);
+    std::basic_ostream<Char> output(&format_buf);
+    output << value;
 
-  BasicStringRef<Char> str(&buffer[0], format_buf.size());
-  typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
-  format_str = f.format(format_str, MakeArg(str));
+    BasicStringRef<Char> str(&buffer[0], format_buf.size());
+    typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
+    format_str = f.format(format_str, MakeArg(str));
 }
 
 /**

include/spdlog/sinks/android_sink.h

@@ -32,10 +32,11 @@ public:
         const android_LogPriority priority = convert_to_android(msg.level);
         // See system/core/liblog/logger_write.c for explanation of return value
         const int ret = __android_log_write(
-                             priority, _tag.c_str(), msg.formatted.c_str()
-                         );
-        if (ret < 0) {
-          throw spdlog_ex("__android_log_write() failed", ret);
+                            priority, _tag.c_str(), msg.formatted.c_str()
+                        );
+        if (ret < 0)
+        {
+            throw spdlog_ex("__android_log_write() failed", ret);
         }
     }
 

include/spdlog/sinks/dist_sink.h

@@ -35,8 +35,10 @@ protected:
 
     void _sink_it(const details::log_msg& msg) override
     {
-        for (auto &sink : _sinks){
-            if( sink->should_log( msg.level)){
+        for (auto &sink : _sinks)
+        {
+            if( sink->should_log( msg.level))
+            {
                 sink->log(msg);
             }
         }

include/spdlog/sinks/sink.h

@@ -30,15 +30,18 @@ private:
 
 };
 
-inline bool sink::should_log(level::level_enum msg_level) const {
+inline bool sink::should_log(level::level_enum msg_level) const
+{
     return msg_level >= _level.load(std::memory_order_relaxed);
 }
 
-inline void sink::set_level(level::level_enum log_level) {
+inline void sink::set_level(level::level_enum log_level)
+{
     _level.store(log_level);
 }
 
-inline level::level_enum sink::level() const {
+inline level::level_enum sink::level() const
+{
     return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
 }
 

include/spdlog/spdlog.h

@@ -20,7 +20,7 @@
 namespace spdlog
 {
 
-// 
+//
 // Return an existing logger or nullptr if a logger with such name doesn't exist.
 // example: spdlog::get("my_logger")->info("hello {}", "world");
 //
@@ -67,7 +67,7 @@ void set_sync_mode();
 
 
 //
-// Create and register multi/single threaded basic file logger. 
+// Create and register multi/single threaded basic file logger.
 // Basic logger simply writes to given file without any limitatons or rotations.
 //
 std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false);