scijava · maarzt · Dec 14, 2016 · Dec 14, 2016 · Dec 13, 2016 · Dec 13, 2016
diff --git a/src/main/java/org/scijava/console/ConsoleService.java b/src/main/java/org/scijava/console/ConsoleService.java
@@ -31,6 +31,7 @@
 
 package org.scijava.console;
 
+import java.io.PrintStream;
 import java.util.LinkedList;
 
 import org.scijava.plugin.HandlerService;

diff --git a/src/main/java/org/scijava/console/DefaultConsoleService.java b/src/main/java/org/scijava/console/DefaultConsoleService.java
@@ -36,9 +36,12 @@
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.BiFunction;
 
 import org.scijava.Context;
 import org.scijava.console.OutputEvent.Source;
+import org.scijava.log.LogLevel;
 import org.scijava.log.LogService;
 import org.scijava.plugin.AbstractHandlerService;
 import org.scijava.plugin.Parameter;
@@ -64,16 +67,20 @@ public class DefaultConsoleService extends
 	@Parameter
 	private LogService log;
 
-	private MultiPrintStream sysout, syserr;
 	private OutputStreamReporter out, err;
 
 	/** List of listeners for {@code stdout} and {@code stderr} output. */
-	private ArrayList<OutputListener> listeners;
-
-	private OutputListener[] cachedListeners;
+	private List<OutputListener> listeners;
 
 	// -- ConsoleService methods --
 
