can_stack_logger.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef CAN_STACK_LOGGER_HPP
#define CAN_STACK_LOGGER_HPP
 
#include "isobus/utility/thread_synchronization.hpp"
 
#include <memory>
#include <string>
 
namespace isobus
{
    //================================================================================================
    //================================================================================================
    class CANStackLogger
    {
    public:
        enum class LoggingLevel
        {
            Debug = 0, 
            Info, 
            Warning, 
            Error, 
            Critical 
        };
 
        CANStackLogger() = default;
 
        ~CANStackLogger() = default;
 
#ifndef DISABLE_CAN_STACK_LOGGER
 
        static void CAN_stack_log(LoggingLevel level, const std::string &logText);
 
        template<typename... Args>
        static void CAN_stack_log(LoggingLevel level, const std::string &format, Args... args)
        {
            int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
            if (size_s > 0)
            {
                auto size = static_cast<std::size_t>(size_s);
                std::unique_ptr<char[]> buf(new char[size]);
                std::snprintf(buf.get(), size, format.c_str(), args...);
                CAN_stack_log(level, std::string(buf.get(), buf.get() + size - 1)); // We don't want the '\0' inside
            }
            else if (size_s < 0)
            {
                CAN_stack_log(level, format); // If snprintf had some error, at least print the format string
            }
        }
 
        static void debug(const std::string &logText);
 
        template<typename... Args>
        static void debug(const std::string &format, Args... args)
        {
            CAN_stack_log(LoggingLevel::Debug, format, args...);
        }
 
        static void info(const std::string &logText);
 
        template<typename... Args>
        static void info(const std::string &format, Args... args)
        {
            CAN_stack_log(LoggingLevel::Info, format, args...);
        }
 
        static void warn(const std::string &logText);
 
        template<typename... Args>
        static void warn(const std::string &format, Args... args)
        {
            CAN_stack_log(LoggingLevel::Warning, format, args...);
        }
 
        static void error(const std::string &logText);
 
        template<typename... Args>
        static void error(const std::string &format, Args... args)
        {
            CAN_stack_log(LoggingLevel::Error, format, args...);
        }
 
        static void critical(const std::string &logText);
 
        template<typename... Args>
        static void critical(const std::string &format, Args... args)
        {
            CAN_stack_log(LoggingLevel::Critical, format, args...);
        }
 
#endif
 
        static void set_can_stack_logger_sink(CANStackLogger *logSink);
 
        static LoggingLevel get_log_level();
 
        static void set_log_level(LoggingLevel newLogLevel);
 
        virtual void sink_CAN_stack_log(LoggingLevel level, const std::string &logText);
 
    private:
        static bool get_can_stack_logger(CANStackLogger *&canStackLogger);
 
        static CANStackLogger *logger; 
        static LoggingLevel currentLogLevel; 
        static Mutex loggerMutex; 
    };
} // namespace isobus
 
#ifdef DISABLE_CAN_STACK_LOGGER
#define LOG_CRITICAL(...)
#define LOG_ERROR(...)
#define LOG_WARNING(...)
#define LOG_INFO(...)
#define LOG_DEBUG(...)
#else
#define LOG_CRITICAL(...) isobus::CANStackLogger::critical(__VA_ARGS__)
#define LOG_ERROR(...) isobus::CANStackLogger::error(__VA_ARGS__)
#define LOG_WARNING(...) isobus::CANStackLogger::warn(__VA_ARGS__)
#define LOG_INFO(...) isobus::CANStackLogger::info(__VA_ARGS__)
#define LOG_DEBUG(...) isobus::CANStackLogger::debug(__VA_ARGS__)
#endif
 
#endif // CAN_STACK_LOGGER_HPP