refactor: custom logging solution

src/main/java/runner/Processor.java

@@ -1,19 +1,18 @@
 package runner;
 
+import technology.idlab.logging.Log;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-import java.util.logging.Logger;
-
-import static technology.idlab.logging.LoggerKt.createLogger;
 
 public abstract class Processor {
     /**
      * Processors which wish to log messages should use the logger provided by
      * the template class. This logger is created with the name of the class
      * which extends the template.
      */
-    protected final Logger logger = createLogger();
+    protected final Log log = Log.Companion.getShared();
 
     /**
      * The arguments of a processor are stored in a map and can be accessed by
@@ -40,10 +39,10 @@ protected <T> Optional<T> getOptionalArgument(String name) {
     }
 
     public void setup() {
-        logger.info("Setting up processor");
+        log.info("Setting up processor");
     }
 
     public void exec() {
-        logger.info("Executing processor");
+        log.info("Executing processor");
     }
 }

src/main/kotlin/compiler/Compiler.kt

@@ -1,22 +1,20 @@
 package technology.idlab.compiler
 
-import technology.idlab.logging.createLogger
-import technology.idlab.logging.fatal
+import technology.idlab.logging.Log
 import java.io.File
 import java.io.PrintWriter
 import javax.tools.DiagnosticCollector
 import javax.tools.JavaFileObject
 import javax.tools.ToolProvider
 
 class Compiler {
-    private val logger = createLogger()
     private val compiler =
-        ToolProvider.getSystemJavaCompiler() ?: logger.fatal(
+        ToolProvider.getSystemJavaCompiler() ?: Log.shared.fatal(
             "No Java compiler found.",
         )
 
     fun compile(file: File): ByteArray {
-        logger.info("Compiling file://${file.absolutePath}")
+        Log.shared.info("Compiling file://${file.absolutePath}")
 
         // Prepare compilation.
         val files = listOf(file)
@@ -40,11 +38,11 @@ class Compiler {
 
         // Write diagnostics to logger.
         diagnosticCollector.diagnostics.forEach {
-            logger.info(it.toString())
+            Log.shared.info(it.toString())
         }
 
         if (!success) {
-            logger.fatal("ERROR: compilation failed")
+            Log.shared.fatal("ERROR: compilation failed")
         }
 
         return results.get(file.nameWithoutExtension)

src/main/kotlin/compiler/MemoryClassLoader.kt

@@ -1,18 +1,15 @@
 package technology.idlab.compiler
 
-import technology.idlab.logging.createLogger
-import technology.idlab.logging.fatal
+import technology.idlab.logging.Log
 
 class MemoryClassLoader : ClassLoader() {
-    private val logger = createLogger()
-
     fun fromBytes(bytes: ByteArray, name: String): Class<*> {
-        logger.info("Loading class $name")
+        Log.shared.info("Loading class $name")
 
         return try {
             defineClass(name, bytes, 0, bytes.size)
         } catch (e: ClassFormatError) {
-            logger.fatal("Failed to load class $name")
+            Log.shared.fatal("Failed to load class $name")
         }
     }
 }

src/main/kotlin/compiler/MemoryFileManager.kt

@@ -1,7 +1,6 @@
 package technology.idlab.compiler
 
-import technology.idlab.logging.createLogger
-import technology.idlab.logging.fatal
+import technology.idlab.logging.Log
 import java.io.ByteArrayOutputStream
 import java.io.OutputStream
 import java.net.URI
@@ -19,7 +18,6 @@ class MemoryFileManager(
     fileManager: JavaFileManager,
 ) : ForwardingJavaFileManager<JavaFileManager>(fileManager) {
     private val results: MutableMap<String, ByteArray> = HashMap()
-    private val logger = createLogger()
 
     override fun getJavaFileForOutput(
         location: JavaFileManager.Location?,
@@ -46,6 +44,6 @@ class MemoryFileManager(
     }
 
     fun get(className: String): ByteArray {
-        return results[className] ?: logger.fatal("Class $className not found")
+        return results[className] ?: Log.shared.fatal("Class $className not found")
     }
 }