Log Utils 0.4 - Migrate from static to instance loggers

log-utils/src/main/java/net/minecraftforge/util/logging/AbstractLogger.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Forge Development LLC
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+package net.minecraftforge.util.logging;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public abstract class AbstractLogger implements Logger {
+    /* CREATION */
+
+    protected AbstractLogger() {
+        this(Level.INFO, (byte) 0);
+    }
+
+    protected AbstractLogger(byte indentLevel) {
+        this(Level.INFO, indentLevel);
+    }
+
+    protected AbstractLogger(Level enabled) {
+        this(enabled, (byte) 0);
+    }
+
+    protected AbstractLogger(Level enabled, byte indentLevel) {
+        this.enabled = enabled;
+        this.indentLevel = indentLevel;
+    }
+
+    /* LOG LEVELS */
+
+    private @Nullable Level enabled;
+
+    @Override
+    public final @Nullable Level getEnabled() {
+        return this.enabled;
+    }
+
+    @Override
+    public final void setEnabled(@Nullable Level level) {
+        this.enabled = level;
+    }
+
+    /* INDENTATIONS */
+
+    private static final String INDENT_STRING = "  ";
+    private static final String[] INDENT_CACHE = new String[Byte.MAX_VALUE];
+    private byte indentLevel;
+
+    static {
+        INDENT_CACHE[0] = "";
+        INDENT_CACHE[1] = INDENT_STRING;
+    }
+
+    @Override
+    public final byte push() {
+        return indentLevel++;
+    }
+
+    @Override
+    public final byte pop() {
+        if (--indentLevel < 0)
+            throw new IllegalStateException("Cannot pop Log below 0");
+
+        return indentLevel;
+    }
+
+    @Override
+    public final byte pop(byte indent) {
+        if (indent < 0)
+            throw new IllegalArgumentException("Cannot pop Log below 0");
+
+        return indentLevel = indent;
+    }
+
+    @Override
+    public final String getIndentation() {
+        String ret = INDENT_CACHE[indentLevel];
+        //noinspection ConstantValue -- IntelliJ skill issue
+        return ret == null ? INDENT_CACHE[indentLevel] = getIndentation(indentLevel) : ret;
+    }
+
+    private static String getIndentation(byte indent) {
+        StringBuilder builder = new StringBuilder(INDENT_STRING.length() * indent);
+        for (int i = 0; i < indent; i++)
+            builder.append(INDENT_STRING);
+        return builder.toString();
+    }
+
+    /* CAPTURING */
+
+    private @Nullable List<Map.Entry<Level, String>> captured;
+
+    @Override
+    public final boolean isCapturing() {
+        return captured != null;
+    }
+
+    @Override
+    public final void capture() {
+        if (captured != null) return;
+        captured = new ArrayList<>(128);
+    }
+
+    final void tryCapture(Consumer<? super String> logger, Level level, String message) {
+        if (captured != null)
+            captured.add(new AbstractMap.SimpleImmutableEntry<>(level, message));
+        else
+            logger.accept(message);
+    }
+
+    @Override
+    public final void drop() {
+        captured = null;
+    }
+
+    @Override
+    public final void release() {
+        release(this::logDirectly);
+    }
+
+    @Override
+    public final void release(BiConsumer<Level, String> consumer) {
+        if (captured == null) return;
+
+        Iterator<Map.Entry<Level, String>> itor = captured.iterator();
+        captured = null;
+        while (itor.hasNext()) {
+            Map.Entry<Level, String> capture = itor.next();
+            consumer.accept(capture.getKey(), capture.getValue());
+        }
+    }
+
+    /* LOGGING */
+
+    static final DelegatePrintStream.Empty EMPTY = DelegatePrintStream.EMPTY;
+
+    private void logDirectly(Level level, String message) {
+        ((DelegatePrintStream) this.getLog(level)).getDelegate().accept(message);
+    }
+}

