ConsoleService: let OutputListeners know if output is marked as log message

maarzt · ctrueden · commit 20fce37a4333 · 2017-09-21T12:15:47.000+02:00
Added a method containsLog to OutputEvent,

For OutputEvents containing a log message, the method containsLog will
return true.
diff --git a/src/main/java/org/scijava/console/ConsoleService.java b/src/main/java/org/scijava/console/ConsoleService.java
@@ -32,6 +32,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
@@ -33,13 +33,16 @@
 package org.scijava.console;
 
 import java.io.OutputStream;
+import java.io.PrintStream;
 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;
@@ -72,6 +75,13 @@ public class DefaultConsoleService extends
 
 	// -- 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:");
@@ -129,6 +139,27 @@ public void notifyListeners(final OutputEvent event) {
 			l.outputOccurred(event);
 	}
 
+	private 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
@@ -143,14 +174,23 @@ public void dispose() {
 	private synchronized void initListeners() {
 		if (listeners != null) return; // already initialized
 
-		out = new OutputStreamReporter(Source.STDOUT);
+		out = setupDefaultReporter(Source.STDOUT);
+		err = setupDefaultReporter(Source.STDERR);
 		ListenableSystemStreams.out().addOutputStream(out);
-		err = new OutputStreamReporter(Source.STDERR);
 		ListenableSystemStreams.err().addOutputStream(err);
 
 		listeners = new CopyOnWriteArrayList<>();
 	}
 
+	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);
+		});
+	}
+
 	// -- Helper methods --
 
 	/**
@@ -178,11 +218,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 --
@@ -208,12 +249,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/OutputEvent.java b/src/main/java/org/scijava/console/OutputEvent.java
@@ -68,20 +68,25 @@ public enum Source {
 	 */
 	private final boolean contextual;
 
+	/** Whether the output is a printed log message. */
+	private final boolean containsLog;
+
 	/**
 	 * Creates a new output event.
-	 *
+	 * 
 	 * @param source The source of the output.
 	 * @param output The output string.
 	 * @param contextual Whether the output was produced within this specific
 	 *          SciJava {@link Context}.
+	 * @param containsLog Whether the output is contains a log message.
 	 */
 	public OutputEvent(final Context context, final Source source,
-		final String output, final boolean contextual)
+		final String output, final boolean contextual, boolean containsLog)
 	{
 		this.source = source;
 		this.output = output;
 		this.contextual = contextual;
+		this.containsLog = containsLog;
 		setContext(context);
 		setCallingThread(Thread.currentThread());
 	}
@@ -114,6 +119,14 @@ public boolean isStderr() {
 		return source == Source.STDERR;
 	}
 
+	/**
+	 * Returns true if the source of the output is a streams returned
+	 * {@link org.scijava.console.ConsoleService#logStream(org.scijava.console.OutputEvent.Source)}
+	 */
+	public boolean containsLog() {
+		return containsLog;
+	}
+
 	// -- Object methods --
 
 	@Override
diff --git a/src/main/java/org/scijava/log/LogService.java b/src/main/java/org/scijava/log/LogService.java
@@ -34,6 +34,9 @@
 
 import org.scijava.service.SciJavaService;
 
+import java.io.PrintStream;
+import java.util.function.Function;
+
 /**
  * Interface for the logging service.
  * <p>
@@ -75,6 +78,12 @@ public interface LogService extends SciJavaService, Logger {
 	 */
 	void setLevelForLogger(String source, int level);
 
+	/**
+	 * If the a LogService writes the log messages to streams,
+	 * it should implement this method for setting the output streams.
+	 */
+	default void setPrintStreams(Function<Integer, PrintStream> levelToStream) {}
+
 	// -- Deprecated --
 
 	/** @deprecated Use {@link LogLevel#NONE}. */
@@ -95,4 +104,5 @@ public interface LogService extends SciJavaService, Logger {
 	/** @deprecated Use {@link LogLevel#TRACE}. */
 	@Deprecated
 	int TRACE = LogLevel.TRACE;
+
 }
diff --git a/src/main/java/org/scijava/log/StderrLogService.java b/src/main/java/org/scijava/log/StderrLogService.java
@@ -56,6 +56,7 @@ public class StderrLogService extends AbstractLogService {
 	private Function<Integer, PrintStream> levelToStream =
 		level -> (level <= LogLevel.WARN) ? System.err : System.out;
 
+	@Override
 	public void setPrintStreams(Function<Integer, PrintStream> levelToStream) {
 		this.levelToStream = levelToStream;
 	}
diff --git a/src/test/java/org/scijava/console/ConsoleServiceTest.java b/src/test/java/org/scijava/console/ConsoleServiceTest.java
@@ -36,6 +36,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
@@ -49,6 +50,8 @@
 import org.scijava.Context;
 import org.scijava.Priority;
 import org.scijava.console.OutputEvent.Source;
+import org.scijava.convert.ConvertService;
+import org.scijava.log.LogService;
 import org.scijava.plugin.Plugin;
 import org.scijava.thread.ThreadService;
 
@@ -208,6 +211,25 @@ public void testMultipleContextOutput() throws InterruptedException,
 		assertOutputEvent(Source.STDERR, c2InvokeErr, true, events2.get(5));
 	}
 
+	@Test
+	public void testLogToStream() {
+		final Context context = new Context(LogService.class, ConsoleService.class);
+		final ConsoleService consoleService = context.getService(ConsoleService.class);
+		final LogService logService = context.getService(LogService.class);
+		final ArrayList<OutputEvent> events = new ArrayList<>();
+		final OutputListener outputListener = new OutputTracker(events);
+
+		consoleService.addOutputListener(outputListener);
+		logService.warn("Hello");
+		System.out.print("World");
+		consoleService.removeOutputListener(outputListener);
+
+		assertEquals(2, events.size());
+		assertTrue(events.get(0).containsLog());
+		assertTrue(events.get(0).isContextual());
+		assertFalse(events.get(1).containsLog());
+	}
+
 	// -- Helper methods --
 
 	private void assertOutputEvent(final Source source, final String output,

Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,7 @@ public class StderrLogService extends AbstractLogService {`
`56`	`56`	`private Function<Integer, PrintStream> levelToStream =`
`57`	`57`	`level -> (level <= LogLevel.WARN) ? System.err : System.out;`
`58`	`58`
	`59`	`+ @Override`
`59`	`60`	`public void setPrintStreams(Function<Integer, PrintStream> levelToStream) {`
`60`	`61`	`this.levelToStream = levelToStream;`
`61`	`62`	`}`