Handle indentations within the delegate print stream

Author: Jonathing

.gitignore

@@ -3,7 +3,6 @@
 /**/.project
 /**/.settings/
 /**/bin/
-/**/test/
 /**/build/
 /repo/
 /cache/

log-utils/build.gradle

@@ -28,6 +28,11 @@ jar {
     }
 }
 
+compileJava {
+    // Java 6 exclusive javac argument that ignores "internal and proprietary usage" warnings for UnsafeHacks
+    options.forkOptions.jvmArgs += '-XDignore.symbol.file'
+}
+
 publishing {
     publications.register('mavenJava', MavenPublication).configure {
         artifactId = project.name

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

@@ -8,204 +8,237 @@
 import java.io.PrintStream;
 import java.util.Locale;
 
-final class DelegatePrintStream extends PrintStream {
+class DelegatePrintStream extends PrintStream {
+    static final PrintStream EMPTY = new DelegatePrintStream(null, System.err) {
+        @Override
+        boolean isEnabled() {
+            return false;
+        }
+
+        @Override
+        public boolean checkError() {
+            return false;
+        }
+
+        @SuppressWarnings({"unused", "ProtectedMemberInFinalClass", "override", "RedundantSuppression"})
+        protected void clearError() { }
+    };
+
     private final Log.Level level;
-    private final PrintStream delegate;
-    private boolean trouble;
+    private boolean shouldIndent;
 
     DelegatePrintStream(Log.Level level, PrintStream delegate) {
-        super(System.err);
+        super(delegate);
         this.level = level;
-        this.delegate = delegate;
     }
 
-    PrintStream getDelegate() {
-        return Log.enabled != null && this.level.compareTo(Log.enabled) >= 0 ? this.delegate : EmptyPrintStream.INSTANCE;
+    boolean isEnabled() {
+        return this.level != null && Log.enabled != null && this.level.compareTo(Log.enabled) >= 0;
     }
 
-    @Override
-    public void flush() {
-        this.getDelegate().flush();
+    private void printPre() {
+        if (!this.shouldIndent) return;
+
+        this.shouldIndent = false;
+        super.print(Log.getIndentation());
     }
 
-    @Override
-    public void close() {
-        this.getDelegate().close();
+    private void printPost(boolean newline) {
+        if (!newline) return;
+
+        this.shouldIndent = true;
     }
 
+
+    /* DELEGATE */
+
     @Override
-    public boolean checkError() {
-        return this.getDelegate().checkError() || this.trouble;
+    public void flush() {
+        if (!this.isEnabled()) return;
+        super.flush();
     }
 
+    @Override
+    public void close() { }
+
     @Override
     protected void setError() {
-        this.trouble = true;
+        if (!this.isEnabled()) return;
+        super.setError();
     }
 
-    @SuppressWarnings({"unused", "ProtectedMemberInFinalClass", "override", "RedundantSuppression"})
-    protected void clearError() {
-        this.trouble = false;
+    @Override
+    public void write(int b) {
+        if (!this.isEnabled()) return;
+        super.write(b);
     }
 
     @Override
-    public void write(int b) {
-        this.getDelegate().write(b);
+    public void write(byte[] b) throws IOException {
+        if (!this.isEnabled()) return;
+        super.write(b);
     }
 
     @Override
     public void write(byte[] buf, int off, int len) {
-        this.getDelegate().write(buf, off, len);
+        if (!this.isEnabled()) return;
+        super.write(buf, off, len);
     }
 
     @Override
     public void print(boolean b) {
-        this.getDelegate().print(b);
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.print(b);
     }
 
     @Override
     public void print(char c) {
-        this.getDelegate().print(c);
+        this.print(String.valueOf(c));
     }
 
     @Override
     public void print(int i) {
-        this.getDelegate().print(i);
+        this.print(String.valueOf(i));
     }
 
     @Override
     public void print(long l) {
-        this.getDelegate().print(l);
+        this.print(String.valueOf(l));
     }
 
     @Override
     public void print(float f) {
-        this.getDelegate().print(f);
+        this.print(String.valueOf(f));
     }
 
     @Override
     public void print(double d) {
-        this.getDelegate().print(d);
+        this.print(String.valueOf(d));
     }
 
     @Override
     public void print(char[] s) {
-        this.getDelegate().print(s);
+        if (!this.isEnabled()) return;
+        super.print(s);
+
+        if (s[s.length - 1] == '\n')
+            super.print(Log.getIndentation());
     }
 
     @Override
     public void print(String s) {
-        this.getDelegate().print(s);
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.print(s);
+        this.printPost(s.indexOf('\n') == s.length() - 1);
     }
 
     @Override
     public void print(Object obj) {
-        this.getDelegate().print(obj);
+        this.print(String.valueOf(obj));
     }
 
     @Override
     public void println() {
-        this.getDelegate().println();
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.println();
+        this.printPost(true);
     }
 
     @Override
     public void println(boolean x) {
-        this.getDelegate().println(x);
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.println(x);
+        this.printPost(true);
     }
 
     @Override
     public void println(char x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public void println(int x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public void println(long x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public void println(float x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public void println(double x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public void println(char[] x) {
-        this.getDelegate().println(x);
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.println(x);
+        this.printPost(true);
     }
 
     @Override
     public void println(String x) {
-        this.getDelegate().println(x);
+        if (!this.isEnabled()) return;
+        this.printPre();
+        super.println(x);
+        this.printPost(true);
     }
 
     @Override
     public void println(Object x) {
-        this.getDelegate().println(x);
+        this.println(String.valueOf(x));
     }
 
     @Override
     public PrintStream printf(String format, Object... args) {
-        return this.getDelegate().printf(format, args);
+        return this.isEnabled() ? super.printf(format, args) : this;
     }
 
     @Override
     public PrintStream printf(Locale l, String format, Object... args) {
-        return this.getDelegate().printf(l, format, args);
+        return this.isEnabled() ? super.printf(l, format, args) : this;
     }
 
     @Override
     public PrintStream format(String format, Object... args) {
-        return this.getDelegate().format(format, args);
+        return this.isEnabled() ? super.format(format, args) : this;
     }
 
     @Override
     public PrintStream format(Locale l, String format, Object... args) {
-        return this.getDelegate().format(l, format, args);
+        return this.isEnabled() ? super.format(l, format, args) : this;
     }
 
     @Override
     public PrintStream append(CharSequence csq) {
-        return this.getDelegate().append(csq);
+        return this.isEnabled() ? super.append(csq) : this;
     }
 
     @Override
     public PrintStream append(CharSequence csq, int start, int end) {
-        return this.getDelegate().append(csq, start, end);
-    }
-
-    @Override
-    public PrintStream append(char c) {
-        return this.getDelegate().append(c);
-    }
+        if (this.isEnabled()) {
+            super.append(csq, start, end);
+            if (csq.charAt(end) == '\n')
+                super.print(Log.getIndentation());
+        }
 
-    @Override
-    public void write(byte[] b) throws IOException {
-        this.getDelegate().write(b);
+        return this;
     }
 
     @Override
-    public int hashCode() {
-        return this.getDelegate().hashCode();
-    }
-
-    @SuppressWarnings("EqualsDoesntCheckParameterClass")
-    @Override
-    public boolean equals(Object obj) {
-        return this.getDelegate().equals(obj);
-    }
-
-    @Override
-    public String toString() {
-        return this.getDelegate().toString();
+    public PrintStream append(char c) {
+        return this.isEnabled() ? super.append(c) : this;
     }
 }