astyle

include/spdlog/async_logger.h

@@ -64,9 +64,9 @@ public:
     //Warning: this can potentialy last forever as we wait it to complete
     void flush() override;
 
-	// Error handler
-	virtual void set_error_handler(log_err_handler) override;
-	virtual log_err_handler error_handler() override;
+    // Error handler
+    virtual void set_error_handler(log_err_handler) override;
+    virtual log_err_handler error_handler() override;
 
 protected:
     void _sink_it(details::log_msg& msg) override;

include/spdlog/details/async_logger_impl.h

@@ -60,13 +60,13 @@ inline void spdlog::async_logger::flush()
 // Error handler
 inline void spdlog::async_logger::set_error_handler(spdlog::log_err_handler err_handler)
 {
-	_err_handler = err_handler;
-	_async_log_helper->set_error_handler(err_handler);
-	
+    _err_handler = err_handler;
+    _async_log_helper->set_error_handler(err_handler);
+
 }
 inline spdlog::log_err_handler spdlog::async_logger::error_handler()
 {
-	return _err_handler;
+    return _err_handler;
 }
 
 

include/spdlog/fmt/bundled/ostream.h

@@ -13,74 +13,85 @@
 #include "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)
+    };
 };
 }  // namespace internal
 
 // Formats a value.
 template <typename Char, typename ArgFormatter, typename T>
 void format(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/fmt/bundled/time.h

@@ -13,40 +13,45 @@
 #include "format.h"
 #include <ctime>
 
-namespace fmt {
+namespace fmt
+{
 template <typename ArgFormatter>
 void format(BasicFormatter<char, ArgFormatter> &f,
-            const char *&format_str, const std::tm &tm) {
-  if (*format_str == ':')
-    ++format_str;
-  const char *end = format_str;
-  while (*end && *end != '}')
-    ++end;
-  if (*end != '}')
-    FMT_THROW(FormatError("missing '}' in format string"));
-  internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
-  format.append(format_str, end + 1);
-  format[format.size() - 1] = '\0';
-  Buffer<char> &buffer = f.writer().buffer();
-  std::size_t start = buffer.size();
-  for (;;) {
-    std::size_t size = buffer.capacity() - start;
-    std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
-    if (count != 0) {
-      buffer.resize(start + count);
-      break;
+            const char *&format_str, const std::tm &tm)
+{
+    if (*format_str == ':')
+        ++format_str;
+    const char *end = format_str;
+    while (*end && *end != '}')
+        ++end;
+    if (*end != '}')
+        FMT_THROW(FormatError("missing '}' in format string"));
+    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
+    format.append(format_str, end + 1);
+    format[format.size() - 1] = '\0';
+    Buffer<char> &buffer = f.writer().buffer();
+    std::size_t start = buffer.size();
+    for (;;)
+    {
+        std::size_t size = buffer.capacity() - start;
+        std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
+        if (count != 0)
+        {
+            buffer.resize(start + count);
+            break;
+        }
+        if (size >= 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:
+            // https://github.com/fmtlib/fmt/issues/367
+            break;
+        }
+        const std::size_t MIN_GROWTH = 10;
+        buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
-    if (size >= 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:
-      // https://github.com/fmtlib/fmt/issues/367
-      break;
-    }
-    const std::size_t MIN_GROWTH = 10;
-    buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-  }
-  format_str = end + 1;
+    format_str = end + 1;
 }
 }
 

include/spdlog/logger.h

@@ -58,7 +58,7 @@ public:
     const std::string& name() const;
     void set_pattern(const std::string&);
     void set_formatter(formatter_ptr);
-   
+
     // automatically call flush() if message level >= log_level
     void flush_on(level::level_enum log_level);
 
@@ -66,9 +66,9 @@ public:
 
     const std::vector<sink_ptr>& sinks() const;
 
-	// error handler
-	virtual void set_error_handler(log_err_handler);
-	virtual log_err_handler error_handler();
+    // error handler
+    virtual void set_error_handler(log_err_handler);
+    virtual log_err_handler error_handler();
 
 protected:
     virtual void _sink_it(details::log_msg&);

tests/errors.cpp

@@ -8,30 +8,30 @@
 
 
 
-class failing_sink: public spdlog::sinks::sink
-{
-	void log(const spdlog::details::log_msg& msg) override
-	{
-		throw std::runtime_error("some error happened during log");
-	}
-
-	void flush()
-	{}
+class failing_sink: public spdlog::sinks::sink
+{
+    void log(const spdlog::details::log_msg& msg) override
+    {
+        throw std::runtime_error("some error happened during log");
+    }
+
+    void flush()
+    {}
 };
 
 TEST_CASE("default_error_handler", "[errors]]")
 {
-	prepare_logdir();
-	std::string filename = "logs/simple_log.txt";
+    prepare_logdir();
+    std::string filename = "logs/simple_log.txt";
 
-	auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
-	logger->set_pattern("%v");
-	logger->info("Test message {} {}", 1);
-	logger->info("Test message {}", 2);
-	logger->flush();
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+    logger->set_pattern("%v");
+    logger->info("Test message {} {}", 1);
+    logger->info("Test message {}", 2);
+    logger->flush();
 
-	REQUIRE(file_contents(filename) == std::string("Test message 2\n"));
-	REQUIRE(count_lines(filename) == 1);
+    REQUIRE(file_contents(filename) == std::string("Test message 2\n"));
+    REQUIRE(count_lines(filename) == 1);
 }
 
 
@@ -41,69 +41,73 @@ struct custom_ex
 {};
 TEST_CASE("custom_error_handler", "[errors]]")
 {
-	prepare_logdir();
-	std::string filename = "logs/simple_log.txt";
-	auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
-	logger->flush_on(spdlog::level::info);
-	logger->set_error_handler([=](const std::string& msg) {
-		throw custom_ex();
-	});
-	logger->info("Good message #1");
-	REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex);
-	logger->info("Good message #2");
-	REQUIRE(count_lines(filename) == 2);
+    prepare_logdir();
+    std::string filename = "logs/simple_log.txt";
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+    logger->flush_on(spdlog::level::info);
+    logger->set_error_handler([=](const std::string& msg)
+    {
+        throw custom_ex();
+    });
+    logger->info("Good message #1");
+    REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex);
+    logger->info("Good message #2");
+    REQUIRE(count_lines(filename) == 2);
 }
 
 TEST_CASE("default_error_handler2", "[errors]]")
 {
 
-	auto logger = spdlog::create<failing_sink>("failed_logger");
-	logger->set_error_handler([=](const std::string& msg) {
-		throw custom_ex();
-	});
-	REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
+    auto logger = spdlog::create<failing_sink>("failed_logger");
+    logger->set_error_handler([=](const std::string& msg)
+    {
+        throw custom_ex();
+    });
+    REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
 }
 
 TEST_CASE("async_error_handler", "[errors]]")
 {
-	prepare_logdir();
-	std::string err_msg("log failed with some msg");
-	spdlog::set_async_mode(128);
-	std::string filename = "logs/simple_async_log.txt";
-	{
-		auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
-		logger->set_error_handler([=](const std::string& msg) {
-			std::ofstream ofs("logs/custom_err.txt");
-			if (!ofs) throw std::runtime_error("Failed open logs/custom_err.txt");
-			ofs << err_msg;
-		});
-		logger->info("Good message #1");
-		logger->info("Bad format msg {} {}", "xxx");
-		logger->info("Good message #2");
-		spdlog::drop("logger"); //force logger to drain the queue and shutdown
-		spdlog::set_sync_mode();
-	}
-	REQUIRE(count_lines(filename) == 2);
-	REQUIRE(file_contents("logs/custom_err.txt") == err_msg);
+    prepare_logdir();
+    std::string err_msg("log failed with some msg");
+    spdlog::set_async_mode(128);
+    std::string filename = "logs/simple_async_log.txt";
+    {
+        auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+        logger->set_error_handler([=](const std::string& msg)
+        {
+            std::ofstream ofs("logs/custom_err.txt");
+            if (!ofs) throw std::runtime_error("Failed open logs/custom_err.txt");
+            ofs << err_msg;
+        });
+        logger->info("Good message #1");
+        logger->info("Bad format msg {} {}", "xxx");
+        logger->info("Good message #2");
+        spdlog::drop("logger"); //force logger to drain the queue and shutdown
+        spdlog::set_sync_mode();
+    }
+    REQUIRE(count_lines(filename) == 2);
+    REQUIRE(file_contents("logs/custom_err.txt") == err_msg);
 }
 
 // Make sure async error handler is executed
 TEST_CASE("async_error_handler2", "[errors]]")
 {
-	prepare_logdir();
-	std::string err_msg("This is async handler error message");
-	spdlog::set_async_mode(128);
-	{
-		auto logger = spdlog::create<failing_sink>("failed_logger");
-		logger->set_error_handler([=](const std::string& msg) {
-			std::ofstream ofs("logs/custom_err2.txt");
-			if (!ofs) throw std::runtime_error("Failed open logs/custom_err2.txt");
-			ofs << err_msg;
-		});
-		logger->info("Hello failure");
-		spdlog::drop("failed_logger"); //force logger to drain the queue and shutdown
-		spdlog::set_sync_mode();
-	}
-
-	REQUIRE(file_contents("logs/custom_err2.txt") == err_msg);
+    prepare_logdir();
+    std::string err_msg("This is async handler error message");
+    spdlog::set_async_mode(128);
+    {
+        auto logger = spdlog::create<failing_sink>("failed_logger");
+        logger->set_error_handler([=](const std::string& msg)
+        {
+            std::ofstream ofs("logs/custom_err2.txt");
+            if (!ofs) throw std::runtime_error("Failed open logs/custom_err2.txt");
+            ofs << err_msg;
+        });
+        logger->info("Hello failure");
+        spdlog::drop("failed_logger"); //force logger to drain the queue and shutdown
+        spdlog::set_sync_mode();
+    }
+
+    REQUIRE(file_contents("logs/custom_err2.txt") == err_msg);
 }

tests/utils.cpp

@@ -3,15 +3,15 @@
 
 void prepare_logdir()
 {
-    spdlog::drop_all();    
+    spdlog::drop_all();
 #ifdef _WIN32
-	system("if not exist logs mkdir logs");
+    system("if not exist logs mkdir logs");
     system("del /F /Q logs\\*");
 #else
-	auto rv = system("mkdir -p logs");
+    auto rv = system("mkdir -p logs");
     rv = system("rm -f logs/*");
     (void)rv;
-#endif    
+#endif
 }