log-utils/src/main/java/net/minecraftforge/util/logging/DefaultLogger.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Forge Development LLC
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+package net.minecraftforge.util.logging;
+
+import java.io.PrintStream;
+
+final class DefaultLogger extends AbstractLogger {
+    DefaultLogger() {
+        super();
+    }
+
+    DefaultLogger(byte indentLevel) {
+        super(indentLevel);
+    }
+
+    DefaultLogger(Level enabled) {
+        super(enabled);
+    }
+
+    DefaultLogger(Level enabled, byte indentLevel) {
+        super(enabled, indentLevel);
+    }
+
+    private final DelegatePrintStream.Capturing debug = new DelegatePrintStream.Capturing(this, Level.DEBUG, System.out::println);
+    private final DelegatePrintStream.Capturing quiet = new DelegatePrintStream.Capturing(this, Level.QUIET, System.out::println);
+    private final DelegatePrintStream.Capturing info = new DelegatePrintStream.Capturing(this, Level.INFO, System.out::println);
+    private final DelegatePrintStream.Capturing warn = new DelegatePrintStream.Capturing(this, Level.WARN, System.out::println);
+    private final DelegatePrintStream.Capturing error = new DelegatePrintStream.Capturing(this, Level.ERROR, System.err::println);
+    private final DelegatePrintStream.Capturing fatal = new DelegatePrintStream.Capturing(this, Level.FATAL, System.err::println);
+
+    @Override
+    public PrintStream getDebug() {
+        return this.debug;
+    }
+
+    @Override
+    public PrintStream getQuiet() {
+        return this.quiet;
+    }
+
+    @Override
+    public PrintStream getInfo() {
+        return this.info;
+    }
+
+    @Override
+    public PrintStream getWarn() {
+        return this.warn;
+    }
+
+    @Override
+    public PrintStream getError() {
+        return this.error;
+    }
+
+    @Override
+    public PrintStream getFatal() {
+        return this.fatal;
+    }
+}

log-utils/src/main/java/net/minecraftforge/util/logging/DelegatePrintStream.java

@@ -9,16 +9,16 @@
 import java.util.function.Consumer;
 
 interface DelegatePrintStream {
-    PrintStream EMPTY = new Empty();
+    DelegatePrintStream.Empty EMPTY = new Empty();
 
-    PrintStream getDelegate();
+    Consumer<? super String> getDelegate();
 
     final class Capturing extends PrintStream implements DelegatePrintStream {
-        private final PrintStream raw;
+        private final Consumer<? super String> delegate;
 
-        public Capturing(Log.Level level, PrintStream stream) {
+        public Capturing(AbstractLogger logger, Logger.Level level, Consumer<? super String> output) {
             super(new OutputStream() {
-                private final Consumer<String> logger = new LogConsumer(level, stream::println);
+                private final Consumer<? super String> consumer = new LogConsumer(logger, level, output);
                 private StringBuffer buffer = new StringBuffer(512);
 
                 @Override
@@ -29,7 +29,7 @@ public void write(int b) {
                 private void write(char c) {
                     if (c == '\n' || c == '\r') {
                         if (this.buffer.length() != 0) {
-                            logger.accept(this.buffer.insert(0, Log.getIndentation()).toString());
+                            consumer.accept(this.buffer.insert(0, logger.getIndentation()).toString());
                             this.buffer = new StringBuffer(512);
                         }
                     } else {
@@ -38,12 +38,12 @@ private void write(char c) {
                 }
             });
 
-            this.raw = stream;
+            this.delegate = output;
         }
 
         @Override
-        public PrintStream getDelegate() {
-            return this.raw;
+        public Consumer<? super String> getDelegate() {
+            return this.delegate;
         }
     }
 
@@ -64,8 +64,8 @@ public boolean checkError() {
         protected void clearError() { }
 
         @Override
-        public PrintStream getDelegate() {
-            return this;
+        public Consumer<? super String> getDelegate() {
+            return s -> {};
         }
     }
 }