Clang format

src/details/file_helper.cpp

@@ -13,16 +13,16 @@
 namespace spdlog {
 namespace details {
 
- file_helper::file_helper(const file_event_handlers &event_handlers)
+file_helper::file_helper(const file_event_handlers &event_handlers)
     : event_handlers_(event_handlers)
 {}
 
- file_helper::~file_helper()
+file_helper::~file_helper()
 {
     close();
 }
 
- void file_helper::open(const filename_t &fname, bool truncate)
+void file_helper::open(const filename_t &fname, bool truncate)
 {
     close();
     filename_ = fname;
@@ -66,7 +66,7 @@ namespace details {
     throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
 }
 
- void file_helper::reopen(bool truncate)
+void file_helper::reopen(bool truncate)
 {
     if (filename_.empty())
     {
@@ -75,7 +75,7 @@ namespace details {
     this->open(filename_, truncate);
 }
 
- void file_helper::flush()
+void file_helper::flush()
 {
     if (std::fflush(fd_) != 0)
     {
@@ -83,7 +83,7 @@ namespace details {
     }
 }
 
- void file_helper::sync()
+void file_helper::sync()
 {
     if (!os::fsync(fd_))
     {
@@ -91,7 +91,7 @@ namespace details {
     }
 }
 
- void file_helper::close()
+void file_helper::close()
 {
     if (fd_ != nullptr)
     {
@@ -110,7 +110,7 @@ namespace details {
     }
 }
 
- void file_helper::write(const memory_buf_t &buf)
+void file_helper::write(const memory_buf_t &buf)
 {
     size_t msg_size = buf.size();
     auto data = buf.data();
@@ -120,7 +120,7 @@ namespace details {
     }
 }
 
- size_t file_helper::size() const
+size_t file_helper::size() const
 {
     if (fd_ == nullptr)
     {
@@ -129,7 +129,7 @@ namespace details {
     return os::filesize(fd_);
 }
 
- const filename_t &file_helper::filename() const
+const filename_t &file_helper::filename() const
 {
     return filename_;
 }
@@ -147,7 +147,7 @@ namespace details {
 // ".mylog" => (".mylog". "")
 // "my_folder/.mylog" => ("my_folder/.mylog", "")
 // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
- std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
 {
     auto ext_index = fname.rfind('.');
 

src/details/log_msg.cpp

@@ -7,8 +7,8 @@
 namespace spdlog {
 namespace details {
 
- log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
-    spdlog::level lvl, spdlog::string_view_t msg)
+log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl,
+    spdlog::string_view_t msg)
     : logger_name(a_logger_name)
     , log_level(lvl)
     , time(log_time)
@@ -19,12 +19,11 @@ namespace details {
     , payload(msg)
 {}
 
- log_msg::log_msg(
-    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
+log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
     : log_msg(os::now(), loc, a_logger_name, lvl, msg)
 {}
 
- log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
+log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
     : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
 {}
 

src/details/log_msg_buffer.cpp

@@ -6,7 +6,7 @@
 namespace spdlog {
 namespace details {
 
- log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
+log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
     : log_msg{orig_msg}
 {
     buffer.append(logger_name.begin(), logger_name.end());
@@ -14,7 +14,7 @@ namespace details {
     update_string_views();
 }
 
- log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
+log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
     : log_msg{other}
 {
     buffer.append(logger_name.begin(), logger_name.end());
@@ -22,14 +22,14 @@ namespace details {
     update_string_views();
 }
 
- log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept
+log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept
     : log_msg{other}
     , buffer{std::move(other.buffer)}
 {
     update_string_views();
 }
 
- log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
 {
     log_msg::operator=(other);
     buffer.clear();
@@ -38,7 +38,7 @@ namespace details {
     return *this;
 }
 
- log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept
+log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept
 {
     log_msg::operator=(other);
     buffer = std::move(other.buffer);
@@ -46,7 +46,7 @@ namespace details {
     return *this;
 }
 
- void log_msg_buffer::update_string_views()
+void log_msg_buffer::update_string_views()
 {
     logger_name = string_view_t{buffer.data(), logger_name.size()};
     payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};

src/details/os.cpp

@@ -68,7 +68,7 @@ namespace spdlog {
 namespace details {
 namespace os {
 
- spdlog::log_clock::time_point now() noexcept
+spdlog::log_clock::time_point now() noexcept
 {
 
 #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
@@ -81,7 +81,7 @@ namespace os {
     return log_clock::now();
 #endif
 }
- std::tm localtime(const std::time_t &time_tt) noexcept
+std::tm localtime(const std::time_t &time_tt) noexcept
 {
 
 #ifdef _WIN32
@@ -94,13 +94,13 @@ namespace os {
     return tm;
 }
 
- std::tm localtime() noexcept
+std::tm localtime() noexcept
 {
     std::time_t now_t = ::time(nullptr);
     return localtime(now_t);
 }
 
- std::tm gmtime(const std::time_t &time_tt) noexcept
+std::tm gmtime(const std::time_t &time_tt) noexcept
 {
 
 #ifdef _WIN32
@@ -113,14 +113,14 @@ namespace os {
     return tm;
 }
 
- std::tm gmtime() noexcept
+std::tm gmtime() noexcept
 {
     std::time_t now_t = ::time(nullptr);
     return gmtime(now_t);
 }
 
 // fopen_s on non windows for writing
- bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
 {
 #ifdef _WIN32
 #    ifdef SPDLOG_WCHAR_FILENAMES
@@ -160,7 +160,7 @@ namespace os {
     return *fp == nullptr;
 }
 
- int remove(const filename_t &filename) noexcept
+int remove(const filename_t &filename) noexcept
 {
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
     return ::_wremove(filename.c_str());
@@ -169,12 +169,12 @@ namespace os {
 #endif
 }
 
- int remove_if_exists(const filename_t &filename) noexcept
+int remove_if_exists(const filename_t &filename) noexcept
 {
     return path_exists(filename) ? remove(filename) : 0;
 }
 
- int rename(const filename_t &filename1, const filename_t &filename2) noexcept
+int rename(const filename_t &filename1, const filename_t &filename2) noexcept
 {
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
     return ::_wrename(filename1.c_str(), filename2.c_str());
@@ -184,7 +184,7 @@ namespace os {
 }
 
 // Return true if path exists (file or directory)
- bool path_exists(const filename_t &filename) noexcept
+bool path_exists(const filename_t &filename) noexcept
 {
 #ifdef _WIN32
 #    ifdef SPDLOG_WCHAR_FILENAMES
@@ -206,7 +206,7 @@ namespace os {
 #endif
 
 // Return file size according to open FILE* object
- size_t filesize(FILE *f)
+size_t filesize(FILE *f)
 {
     if (f == nullptr)
     {
@@ -260,7 +260,7 @@ namespace os {
 #endif
 
 // Return utc offset in minutes or throw spdlog_ex on failure
- int utc_minutes_offset(const std::tm &tm)
+int utc_minutes_offset(const std::tm &tm)
 {
 
 #ifdef _WIN32
@@ -328,7 +328,7 @@ namespace os {
 // Return current thread id as size_t
 // It exists because the std::this_thread::get_id() is much slower(especially
 // under VS 2013)
- size_t _thread_id() noexcept
+size_t _thread_id() noexcept
 {
 #ifdef _WIN32
     return static_cast<size_t>(::GetCurrentThreadId());
@@ -377,7 +377,7 @@ namespace os {
 }
 
 // Return current thread id as size_t (from thread local storage)
- size_t thread_id() noexcept
+size_t thread_id() noexcept
 {
     // cache thread id in tls
     static thread_local const size_t tid = _thread_id();
@@ -386,7 +386,7 @@ namespace os {
 
 // This is avoid msvc issue in sleep_for that happens if the clock changes.
 // See https://github.com/gabime/spdlog/issues/609
- void sleep_for_millis(unsigned int milliseconds) noexcept
+void sleep_for_millis(unsigned int milliseconds) noexcept
 {
 #if defined(_WIN32)
     ::Sleep(milliseconds);
@@ -397,20 +397,20 @@ namespace os {
 
 // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
- std::string filename_to_str(const filename_t &filename)
+std::string filename_to_str(const filename_t &filename)
 {
     memory_buf_t buf;
     wstr_to_utf8buf(filename, buf);
     return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
- std::string filename_to_str(const filename_t &filename)
+std::string filename_to_str(const filename_t &filename)
 {
     return filename;
 }
 #endif
 
- int pid() noexcept
+int pid() noexcept
 {
 
 #ifdef _WIN32
@@ -422,7 +422,7 @@ namespace os {
 
 // Determine if the terminal supports colors
 // Based on: https://github.com/agauniyal/rang/
- bool is_color_terminal() noexcept
+bool is_color_terminal() noexcept
 {
 #ifdef _WIN32
     return true;
@@ -453,7 +453,7 @@ namespace os {
 
 // Determine if the terminal attached
 // Source: https://github.com/agauniyal/rang/
- bool in_terminal(FILE *file) noexcept
+bool in_terminal(FILE *file) noexcept
 {
 
 #ifdef _WIN32
@@ -464,7 +464,7 @@ namespace os {
 }
 
 #if defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32)
- void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
+void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
 {
     if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
     {
@@ -499,7 +499,7 @@ namespace os {
     throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
 }
 
- void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
+void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
 {
     if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
     {
@@ -532,7 +532,7 @@ namespace os {
 #endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32)
 
 // return true on success
-static  bool mkdir_(const filename_t &path)
+static bool mkdir_(const filename_t &path)
 {
 #ifdef _WIN32
 #    ifdef SPDLOG_WCHAR_FILENAMES
@@ -547,7 +547,7 @@ static  bool mkdir_(const filename_t &path)
 
 // create the given directory - and all directories leading to it
 // return true on success or if the directory already exists
- bool create_dir(const filename_t &path)
+bool create_dir(const filename_t &path)
 {
     if (path_exists(path))
     {
@@ -586,13 +586,13 @@ static  bool mkdir_(const filename_t &path)
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
- filename_t dir_name(const filename_t &path)
+filename_t dir_name(const filename_t &path)
 {
     auto pos = path.find_last_of(folder_seps_filename);
     return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
 }
 
-std::string  getenv(const char *field)
+std::string getenv(const char *field)
 {
 
 #if defined(_MSC_VER)
@@ -612,7 +612,7 @@ std::string  getenv(const char *field)
 
 // Do fsync by FILE handlerpointer
 // Return true on success
- bool fsync(FILE *fp)
+bool fsync(FILE *fp)
 {
 #ifdef _WIN32
     return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;

src/details/periodic_worker.cpp

@@ -7,7 +7,7 @@ namespace spdlog {
 namespace details {
 
 // stop the worker thread and join it
- periodic_worker::~periodic_worker()
+periodic_worker::~periodic_worker()
 {
     if (worker_thread_.joinable())
     {

src/details/registry.cpp

@@ -26,7 +26,7 @@
 namespace spdlog {
 namespace details {
 
- registry::registry()
+registry::registry()
     : formatter_(new pattern_formatter())
 {
 
@@ -45,15 +45,15 @@ namespace details {
 #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
 }
 
- registry::~registry() = default;
+registry::~registry() = default;
 
- void registry::register_logger(std::shared_ptr<logger> new_logger)
+void registry::register_logger(std::shared_ptr<logger> new_logger)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     register_logger_(std::move(new_logger));
 }
 
- void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+void registry::initialize_logger(std::shared_ptr<logger> new_logger)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     new_logger->set_formatter(formatter_->clone());
@@ -76,14 +76,14 @@ namespace details {
     }
 }
 
- std::shared_ptr<logger> registry::get(const std::string &logger_name)
+std::shared_ptr<logger> registry::get(const std::string &logger_name)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     auto found = loggers_.find(logger_name);
     return found == loggers_.end() ? nullptr : found->second;
 }
 
- std::shared_ptr<logger> registry::default_logger()
+std::shared_ptr<logger> registry::default_logger()
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     return default_logger_;
@@ -93,14 +93,14 @@ namespace details {
 // To be used directly by the spdlog default api (e.g. spdlog::info)
 // This make the default API faster, but cannot be used concurrently with set_default_logger().
 // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
- logger *registry::get_default_raw()
+logger *registry::get_default_raw()
 {
     return default_logger_.get();
 }
 
 // set default logger.
 // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
- void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     // remove previous default logger from the map
@@ -115,20 +115,20 @@ namespace details {
     default_logger_ = std::move(new_default_logger);
 }
 
- void registry::set_tp(std::shared_ptr<thread_pool> tp)
+void registry::set_tp(std::shared_ptr<thread_pool> tp)
 {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     tp_ = std::move(tp);
 }
 
- std::shared_ptr<thread_pool> registry::get_tp()
+std::shared_ptr<thread_pool> registry::get_tp()
 {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     return tp_;
 }
 
 // Set global formatter. Each sink in each logger will get a clone of this object
- void registry::set_formatter(std::unique_ptr<formatter> formatter)
+void registry::set_formatter(std::unique_ptr<formatter> formatter)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     formatter_ = std::move(formatter);
@@ -138,7 +138,7 @@ namespace details {
     }
 }
 
- void registry::set_level(level level)
+void registry::set_level(level level)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     for (auto &l : loggers_)
@@ -148,7 +148,7 @@ namespace details {
     global_log_level_ = level;
 }
 
- void registry::flush_on(level level)
+void registry::flush_on(level level)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     for (auto &l : loggers_)
@@ -158,7 +158,7 @@ namespace details {
     flush_level_ = level;
 }
 
- void registry::set_error_handler(err_handler handler)
+void registry::set_error_handler(err_handler handler)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     for (auto &l : loggers_)
@@ -168,7 +168,7 @@ namespace details {
     err_handler_ = std::move(handler);
 }
 
- void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     for (auto &l : loggers_)
@@ -177,7 +177,7 @@ namespace details {
     }
 }
 
- void registry::flush_all()
+void registry::flush_all()
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     for (auto &l : loggers_)
@@ -186,7 +186,7 @@ namespace details {
     }
 }
 
- void registry::drop(const std::string &logger_name)
+void registry::drop(const std::string &logger_name)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
@@ -197,7 +197,7 @@ namespace details {
     }
 }
 
- void registry::drop_all()
+void registry::drop_all()
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     loggers_.clear();
@@ -205,7 +205,7 @@ namespace details {
 }
 
 // clean all resources and threads started by the registry
- void registry::shutdown()
+void registry::shutdown()
 {
     {
         std::lock_guard<std::mutex> lock(flusher_mutex_);
@@ -220,18 +220,18 @@ namespace details {
     }
 }
 
- std::recursive_mutex &registry::tp_mutex()
+std::recursive_mutex &registry::tp_mutex()
 {
     return tp_mutex_;
 }
 
- void registry::set_automatic_registration(bool automatic_registration)
+void registry::set_automatic_registration(bool automatic_registration)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     automatic_registration_ = automatic_registration;
 }
 
- void registry::set_levels(log_levels levels, level *global_level)
+void registry::set_levels(log_levels levels, level *global_level)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     log_levels_ = std::move(levels);
@@ -252,13 +252,13 @@ namespace details {
     }
 }
 
- registry &registry::instance()
+registry &registry::instance()
 {
     static registry s_instance;
     return s_instance;
 }
 
- void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger)
+void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     auto it = log_levels_.find(new_logger->name());
@@ -266,7 +266,7 @@ namespace details {
     new_logger->set_level(new_level);
 }
 
- void registry::throw_if_exists_(const std::string &logger_name)
+void registry::throw_if_exists_(const std::string &logger_name)
 {
     if (loggers_.find(logger_name) != loggers_.end())
     {
@@ -274,7 +274,7 @@ namespace details {
     }
 }
 
- void registry::register_logger_(std::shared_ptr<logger> new_logger)
+void registry::register_logger_(std::shared_ptr<logger> new_logger)
 {
     auto logger_name = new_logger->name();
     throw_if_exists_(logger_name);

src/details/thread_pool.cpp

@@ -8,8 +8,7 @@
 namespace spdlog {
 namespace details {
 
- thread_pool::thread_pool(
-    size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
+thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
     : q_(q_max_items)
 {
     if (threads_n == 0 || threads_n > 1000)
@@ -27,17 +26,17 @@ namespace details {
     }
 }
 
- thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
     : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
 {}
 
- thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
+thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
     : thread_pool(
           q_max_items, threads_n, [] {}, [] {})
 {}
 
 // message all threads to terminate gracefully join them
- thread_pool::~thread_pool()
+thread_pool::~thread_pool()
 {
     SPDLOG_TRY
     {
@@ -54,43 +53,43 @@ namespace details {
     SPDLOG_CATCH_STD
 }
 
-void  thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
+void thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
 {
     async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
     post_async_msg_(std::move(async_m), overflow_policy);
 }
 
-void  thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+void thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
 {
     post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
 }
 
-size_t  thread_pool::overrun_counter()
+size_t thread_pool::overrun_counter()
 {
     return q_.overrun_counter();
 }
 
-void  thread_pool::reset_overrun_counter()
+void thread_pool::reset_overrun_counter()
 {
     q_.reset_overrun_counter();
 }
 
-size_t  thread_pool::discard_counter()
+size_t thread_pool::discard_counter()
 {
     return q_.discard_counter();
 }
 
-void  thread_pool::reset_discard_counter()
+void thread_pool::reset_discard_counter()
 {
     q_.reset_discard_counter();
 }
 
-size_t  thread_pool::queue_size()
+size_t thread_pool::queue_size()
 {
     return q_.size();
 }
 
-void  thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+void thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
 {
     if (overflow_policy == async_overflow_policy::block)
     {
@@ -107,7 +106,7 @@ void  thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy ov
     }
 }
 
-void  thread_pool::worker_loop_()
+void thread_pool::worker_loop_()
 {
     while (process_next_msg_()) {}
 }
@@ -115,7 +114,7 @@ void  thread_pool::worker_loop_()
 // process next message in the queue
 // return true if this thread should still be active (while no terminate msg
 // was received)
-bool  thread_pool::process_next_msg_()
+bool thread_pool::process_next_msg_()
 {
     async_msg incoming_async_msg;
     q_.dequeue(incoming_async_msg);