astyle

include/spdlog/details/async_log_helper.h

@@ -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/fmt/bundled/ostream.h

@@ -14,26 +14,32 @@
 // #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:
+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]) {
+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())) {
+    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);
@@ -45,14 +51,16 @@ class FormatBuf : public std::basic_streambuf<Char> {
         return ch;
     }
 
-  size_t size() const {
+    size_t size() const
+    {
         return to_unsigned(this->pptr() - start_);
     }
 };
 
 Yes &convert(std::ostream &);
 
-struct DummyStream : std::ostream {
+struct DummyStream : std::ostream
+{
     DummyStream();  // Suppress a bogus warning in MSVC.
     // Hide all operator<< overloads from std::ostream.
     void operator<<(Null<>);
@@ -61,9 +69,11 @@ struct DummyStream : std::ostream {
 No &operator<<(std::ostream &, int);
 
 template<typename T>
-struct ConvertToIntImpl<T, true> {
+struct ConvertToIntImpl<T, true>
+{
     // Convert to int only if T doesn't have an overloaded operator<<.
-  enum {
+    enum
+    {
         value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
     };
 };
@@ -75,7 +85,8 @@ 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) {
+                const Char *&format_str, const T &value)
+{
     internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
 
     internal::FormatBuf<Char> format_buf(buffer);

include/spdlog/sinks/android_sink.h

@@ -34,7 +34,8 @@ public:
         const int ret = __android_log_write(
                             priority, _tag.c_str(), msg.formatted.c_str()
                         );
-        if (ret < 0) {
+        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));
 }