support for setting writers to capture the matlab process stdout and

stderr to ease debugging in some cases

Author: subes

src/matlabcontrol/MatlabProxyFactoryOptions.java

@@ -6,6 +6,7 @@
 package matlabcontrol;
 
 import java.io.File;
+import java.io.Writer;
 import java.util.concurrent.atomic.AtomicLong;
 
 import matlabcontrol.MatlabProxyFactory.CopyPasteCallback;
@@ -32,6 +33,8 @@ public class MatlabProxyFactoryOptions {
 	private final String _licenseFile;
 	private final boolean _useSingleCompThread;
 	private final int _port;
+	private final Writer _inputWriter;
+	private final Writer _errorWriter;
 
 	private MatlabProxyFactoryOptions(Builder options) {
 		_matlabLocation = options._matlabLocation;
@@ -46,6 +49,8 @@ private MatlabProxyFactoryOptions(Builder options) {
 		_licenseFile = options._licenseFile;
 		_useSingleCompThread = options._useSingleCompThread;
 		_port = options._port;
+		_inputWriter = options._inputWriter;
+		_errorWriter = options._errorWriter;
 	}
 
 	String getMatlabLocation() {
@@ -95,6 +100,14 @@ boolean getUseSingleComputationalThread() {
 	int getPort() {
 		return _port;
 	}
+	
+	public Writer getInputWriter() {
+		return _inputWriter;
+	}
+
+	public Writer getErrorWriter() {
+		return _errorWriter;
+	}
 
 	/**
 	 * Creates instances of {@link MatlabProxyFactoryOptions}. Any and all of these properties may be left unset, if so
@@ -127,6 +140,8 @@ public static class Builder {
 		private volatile String _licenseFile = null;
 		private volatile boolean _useSingleCompThread = false;
 		private volatile int _port = 2100;
+		private volatile Writer _inputWriter;
+		private volatile Writer _errorWriter;
 
 		//Assigning to a long is not atomic, so use an AtomicLong so that a thread always sees an intended value
 		private final AtomicLong _proxyTimeout = new AtomicLong(180000L);
@@ -386,6 +401,30 @@ public final Builder setPort(int port) {
 
 			return this;
 		}
+		
+		/**
+		 * Sets the input writer where the standard output of the created matlab process is written to.
+		 * This is only used when an actual process is spawned for the matlab proxy instance.
+		 * 
+		 * @param inputWriter
+		 */
+		public final Builder setInputWriter(Writer inputWriter){
+			_inputWriter = inputWriter;
+			
+			return this;
+		}
+		
+		/**
+		 * Sets the error writer where the error output of the created matlab process is written to. 
+		 * This is only used when an actual process is spawned for the matlab proxy instance.
+		 * 
+		 * @param inputWriter
+		 */
+		public final Builder setErrorWriter(Writer errorWriter){
+			_errorWriter = errorWriter;
+			
+			return this;
+		}
 
 		/**
 		 * Builds a {@code MatlabProxyFactoryOptions} instance.
@@ -396,4 +435,5 @@ public final MatlabProxyFactoryOptions build() {
 			return new MatlabProxyFactoryOptions(this);
 		}
 	}
+
 }

src/matlabcontrol/RemoteMatlabProxyFactory.java

@@ -7,6 +7,9 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.Writer;
 import java.rmi.AlreadyBoundException;
 import java.rmi.NoSuchObjectException;
 import java.rmi.NotBoundException;
@@ -270,8 +273,8 @@ private Process createProcess(RemoteRequestReceiver receiver) throws MatlabConne
 
 			//If running under UNIX and MATLAB is hidden these streams need to be read so that MATLAB does not block
 			if (_options.getHidden() && !Configuration.isWindows()) {
-				new ProcessStreamDrainer(process.getInputStream(), "Input").start();
-				new ProcessStreamDrainer(process.getErrorStream(), "Error").start();
+				new ProcessStreamDrainer(process.getInputStream(), "Input", _options.getInputWriter()).start();
+				new ProcessStreamDrainer(process.getErrorStream(), "Error", _options.getErrorWriter()).start();
 			}
 
 			return process;
@@ -309,10 +312,12 @@ private String getRunArg(RemoteRequestReceiver receiver) throws MatlabConnection
 	 * blocking.
 	 */
 	private static class ProcessStreamDrainer extends Thread {
-		private final InputStream _stream;
+		private final Reader _reader;
+		private final Writer _writer;
 
-		private ProcessStreamDrainer(InputStream stream, String type) {
-			_stream = stream;
+		private ProcessStreamDrainer(InputStream stream, String type, Writer writer) {
+			_reader = new InputStreamReader(stream);
+			_writer = writer;
 
 			this.setDaemon(true);
 			this.setName("ProcessStreamDrainer - " + type);
@@ -321,14 +326,21 @@ private ProcessStreamDrainer(InputStream stream, String type) {
 		@Override
 		public void run() {
 			try {
-				byte[] buffer = new byte[1024];
-				while (_stream.read(buffer) != -1)
-					;
+				char[] buffer = new char[1024];
+				if(_writer != null){
+					while (_reader.read(buffer) != -1){
+						_writer.write(buffer);
+					}
+				}else{
+					while (_reader.read(buffer) != -1)
+						;
+				}
 			} catch (IOException e) {
 				e.printStackTrace();
 				throw new RuntimeException(e);
 			}
 		}
+		
 	}
 
 	/**