logger.h

Go to the documentation of this file.

 
#ifndef MAXOS_COMMON_LOGGER_H
#define MAXOS_COMMON_LOGGER_H
 
#include <libcommon/outputStream.h>
#include <libcommon/colour.h>
#include <libcommon/spinlock.h>
 
namespace MaxOS {
 
 
    enum class LogLevel {
        OUT,
        ERROR,
        WARNING,
        HEADER,
        INFO,
        TEST,
        DEBUG,
    };
 
 
    constexpr uint8_t MAX_LOG_WRITERS = 5;                  
#ifdef NDEBUG
    constexpr LogLevel MAX_LOG_LEVEL = LogLevel::INFO;      
#else
    constexpr LogLevel MAX_LOG_LEVEL = LogLevel::DEBUG;     
#endif
 
 
 
    class LogRecord;
 
    class Logger : public MaxOS::common::OutputStream {
 
        friend class LogRecord;
 
        private:
 
            // Cant use vector as this needs to be init before the heap
            uint8_t m_log_writer_count = 0;
            OutputStream* m_log_writers[MAX_LOG_WRITERS] = { nullptr, nullptr, nullptr, nullptr, nullptr };
            bool m_log_writers_enabled[MAX_LOG_WRITERS] = { false, false, false, false, false };
 
            // Progress bar
            static inline uint8_t s_progress_total = 100;
            uint8_t m_progress_current = 0;
 
            static inline Logger* s_active_logger = nullptr;
            inline static common::Spinlock s_loggers_lock = {};
 
            LogLevel m_log_level = LogLevel::INFO;
 
        public:
            Logger();
            ~Logger();
 
            void add_log_writer(OutputStream* log_writer);
            void disable_log_writer(OutputStream* log_writer);
            void enable_log_writer(OutputStream* log_writer);
            void enable_all_log_writers();
 
            void set_log_level(LogLevel log_level);
 
            void write_char(char c) final;
            void printf(const char* format, ...);
 
            static void assert(bool condition, const char* message, ...);
 
            static Logger* active_logger();
 
            static LogRecord Out();
 
            static LogRecord ERROR();
            static LogRecord WARNING();
            static LogRecord HEADER();
            static LogRecord INFO();
            static LogRecord TEST();
            static LogRecord DEBUG();
 
            using OutputStream::operator <<;
            Logger& operator <<(LogLevel log_level);
    };
 
    class LogRecord {
 
        private:
            Logger& m_logger;
 
        public:
            explicit LogRecord(Logger& logger, LogLevel level);
            ~LogRecord();
 
            template<typename T> LogRecord& operator << (const T& value) {
                m_logger.write(value);
                return *this;
            }
 
            LogRecord& operator << (char c) {
                m_logger.write_char(c);
                return *this;
            }
    };
}
 
#endif // MAXOS_COMMON_LOGGER_H