+	@Override
+	public void initialize() {
+		PrintStream logErr = logStream(Source.STDERR);
+		PrintStream logOut = logStream(Source.STDOUT);
+		log.setPrintStreams(level -> (level <= LogLevel.WARN) ? logErr : logOut);
+	}
+
 	@Override
 	public void processArgs(final String... args) {
 		log.debug("Received command line arguments:");
@@ -115,35 +122,49 @@ public void processArgs(final String... args) {
 	@Override
 	public void addOutputListener(final OutputListener l) {
 		if (listeners == null) initListeners();
-		synchronized (listeners) {
-			listeners.add(l);
-			cacheListeners();
-		}
+		listeners.add(l);
 	}
 
 	@Override
 	public void removeOutputListener(final OutputListener l) {
 		if (listeners == null) initListeners();
-		synchronized (listeners) {
-			listeners.remove(l);
-			cacheListeners();
-		}
+		listeners.remove(l);
 	}
 
 	@Override
 	public void notifyListeners(final OutputEvent event) {
 		if (listeners == null) initListeners();
-		final OutputListener[] toNotify = cachedListeners;
-		for (final OutputListener l : toNotify)
+		for (final OutputListener l : listeners)
 			l.outputOccurred(event);
 	}
 
+	PrintStream logStream(Source source) {
+		OutputStream a = getBypassingStream(source);
+		OutputStream b = new OutputStreamReporter((relevance, text) -> {
+			final Context context = getContext();
+			final boolean contextual = true;
+			final boolean containsLog = true;
+			return new OutputEvent(context, source, text, contextual, containsLog);
+		});
+		return new PrintStream(new MultiOutputStream(a, b));
+	}
+
+	private OutputStream getBypassingStream(Source source) {
+		switch (source) {
+			case STDOUT:
+				return ListenableSystemStreams.out().bypass();
+			case STDERR:
+				return ListenableSystemStreams.err().bypass();
+		}
+		throw new AssertionError();
+	}
+
 	// -- Disposable methods --
 
 	@Override
 	public void dispose() {
-		if (out != null) sysout.getParent().removeOutputStream(out);
-		if (err != null) syserr.getParent().removeOutputStream(err);
+		if(out != null) ListenableSystemStreams.out().removeOutputStream(out);
+		if(err != null) ListenableSystemStreams.err().removeOutputStream(err);
 	}
 
 	// -- Helper methods - lazy initialization --
@@ -152,30 +173,24 @@ public void dispose() {
 	private synchronized void initListeners() {
 		if (listeners != null) return; // already initialized
 
-		sysout = multiPrintStream(System.out);
-		if (System.out != sysout) System.setOut(sysout);
-		out = new OutputStreamReporter(Source.STDOUT);
-		sysout.getParent().addOutputStream(out);
-
-		syserr = multiPrintStream(System.err);
-		if (System.err != syserr) System.setErr(syserr);
-		err = new OutputStreamReporter(Source.STDERR);
-		syserr.getParent().addOutputStream(err);
+		out = setupDefaultReporter(Source.STDOUT);
+		err = setupDefaultReporter(Source.STDERR);
+		ListenableSystemStreams.out().addOutputStream(out);
+		ListenableSystemStreams.err().addOutputStream(err);
 
-		listeners = new ArrayList<>();
-		cachedListeners = listeners.toArray(new OutputListener[0]);
+		listeners = new CopyOnWriteArrayList<>();
 	}
 
-	// -- Helper methods --
-
-	private void cacheListeners() {
-		cachedListeners = listeners.toArray(new OutputListener[listeners.size()]);
+	private OutputStreamReporter setupDefaultReporter(Source source) {
+		return new OutputStreamReporter((relevance, output) -> {
+			final Context context = getContext();
+			final boolean contextual = relevance == ThreadContext.SAME;
+			final boolean containsLog = false;
+			return new OutputEvent(context, source, output, contextual, containsLog);
+		});
 	}
 
-	private MultiPrintStream multiPrintStream(final PrintStream ps) {
-		if (ps instanceof MultiPrintStream) return (MultiPrintStream) ps;
-		return new MultiPrintStream(ps);
-	}
+	// -- Helper methods --
 
 	/**
 	 * Gets whether two lists have exactly the same elements in them.
@@ -202,11 +217,12 @@ private boolean sameElements(final List<String> l1,
 	 */
 	private class OutputStreamReporter extends OutputStream {
 
-		/** Source of the output stream; i.e., {@code stdout} or {@code stderr}. */
-		private final Source source;
+		private final BiFunction<ThreadContext, String, OutputEvent> eventFactory;
 
-		public OutputStreamReporter(final Source source) {
-			this.source = source;
+		public OutputStreamReporter(
+			BiFunction<ThreadContext, String, OutputEvent> eventFactory)
+		{
+			this.eventFactory = eventFactory;
 		}
 
 		// -- OutputStream methods --
@@ -232,12 +248,8 @@ private ThreadContext getRelevance() {
 		}
 
 		private void publish(final ThreadContext relevance, final String output) {
-			final Context context = getContext();
-			final boolean contextual = relevance == ThreadContext.SAME;
-			final OutputEvent event =
-				new OutputEvent(context, source, output, contextual);
+			final OutputEvent event = eventFactory.apply(relevance, output);
 			notifyListeners(event);
 		}
 	}
-
 }
diff --git a/src/main/java/org/scijava/console/ListenableSystemStreams.java b/src/main/java/org/scijava/console/ListenableSystemStreams.java
@@ -0,0 +1,94 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.console;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.function.Consumer;
+
+/**
+ * ListenableSystemStream allows listing to System.out and System.err.
+ *
+ * @author Matthais Arzt
+ */
+class ListenableSystemStreams {
+
+	private ListenableSystemStreams() {
+		// prevent from being initialized
+	}
+
+	public static ListenableStream out() {
+		return LazyHolder.OUT;
+	}
+
+	public static ListenableStream err() {
+		return LazyHolder.ERR;
+	}
+
+	private static class LazyHolder { // using idiom for lazy-loaded singleton
+
+		private static final ListenableStream OUT = new ListenableStream(System.out,
+			System::setOut);
+		private static final ListenableStream ERR = new ListenableStream(System.err,
+			System::setErr);
+	}
+
+	public static class ListenableStream {
+
+		private final PrintStream out;
+		private PrintStream in;
+		private final MultiOutputStream multi;
+
+		ListenableStream(PrintStream out, Consumer<PrintStream> streamSetter) {
+			this.out = out;
+			this.multi = new MultiOutputStream(out);
+			this.in = new PrintStream(multi);
+			streamSetter.accept(in);
+		}
+
+		public void addOutputStream(OutputStream os) {
+			multi.addOutputStream(os);
+		}
+
+		public void removeOutputStream(OutputStream os) {
+			multi.removeOutputStream(os);
+		}
+
+		public PrintStream bypass() {
+			return out;
+		}
+
+		public PrintStream stream() {
+			return in;
+		}
+	}
+}
diff --git a/src/main/java/org/scijava/console/MultiOutputStream.java b/src/main/java/org/scijava/console/MultiOutputStream.java
@@ -34,6 +34,8 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
  * A {@code MultiOutputStream} is a collection of constituent
@@ -48,81 +50,59 @@
  */
 public class MultiOutputStream extends OutputStream {
 
-	private final ArrayList<OutputStream> streams;
-
-	private OutputStream[] cachedStreams;
+	private final List<OutputStream> streams;
 
 	/**
 	 * Forwards output to a list of output streams.
 	 *
 	 * @param os Output streams which will receive this stream's output.
 	 */
 	public MultiOutputStream(final OutputStream... os) {
-		streams = new ArrayList<>(os.length);
-		for (int i = 0; i < os.length; i++) {
-			streams.add(os[i]);
-		}
-		cacheStreams();
+		streams = new CopyOnWriteArrayList<>(os);
 	}
 
 	// -- MultiOutputStream methods --
 
 	/** Adds an output stream to those receiving this stream's output. */
 	public void addOutputStream(final OutputStream os) {
-		synchronized (streams) {
-			streams.add(os);
-			cacheStreams();
-		}
+		streams.add(os);
 	}
 
 	/** Removes an output stream from those receiving this stream's output. */
 	public void removeOutputStream(final OutputStream os) {
-		synchronized (streams) {
-			streams.remove(os);
-			cacheStreams();
-		}
+		streams.remove(os);
 	}
 
 	// -- OutputStream methods --
 
 	@Override
 	public void write(final int b) throws IOException {
-		final OutputStream[] toWrite = cachedStreams;
-		for (final OutputStream stream : toWrite)
+		for (final OutputStream stream : streams)
 			stream.write(b);
 	}
 
 	@Override
 	public void write(final byte[] buf, final int off, final int len)
 		throws IOException
 	{
-		final OutputStream[] toWrite = cachedStreams;
-		for (final OutputStream stream : toWrite)
+		for (final OutputStream stream : streams)
 			stream.write(buf, off, len);
 	}
 
 	// -- Closeable methods --
 
 	@Override
 	public void close() throws IOException {
-		final OutputStream[] toClose = cachedStreams;
-		for (final OutputStream stream : toClose)
+		for (final OutputStream stream : streams)
 			stream.close();
 	}
 
 	// -- Flushable methods --
 
 	@Override
 	public void flush() throws IOException {
-		final OutputStream[] toFlush = cachedStreams;
-		for (final OutputStream stream : toFlush)
+		for (final OutputStream stream : streams)
 			stream.flush();
 	}
 
-	// -- Helper methods --
-
-	private void cacheStreams() {
-		cachedStreams = streams.toArray(new OutputStream[streams.size()]);
-	}
-
 }