EIC code displayed by LXR master/​include/​spdlog/​logger-inl.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:12:43

 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
 #    include <spdlog/logger.h>
 #endif
 
 #include <spdlog/sinks/sink.h>
 #include <spdlog/details/backtracer.h>
 #include <spdlog/pattern_formatter.h>
 
 #include <cstdio>
 
 namespace spdlog {
 
 // public methods
 SPDLOG_INLINE logger::logger(const logger &other)
     : name_(other.name_)
     , sinks_(other.sinks_)
     , level_(other.level_.load(std::memory_order_relaxed))
     , flush_level_(other.flush_level_.load(std::memory_order_relaxed))
     , custom_err_handler_(other.custom_err_handler_)
     , tracer_(other.tracer_)
 {}
 
 SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)),
                                                                sinks_(std::move(other.sinks_)),
                                                                level_(other.level_.load(std::memory_order_relaxed)),
                                                                flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
                                                                custom_err_handler_(std::move(other.custom_err_handler_)),
                                                                tracer_(std::move(other.tracer_))
 
 {}
 
 SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT
 {
     this->swap(other);
     return *this;
 }
 
 SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT
 {
     name_.swap(other.name_);
     sinks_.swap(other.sinks_);
 
     // swap level_
     auto other_level = other.level_.load();
     auto my_level = level_.exchange(other_level);
     other.level_.store(my_level);
 
     // swap flush level_
     other_level = other.flush_level_.load();
     my_level = flush_level_.exchange(other_level);
     other.flush_level_.store(my_level);
 
     custom_err_handler_.swap(other.custom_err_handler_);
     std::swap(tracer_, other.tracer_);
 }
 
 SPDLOG_INLINE void swap(logger &a, logger &b)
 {
     a.swap(b);
 }
 
 SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
 {
     level_.store(log_level);
 }
 
 SPDLOG_INLINE level::level_enum logger::level() const
 {
     return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
 }
 
 SPDLOG_INLINE const std::string &logger::name() const
 {
     return name_;
 }
 
 // set formatting for the sinks in this logger.
 // each sink will get a separate instance of the formatter object.
 SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
 {
     for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
     {
         if (std::next(it) == sinks_.end())
         {
             // last element - we can be move it.
             (*it)->set_formatter(std::move(f));
             break; // to prevent clang-tidy warning
         }
         else
         {
             (*it)->set_formatter(f->clone());
         }
     }
 }
 
 SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type)
 {
     auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
     set_formatter(std::move(new_formatter));
 }
 
 // create new backtrace sink and move to it all our child sinks
 SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages)
 {
     tracer_.enable(n_messages);
 }
 
 // restore orig sinks and level and delete the backtrace sink
 SPDLOG_INLINE void logger::disable_backtrace()
 {
     tracer_.disable();
 }
 
 SPDLOG_INLINE void logger::dump_backtrace()
 {
     dump_backtrace_();
 }
 
 // flush functions
 SPDLOG_INLINE void logger::flush()
 {
     flush_();
 }
 
 SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
 {
     flush_level_.store(log_level);
 }
 
 SPDLOG_INLINE level::level_enum logger::flush_level() const
 {
     return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
 }
 
 // sinks
 SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const
 {
     return sinks_;
 }
 
 SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
 {
     return sinks_;
 }
 
 // error handler
 SPDLOG_INLINE void logger::set_error_handler(err_handler handler)
 {
     custom_err_handler_ = std::move(handler);
 }
 
 // create new logger with same sinks and configuration.
 SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
 {
     auto cloned = std::make_shared<logger>(*this);
     cloned->name_ = std::move(logger_name);
     return cloned;
 }
 
 // protected methods
 SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
 {
     if (log_enabled)
     {
         sink_it_(log_msg);
     }
     if (traceback_enabled)
     {
         tracer_.push_back(log_msg);
     }
 }
 
 SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
 {
     for (auto &sink : sinks_)
     {
         if (sink->should_log(msg.level))
         {
             SPDLOG_TRY
             {
                 sink->log(msg);
             }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
 
     if (should_flush_(msg))
     {
         flush_();
     }
 }
 
 SPDLOG_INLINE void logger::flush_()
 {
     for (auto &sink : sinks_)
     {
         SPDLOG_TRY
         {
             sink->flush();
         }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }
 
 SPDLOG_INLINE void logger::dump_backtrace_()
 {
     using details::log_msg;
     if (tracer_.enabled())
     {
         sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
         tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
         sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
     }
 }
 
 SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg)
 {
     auto flush_level = flush_level_.load(std::memory_order_relaxed);
     return (msg.level >= flush_level) && (msg.level != level::off);
 }
 
 SPDLOG_INLINE void logger::err_handler_(const std::string &msg)
 {
     if (custom_err_handler_)
     {
         custom_err_handler_(msg);
     }
     else
     {
         using std::chrono::system_clock;
         static std::mutex mutex;
         static std::chrono::system_clock::time_point last_report_time;
         static size_t err_counter = 0;
         std::lock_guard<std::mutex> lk{mutex};
         auto now = system_clock::now();
         err_counter++;
         if (now - last_report_time < std::chrono::seconds(1))
         {
             return;
         }
         last_report_time = now;
         auto tm_time = details::os::localtime(system_clock::to_time_t(now));
         char date_buf[64];
         std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
 #if defined(USING_R) && defined(R_R_H) // if in R environment
         REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
 #else
         std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
 #endif
     }
 }
 } // namespace spdlog

This page was automatically generated by the 2.3.7 LXR engine. The LXR team