6 files changed, 260 insertions, 0 deletions
diff --git a/src/de/romjaki/logger/EventHandler.java b/src/de/romjaki/logger/EventHandler.java
new file mode 100644
index 0000000..6e07466
--- /dev/null
+++ b/src/de/romjaki/logger/EventHandler.java
@@ -0,0 +1,7 @@
+package de.romjaki.logger;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public @interface EventHandler {
+}
diff --git a/src/de/romjaki/logger/Level.java b/src/de/romjaki/logger/Level.java
new file mode 100644
index 0000000..38310ab
--- /dev/null
+++ b/src/de/romjaki/logger/Level.java
@@ -0,0 +1,18 @@
+package de.romjaki.logger;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public enum Level {
+    ALL,
+    FAILURE,
+    ERROR,
+    WARNING,
+    INFO,
+    DEBUG,
+    OFF;
+
+    public boolean logs(Level level) {
+        return this.ordinal() <= level.ordinal();
+    }
+}
diff --git a/src/de/romjaki/logger/LogEvent.java b/src/de/romjaki/logger/LogEvent.java
new file mode 100644
index 0000000..e62742c
--- /dev/null
+++ b/src/de/romjaki/logger/LogEvent.java
@@ -0,0 +1,26 @@
+package de.romjaki.logger;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public abstract class LogEvent {
+
+    boolean interrupted = false;
+    Class<?> actor;
+
+    public LogEvent(Class<?> actor) {
+        this.actor = actor;
+    }
+
+    public void interrupt() {
+        interrupted = true;
+    }
+
+    public Class<?> getActor() {
+        return actor;
+    }
+
+    public boolean isInterrupted() {
+        return interrupted;
+    }
+}
diff --git a/src/de/romjaki/logger/LogHandler.java b/src/de/romjaki/logger/LogHandler.java
new file mode 100644
index 0000000..d5c01f6
--- /dev/null
+++ b/src/de/romjaki/logger/LogHandler.java
@@ -0,0 +1,7 @@
+package de.romjaki.logger;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public interface LogHandler {
+}
diff --git a/src/de/romjaki/logger/LoggedEvent.java b/src/de/romjaki/logger/LoggedEvent.java
new file mode 100644
index 0000000..143ab0c
--- /dev/null
+++ b/src/de/romjaki/logger/LoggedEvent.java
@@ -0,0 +1,23 @@
+package de.romjaki.logger;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public class LoggedEvent extends LogEvent {
+    private final Level level;
+    private final String text;
+
+    public LoggedEvent(Class<?> clazz, Level level, String text) {
+        super(clazz);
+        this.level = level;
+        this.text = text;
+    }
+
+    public Level getLevel() {
+        return level;
+    }
+
+    public String getText() {
+        return text;
+    }
+}
diff --git a/src/de/romjaki/logger/Logger.java b/src/de/romjaki/logger/Logger.java
new file mode 100644
index 0000000..f860d9d
--- /dev/null
+++ b/src/de/romjaki/logger/Logger.java
@@ -0,0 +1,179 @@
+package de.romjaki.logger;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import static de.romjaki.logger.Level.*;
+
+/**
+ * Created by RGR on 17.08.2017.
+ */
+public class Logger {
+    static String format = "[{LEVEL}][{DATE}]{NAME}: {TEXT}";
+    static DateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
+    String name;
+    Level logLevel = WARNING;
+    List<LogHandler> handlers = new ArrayList<>();
+
+    public Logger() {
+        this("");
+    }
+
+    public Logger(String name) {
+        this.name = name;
+    }
+
+    public Level getLogLevel() {
+        return logLevel;
+    }
+
+    public void setLogLevel(Level logLevel) {
+        this.logLevel = logLevel;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void log(Level level, String text) {
+        if (logLevel.logs(level)) {
+            doLog(level, text);
+        }
+    }
+
+    public void logf(Level level, String format, Object... fillIn) {
+        log(level, String.format(format, fillIn));
+    }
+
+    public void info(String text) {
+        log(INFO, text);
+    }
+
+    public void infof(String format, Object... fillIn) {
+        logf(INFO, format, fillIn);
+    }
+
+    public void warn(String text) {
+        log(WARNING, text);
+    }
+
+    public void warnf(String format, Object... fillIn) {
+        logf(WARNING, format, fillIn);
+    }
+
+    public void debug(String text) {
+        log(DEBUG, text);
+    }
+
+    public void debugf(String format, Object... fillIn) {
+        logf(DEBUG, format, fillIn);
+    }
+
+    public void error(String text) {
+        log(ERROR, text);
+    }
+
+    public void errorf(String format, Object... fillIn) {
+        logf(ERROR, format, fillIn);
+    }
+
+    public void failure(String text) {
+        log(FAILURE, text);
+    }
+
+    public void failuref(String format, Object... fillIn) {
+        logf(Level.FAILURE, format, fillIn);
+    }
+
+    public PrintStream getAsPrintStream() {
+        return getAsPrintStream(ALL);
+    }
+
+    public PrintStream getAsPrintStream(Level level) {
+        return getAsPrintStream(level, System.lineSeparator());
+    }
+
+    public PrintStream getAsPrintStream(Level level, String sep) {
+        return new PrintStream(new OutputStream() {
+            StringBuffer buffer = new StringBuffer();
+
+            Object locker = new Object();
+
+            @Override
+            public void write(int b) throws IOException {
+                char c = (char) b;
+                synchronized (locker) {
+                    buffer.append(c);
+                    if (buffer.indexOf(sep) != -1) {
+                        String[] splits = buffer.toString().split(sep, 2);
+                        log(level, splits[0]);
+                        if (splits.length > 1) {
+                            buffer = new StringBuffer(splits[1].replace(sep, ""));
+                        } else {
+                            buffer = new StringBuffer();
+                        }
+                    }
+                }
+            }
+        }, true);
+    }
+
+    public void exception(Throwable t) {
+        t.printStackTrace(getAsPrintStream(ERROR));
+    }
+
+    void doLog(Level level, String text) {
+        LogEvent event = new LoggedEvent(getCallingClass(), level, text);
+        dispatchEvent(event);
+        if (!event.isInterrupted()) {
+            System.out.println(format
+                    .replace("{LEVEL}", level.name())
+                    .replace("{DATE}", dateFormat.format(new Date()))
+                    .replace("{NAME}", name != null ? name : "")
+                    .replace("{TEXT}", text));
+        }
+    }
+
+    public void dispatchEvent(LogEvent event) {
+        handlers.forEach(handler -> dispatchEvent(event, handler));
+    }
+
+    void dispatchEvent(LogEvent event, LogHandler handler) {
+        for (Method method : handler.getClass().getMethods()) {
+            invokeSingle(method, event, handler);
+        }
+    }
+
+    void invokeSingle(Method method, LogEvent event, LogHandler handler) {
+        if (method.isAnnotationPresent(EventHandler.class)) {
+            Class<?>[] args = method.getParameterTypes();
+            if (args.length == 1 && args[0].isInstance(event)) {
+                try {
+                    method.invoke(handler, event);
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    Class<?> getCallingClass() {
+        StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+        for (int i = 1; i < trace.length; i++) {
+            StackTraceElement ste = trace[i];
+            if (!ste.getClass().equals(Logger.class) && ste.getClassName().indexOf("java.lang.Thread") != 0) {
+                return ste.getClass();
+            }
+        }
+        return null;
+    }
+
+}