logger.cpp

Go to the documentation of this file.

 
#include <common/logger.h>
#include <stdarg.h>
#include <drivers/console/vesaboot.h>
#include <common/version.h>
#include <system/cpu.h>
#include <processes/scheduler.h>
 
using namespace MaxOS;
using namespace MaxOS::common;
using namespace MaxOS::drivers::console;
using namespace MaxOS::processes;
using namespace MaxOS::system;
 
Logger::Logger()
: m_log_writers()
{
 
    s_active_logger = this;
 
    // The following line is generated automatically by the MaxOS build system.
    s_progress_total = 22;
 
}
 
 
Logger::~Logger() = default;
 
void Logger::add_log_writer(OutputStream* log_writer) {
 
    // If the list is not empty
    if (m_log_writer_count >= MAX_LOG_WRITERS)
        return;
 
    // Add the output stream to the list
    m_log_writers[m_log_writer_count] = log_writer;
    m_log_writers_enabled[m_log_writer_count] = true;
    m_log_writer_count++;
 
    // Print the setup info
    *this << LogLevel::INFO << "Logger setup: " << m_log_writer_count << "\n";
    *this << LogLevel::HEADER << "MaxOS v" << VERSION_STRING << " [ build " << BUILD_NUMBER << " ]\n";
 
}
 
void Logger::disable_log_writer(OutputStream* log_writer) {
 
    // If the list is empty
    if (m_log_writer_count == 0)
        return;
 
    // Find the output stream in the list
    for (int i = 0; i < m_log_writer_count; i++)
        if (m_log_writers[i] == log_writer)
            m_log_writers_enabled[i] = false;
}
 
void Logger::set_log_level(LogLevel log_level) {
 
    // Set the log level
    m_log_level = log_level;
 
    // Update the progress bar
    if (log_level == LogLevel::INFO) {
        VESABootConsole::update_progress_bar((m_progress_current * 100) / s_progress_total);
        m_progress_current++;
    }
 
    // Print the header
    switch (log_level) {
 
        case LogLevel::HEADER:
            *this << ANSI_COLOURS[ANSIColour::FG_Blue] << "[  BOOT    ] ";
            break;
 
        case LogLevel::INFO:
            *this << ANSI_COLOURS[ANSIColour::FG_Cyan] << "[  INFO    ]" << ANSI_COLOURS[ANSIColour::FG_White] << " ";
            break;
 
        case LogLevel::TEST:
            *this << ANSI_COLOURS[ANSIColour::FG_Green] << "[  TEST    ]" << ANSI_COLOURS[ANSIColour::FG_White] << " ";
            break;
 
        case LogLevel::DEBUG:
            *this << ANSI_COLOURS[ANSIColour::FG_Yellow] << "[  DEBUG   ]" << ANSI_COLOURS[ANSIColour::Reset] << " ";
            break;
 
        case LogLevel::WARNING:
            *this << ANSI_COLOURS[ANSIColour::BG_Yellow] << ANSI_COLOURS[FG_White] << "[ WARNING  ]" << ANSI_COLOURS[ANSIColour::Reset] << " ";
            break;
 
        case LogLevel::ERROR:
            *this << ANSI_COLOURS[ANSIColour::BG_Red] << "[  ERROR   ]" << ANSI_COLOURS[ANSIColour::Reset] << " ";
            break;
    }
 
    GlobalScheduler::print_running_header();
}
 
 
void Logger::write_char(char c) {
 
    // Ensure logging at this level is enabled
    if (m_log_level > MAX_LOG_LEVEL)
        return;
 
    // Write the character to all output streams
    for (int i = 0; i < m_log_writer_count; i++)
        if (m_log_writers_enabled[i])
            m_log_writers[i]->write_char(c);
 
}
 
Logger &Logger::Out() {
 
    return *active_logger();
}
 
Logger Logger::HEADER() {
 
    s_active_logger->set_log_level(LogLevel::HEADER);
    return Out();
 
}
 
Logger Logger::INFO() {
 
    s_active_logger->set_log_level(LogLevel::INFO);
    return Out();
}
 
Logger Logger::TEST() {
 
    s_active_logger->set_log_level(LogLevel::TEST);
    return Out();
}
 
Logger Logger::DEBUG() {
 
    s_active_logger->set_log_level(LogLevel::DEBUG);
    return Out();
 
}
 
Logger Logger::WARNING() {
 
    s_active_logger->set_log_level(LogLevel::WARNING);
    return Out();
}
 
Logger Logger::ERROR() {
 
    s_active_logger->set_log_level(LogLevel::ERROR);
    return Out();
 
}
 
Logger *Logger::active_logger() {
    return s_active_logger;
}
 
void Logger::printf(char const *format, ...) {
 
    // Create a pointer to the data
    va_list parameters;
    va_start(parameters, format);
 
    write(String::formatted(format, parameters));
}
 
void Logger::ASSERT(bool condition, char const *message, ...) {
 
    // If the condition is met then everything is ok
    if (condition)
        return;
 
    va_list parameters;
    va_start(parameters, message);
 
    // Hang the system
    system::CPU::PANIC(String::formatted(message, parameters).c_str());
}
 
Logger &Logger::operator<<(LogLevel log_level) {
 
    set_log_level(log_level);
    return *this;
 
}