update logger

c_os/user/lib/Logger.cc

@@ -1,45 +1,95 @@
 #include "user/lib/Logger.h"
 #include "kernel/Globals.h"
 
-bool Logger::kout_enabled = true;
+bool Logger::kout_enabled = false;
 bool Logger::serial_enabled = true;
 const Semaphore Logger::sem = Semaphore(1);
 
 Logger::LogLevel Logger::level = Logger::TRACE;
 
-void Logger::log(char* message, CGA::color col) {
+void Logger::log(char* message, CGA::color col) const {
     if (Logger::kout_enabled) {
         CGA::color old_col = kout.color_fg;
-        kout << fgc(col) << this->name << " :: " << message << fgc(old_col) << endl;
+        kout << fgc(col)
+             << Logger::level_to_string(this->current_message_level) << "::"
+             << this->name << ":: "
+             << message << fgc(old_col);
+        kout.flush();  // Don't add newline, Logger already does that
     }
     if (Logger::serial_enabled) {
+        serial.write(Logger::level_to_string(this->current_message_level));
+        serial.write("::");
         serial.write(this->name);
-        serial.write(" :: ");
+        serial.write(":: ");
         serial.write(message);
-        serial.write("\r\n");
+        serial.write('\r');
+        // serial.write("\r\n");
     }
 }
 
-void Logger::trace(char* message) {
+void Logger::flush() {
+    this->buffer[this->pos] = '\0';
+
+    switch (this->current_message_level) {
+    case Logger::TRACE:
+        this->trace(this->buffer);
+        break;
+    case Logger::DEBUG:
+        this->debug(this->buffer);
+        break;
+    case Logger::ERROR:
+        this->error(this->buffer);
+        break;
+    case Logger::INFO:
+        this->info(this->buffer);
+        break;
+    }
+
+    this->current_message_level = Logger::INFO;
+    this->pos = 0;
+}
+
+void Logger::trace(char* message) const {
     if (Logger::level <= Logger::TRACE) {
         this->log(message, CGA::GREEN);
     }
 }
 
-void Logger::debug(char* message) {
+void Logger::debug(char* message) const {
     if (Logger::level <= Logger::DEBUG) {
-        this->log(message, CGA::CYAN);
+        this->log(message, CGA::LIGHT_BLUE);
     }
 }
 
-void Logger::error(char* message) {
+void Logger::error(char* message) const {
     if (Logger::level <= Logger::ERROR) {
         this->log(message, CGA::RED);
     }
 }
 
-void Logger::info(char* message) {
+void Logger::info(char* message) const {
     if (Logger::level <= Logger::TRACE) {
-        this->log(message, CGA::LIGHT_GREY);
+        this->log(message, CGA::CYAN);
     }
 }
+
+// Manipulatoren
+Logger& TRACE(Logger& log) {
+    log.current_message_level = Logger::TRACE;
+    return log;
+}
+
+Logger& DEBUG(Logger& log) {
+    log.current_message_level = Logger::DEBUG;
+    return log;
+}
+
+Logger& ERROR(Logger& log) {
+    log.current_message_level = Logger::ERROR;
+    return log;
+}
+
+Logger& INFO(Logger& log) {
+    log.current_message_level = Logger::INFO;
+    return log;
+}

c_os/user/lib/Logger.h

@@ -2,9 +2,10 @@
 #define __Logger_Include_H_
 
 #include "devices/CGA.h"
+#include "lib/OutStream.h"
 #include "lib/Semaphore.h"
 
-class Logger {
+class Logger : public OutStream {
 private:
     Logger(const Logger& copy) = delete;
 
@@ -15,7 +16,7 @@ private:
     // TODO: Don't mix logs
     static const Semaphore sem;
 
-    void log(char* message, CGA::color col);
+    void log(char* message, CGA::color col) const;
 
 public:
     Logger(char* name) : name(name) {}
@@ -27,17 +28,33 @@ public:
         INFO = 3
     };
     static LogLevel level;
+    LogLevel current_message_level = Logger::INFO;  // Use this to log with manipulators
 
-    void trace(char* message);
-    void debug(char* message);
-    void error(char* message);
-    void info(char* message);
+    void flush() override;
+
+    void trace(char* message) const;
+    void debug(char* message) const;
+    void error(char* message) const;
+    void info(char* message) const;
 
     // TODO: Make level change accessible over menu
     static void set_level(LogLevel level) {
         Logger::level = level;
     }
 
+    static char* level_to_string(LogLevel level) {
+        switch (level) {
+        case Logger::TRACE:
+            return "TRACE";
+        case Logger::DEBUG:
+            return "DEBUG";
+        case Logger::ERROR:
+            return "ERROR";
+        case Logger::INFO:
+            return "INFO";
+        }
+    }
+
     static void enable_kout() {
         Logger::kout_enabled = true;
     }
@@ -52,4 +69,10 @@ public:
     }
 };
 
+// Manipulatoren
+Logger& TRACE(Logger& log);
+Logger& DEBUG(Logger& log);
+Logger& ERROR(Logger& log);
+Logger& INFO(Logger& log);
+
 #endif