Fix #329: Don't create empty RAF files on reading

When trying to read from a non-existing file, the FileHandle created a
RandomAccessFile, which resulted in an empty file appearing on disk.

Author: gab1one

src/main/java/org/scijava/io/handle/FileHandle.java

@@ -62,7 +62,7 @@ public class FileHandle extends AbstractDataHandle<FileLocation> {
 
 	/** Gets the random access file object backing this FileHandle. */
 	public RandomAccessFile getRandomAccessFile() throws IOException {
-		return raf();
+		return writeRaf();
 	}
 
 	public String getMode() {
@@ -101,199 +101,199 @@ public Date lastModified() {
 
 	@Override
 	public long offset() throws IOException {
-		return raf().getFilePointer();
+		return exists() ? writeRaf().getFilePointer() : 0;
 	}
 
 	@Override
 	public long length() throws IOException {
-		return exists() ? raf().length() : -1;
+		return exists() ? writeRaf().length() : -1;
 	}
 
 	@Override
 	public void setLength(final long length) throws IOException {
-		raf().setLength(length);
+		writeRaf().setLength(length);
 	}
 
 	@Override
 	public int read() throws IOException {
-		return raf().read();
+		return readRaf().read();
 	}
 
 	@Override
 	public int read(final byte[] b) throws IOException {
-		return raf().read(b);
+		return readRaf().read(b);
 	}
 
 	@Override
 	public int read(final byte[] b, final int off, final int len)
 		throws IOException
 	{
-		return raf().read(b, off, len);
+		return readRaf().read(b, off, len);
 	}
 
 	@Override
 	public void seek(final long pos) throws IOException {
-		raf().seek(pos);
+		readRaf().seek(pos);
 	}
 
 	// -- DataInput methods --
 
 	@Override
 	public boolean readBoolean() throws IOException {
-		return raf().readBoolean();
+		return readRaf().readBoolean();
 	}
 
 	@Override
 	public byte readByte() throws IOException {
-		return raf().readByte();
+		return readRaf().readByte();
 	}
 
 	@Override
 	public char readChar() throws IOException {
-		return raf().readChar();
+		return readRaf().readChar();
 	}
 
 	@Override
 	public double readDouble() throws IOException {
-		return raf().readDouble();
+		return readRaf().readDouble();
 	}
 
 	@Override
 	public float readFloat() throws IOException {
-		return raf().readFloat();
+		return readRaf().readFloat();
 	}
 
 	@Override
 	public void readFully(final byte[] b) throws IOException {
-		raf().readFully(b);
+		readRaf().readFully(b);
 	}
 
 	@Override
 	public void readFully(final byte[] b, final int off, final int len)
 		throws IOException
 	{
-		raf().readFully(b, off, len);
+		readRaf().readFully(b, off, len);
 	}
 
 	@Override
 	public int readInt() throws IOException {
-		return raf().readInt();
+		return readRaf().readInt();
 	}
 
 	@Override
 	public String readLine() throws IOException {
-		return raf().readLine();
+		return readRaf().readLine();
 	}
 
 	@Override
 	public long readLong() throws IOException {
-		return raf().readLong();
+		return readRaf().readLong();
 	}
 
 	@Override
 	public short readShort() throws IOException {
-		return raf().readShort();
+		return readRaf().readShort();
 	}
 
 	@Override
 	public int readUnsignedByte() throws IOException {
-		return raf().readUnsignedByte();
+		return readRaf().readUnsignedByte();
 	}
 
 	@Override
 	public int readUnsignedShort() throws IOException {
-		return raf().readUnsignedShort();
+		return readRaf().readUnsignedShort();
 	}
 
 	@Override
 	public String readUTF() throws IOException {
-		return raf().readUTF();
+		return readRaf().readUTF();
 	}
 
 	@Override
 	public int skipBytes(final int n) throws IOException {
-		return raf().skipBytes(n);
+		return readRaf().skipBytes(n);
 	}
 
 	// -- DataOutput methods --
 
 	@Override
 	public void write(final byte[] b) throws IOException {
-		raf().write(b);
+		writeRaf().write(b);
 	}
 
 	@Override
 	public void write(final byte[] b, final int off, final int len)
 		throws IOException
 	{
-		raf().write(b, off, len);
+		writeRaf().write(b, off, len);
 	}
 
 	@Override
 	public void write(final int b) throws IOException {
-		raf().write(b);
+		writeRaf().write(b);
 	}
 
 	@Override
 	public void writeBoolean(final boolean v) throws IOException {
-		raf().writeBoolean(v);
+		writeRaf().writeBoolean(v);
 	}
 
 	@Override
 	public void writeByte(final int v) throws IOException {
-		raf().writeByte(v);
+		writeRaf().writeByte(v);
 	}
 
 	@Override
 	public void writeBytes(final String s) throws IOException {
-		raf().writeBytes(s);
+		writeRaf().writeBytes(s);
 	}
 
 	@Override
 	public void writeChar(final int v) throws IOException {
-		raf().writeChar(v);
+		writeRaf().writeChar(v);
 	}
 
 	@Override
 	public void writeChars(final String s) throws IOException {
-		raf().writeChars(s);
+		writeRaf().writeChars(s);
 	}
 
 	@Override
 	public void writeDouble(final double v) throws IOException {
-		raf().writeDouble(v);
+		writeRaf().writeDouble(v);
 	}
 
 	@Override
 	public void writeFloat(final float v) throws IOException {
-		raf().writeFloat(v);
+		writeRaf().writeFloat(v);
 	}
 
 	@Override
 	public void writeInt(final int v) throws IOException {
-		raf().writeInt(v);
+		writeRaf().writeInt(v);
 	}
 
 	@Override
 	public void writeLong(final long v) throws IOException {
-		raf().writeLong(v);
+		writeRaf().writeLong(v);
 	}
 
 	@Override
 	public void writeShort(final int v) throws IOException {
-		raf().writeShort(v);
+		writeRaf().writeShort(v);
 	}
 
 	@Override
 	public void writeUTF(final String str) throws IOException {
-		raf().writeUTF(str);
+		writeRaf().writeUTF(str);
 	}
 
 	// -- Closeable methods --
 
 	@Override
 	public synchronized void close() throws IOException {
-		if (raf != null) raf().close();
+		if (raf != null) raf.close();
 		closed = true;
 	}
 
@@ -306,11 +306,38 @@ public Class<FileLocation> getType() {
 
 	// -- Helper methods --
 
-	private RandomAccessFile raf() throws IOException {
+	/**
+	 * Access method for the internal {@link RandomAccessFile}, that succeeds
+	 * independently of the underlying file existing on disk. This allows us to
+	 * create a new files for writing.
+	 *
+	 * @return the internal {@link RandomAccessFile} or creates if if needed.
+	 * @throws IOException if the {@link RandomAccessFile} could not be created.
+	 */
+	private RandomAccessFile writeRaf() throws IOException {
 		if (raf == null) initRAF();
 		return raf;
 	}
 
+	/**
+	 * Access method for the internal {@link RandomAccessFile}, that only succeeds
+	 * if the underlying file exists on disk. This prevents accidental creation of
+	 * empty RAF file when calling read operations on a non-existent file.
+	 *
+	 * @return the internal {@link RandomAccessFile} or creates if if needed
+	 * @throws IOException if the {@link RandomAccessFile} could not be created,
+	 *           or the backing file does not exists.
+	 */
+	private RandomAccessFile readRaf() throws IOException {
+		if (raf == null) {
+			if (!exists()) {
+				throw new IOException("Trying to read from non-existent file!");
+			}
+			initRAF();
+		}
+		return raf;
+	}
+
 	private synchronized void initRAF() throws IOException {
 		if (closed) throw new IOException("Handle already closed");
 		if (raf != null) return;