Add tree-like output of nested exceptions to MultitargetException (for Throwable.printStackTrace)

vsilaev · vsilaev · commit 7f91d056f210 · 2019-11-27T06:43:44.000+03:00
diff --git a/src/main/java/net/tascalate/concurrent/MultitargetException.java b/src/main/java/net/tascalate/concurrent/MultitargetException.java
@@ -15,21 +15,31 @@
  */
 package net.tascalate.concurrent;
 
+import java.io.IOException;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
 public class MultitargetException extends Exception {
-    final private static long serialVersionUID = 1L;
+    private final static long serialVersionUID = 1L;
 
-    final private List<Throwable> exceptions;
+    private final List<Throwable> exceptions;
 
-    public MultitargetException(final List<Throwable> exceptions) {
-        this.exceptions = exceptions;
+    public MultitargetException(List<Throwable> exceptions) {
+        this.exceptions = exceptions == null ? 
+            Collections.emptyList() 
+            : 
+            Collections.unmodifiableList(exceptions);
     }
 
     public List<Throwable> getExceptions() {
-        return Collections.unmodifiableList(exceptions);
+        return exceptions;
     }
     
     Optional<Throwable> getFirstException() {
@@ -39,4 +49,55 @@ Optional<Throwable> getFirstException() {
     public static MultitargetException of(final Throwable exception) {
         return new MultitargetException(Collections.singletonList(exception));
     }
+    
+    @Override
+    public void printStackTrace(PrintStream s) {
+        super.printStackTrace(s);
+        printExceptions(s, (ex, padding) -> {
+            PrintStream ps = new PrintStream(new PaddedOutputStream(s, padding)); 
+            ex.printStackTrace(ps);       
+        });
+    }
+    
+    @Override
+    public void printStackTrace(PrintWriter w) {
+        super.printStackTrace(w);
+        printExceptions(w, (ex, padding) -> {
+            PrintWriter pw = new PrintWriter(new PaddedWriter(w, padding), true); 
+            ex.printStackTrace(pw);          
+        });
+    }
+    
+    private <O extends Appendable> void printExceptions(O out, BiConsumer<Throwable, String> nestedExceptionPrinter) {
+        int idx = 0;
+        int n = ((int)Math.log10(exceptions.size()) + 1);
+        String idxPadder = "%0" + n + "d";
+        String padding =  String.format("\t %1$-" + n + "s  ... ", ""); 
+        Consumer<Throwable> printer = ex -> nestedExceptionPrinter.accept(ex, padding);
+        for (Throwable e : exceptions) {
+            if (null == e) {
+                idx++;
+                continue;
+            }
+            try {
+                printException(String.format(idxPadder, idx++), e, out, printer);
+            } catch (IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }        
+    }
+    
+    private static <O extends Appendable> void printException(String idx, Throwable ex, O out, Consumer<Throwable> nestedExceptionPrinter) throws IOException {
+        out.append("\t[");
+        out.append(idx);
+        out.append("] -> ");
+        if (null == ex) {
+            out.append("<NO ERROR>");
+            out.append(NEW_LINE);
+        } else {
+            nestedExceptionPrinter.accept(ex);
+        }
+    }
+    
+    private static final String NEW_LINE = System.lineSeparator();
 }
diff --git a/src/main/java/net/tascalate/concurrent/PaddedOutputStream.java b/src/main/java/net/tascalate/concurrent/PaddedOutputStream.java
@@ -0,0 +1,85 @@
+/**
+ * Copyright 2015-2019 Valery Silaev (http://vsilaev.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.tascalate.concurrent;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+
+class PaddedOutputStream extends OutputStream {
+    private final OutputStream delegate;
+    private final byte[] padding;
+    
+    private volatile boolean needPadding = false;
+    
+    public PaddedOutputStream(OutputStream delegate, String padding) {
+        this.delegate = delegate;
+        this.padding = padding.getBytes(Charset.defaultCharset());
+    }
+
+    private void writePaddingIfNecessary() throws IOException {
+        if (needPadding) {
+            delegate.write(padding);
+            needPadding = false;
+        }
+    }
+    
+    @Override
+    public void write(int b) throws IOException {
+        if (b != 0xD && b!= 0xA) {
+            writePaddingIfNecessary();
+        }
+        if (b == 0xD || b == 0xA) {
+            needPadding = true;
+        }
+        delegate.write(b);
+    }
+    
+    @Override
+    public void write(byte[] b, int off, int len) throws IOException {
+        writePaddingIfNecessary();
+        int from = off;
+        boolean needPadding = false;
+        for (int idx = off; idx < len; idx++) {
+            if (b[idx] == 0xD || b[idx] == 0xA) {
+                needPadding = true;
+            } else if (needPadding) {
+                if (from < idx) {
+                    delegate.write(b, from, idx - from + 1);
+                }
+                delegate.write(padding);
+                needPadding = false;
+                from = idx + 1;
+            }
+        }
+        if (from < len) {
+            delegate.write(b, from, len);
+        }
+        this.needPadding = needPadding;
+    }
+
+    @Override
+    public void flush() throws IOException {
+        delegate.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        try (OutputStream stream = delegate) {
+            flush();
+        }
+    }
+}
diff --git a/src/main/java/net/tascalate/concurrent/PaddedWriter.java b/src/main/java/net/tascalate/concurrent/PaddedWriter.java
@@ -0,0 +1,84 @@
+/**
+ * Copyright 2015-2019 Valery Silaev (http://vsilaev.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.tascalate.concurrent;
+
+import java.io.IOException;
+import java.io.Writer;
+
+public class PaddedWriter extends Writer {
+    private final Writer delegate;
+    private final char[] padding;
+    
+    private volatile boolean needPadding = false;
+    
+    public PaddedWriter(Writer delegate, String padding) {
+        this.delegate = delegate;
+        this.padding = padding.toCharArray();
+    }
+
+    private void writePaddingIfNecessary() throws IOException {
+        if (needPadding) {
+            delegate.write(padding);
+            needPadding = false;
+        }
+    }
+    
+    @Override
+    public void write(int b) throws IOException {
+        if (b != 0xD && b!= 0xA) {
+            writePaddingIfNecessary();
+        }
+        if (b == 0xD || b == 0xA) {
+            needPadding = true;
+        }
+        delegate.write(b);
+    }
+
+    @Override
+    public void write(char[] b, int off, int len) throws IOException {
+        writePaddingIfNecessary();
+        int from = off;
+        boolean needPadding = false;
+        for (int idx = off; idx < len; idx++) {
+            if (b[idx] == 0xD || b[idx] == 0xA) {
+                needPadding = true;
+            } else if (needPadding) {
+                if (from < idx) {
+                    delegate.write(b, from, idx - from + 1);
+                }
+                delegate.write(padding);
+                needPadding = false;
+                from = idx + 1;
+            }
+        }
+        if (from < len) {
+            delegate.write(b, from, len);
+        }
+        this.needPadding = needPadding;
+    }
+
+    @Override
+    public void flush() throws IOException {
+        delegate.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        try (Writer writer = delegate) {
+            flush();
+        }
+    }
+}
diff --git a/src/test/java/net/tascalate/concurrent/TestMultitargetExceptionTraces.java b/src/test/java/net/tascalate/concurrent/TestMultitargetExceptionTraces.java
@@ -0,0 +1,64 @@
+package net.tascalate.concurrent;
+
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class TestMultitargetExceptionTraces {
+
+    
+    public static void main(String[] argv) {
+        Exception e = err();
+        e.printStackTrace(new PrintWriter(System.err, true));
+    }
+    
+    static Exception err() {
+        return err_1();
+    }
+    
+    static Exception err_1() {
+        MultitargetException e = new MultitargetException(Arrays.asList(
+            null, 
+            null, 
+            b(), null, 
+            a(), null, 
+            new MultitargetException(Arrays.asList(c(), b()))
+        ));
+        e.fillInStackTrace();
+        return e;
+    }
+    
+    static Throwable a() {
+        Exception e = new IllegalArgumentException("Something wrong", b());
+        e.fillInStackTrace();
+        return e;
+    }
+    
+    static Throwable b() {
+        return b_1();
+    }
+    
+    static Throwable b_1() {
+        return b_2();
+    }
+    
+    static Throwable b_2() {
+        Throwable e = new NoSuchMethodError("Data not found");
+        e.fillInStackTrace();
+        return e;
+    }
+    
+    static Throwable c() {
+        return c_1();
+    }
+    
+    static Throwable c_1() {
+        return c_2();
+    }
+    
+    static Exception c_2() {
+        Exception e = new IllegalStateException("State is forbidden");
+        e.fillInStackTrace();
+        return e;
+    }
+
+}
