Make ReverseFileReader use Paths.

Change-Id: I921a395e088846216650d1ac14207cb915a6bb8c
Reviewed-on: http://gerrit.dmdirc.com/4045
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/util/io/ReverseFileReader.java

 package com.dmdirc.util.io;
 
 import java.io.EOFException;
-import java.io.File;
 import java.io.IOException;
-import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.SeekableByteChannel;
 import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.Stack;
 
  */
 public class ReverseFileReader {
 
+    /** Path to the file we're reading. */
+    private final Path file;
     /** File to manipulate. */
-    private RandomAccessFile file;
-
+    private SeekableByteChannel byteChannel;
     /** Number of bytes to skip backwards at a time. */
     private byte seekLength = 50;
 
     /**
      * Create a new ReverseFileReader.
      *
-     * @param filename File to open.
-     * @throws SecurityException If a security manager exists and its checkRead method denies read access to the file.
-     * @throws IOException If there is an error seeking to the end of the file.
-     */
-    public ReverseFileReader(final String filename) throws SecurityException, IOException {
-        file = new RandomAccessFile(filename, "r");
-        reset();
-    }
-
-    /**
-     * Create a new ReverseFileReader.
+     * @param file File to read
      *
-     * @param myFile Existing file to use.
-     * @throws SecurityException If a security manager exists and its checkRead method denies read access to the file.
+     * @throws SecurityException If a security manager exists and its checkRead method denies
+     * read access to the file.
      * @throws IOException If there is an error seeking to the end of the file.
      */
-    public ReverseFileReader(final File myFile) throws SecurityException, IOException {
-        file = new RandomAccessFile(myFile, "r");
+    public ReverseFileReader(final Path file) throws SecurityException, IOException {
+        this.file = file;
+        byteChannel = Files.newByteChannel(file, StandardOpenOption.READ);
         reset();
     }
 
      *
      * @throws IOException If there is an error seeking, or the file is closed.
      */
-    public void reset() throws IOException {
-        if (file == null) {
-            throw new IOException("File has been closed.");
+    public final void reset() throws IOException {
+        if (!byteChannel.isOpen()) {
+            throw new IOException("Channel has been closed.");
         }
-        file.seek(file.length());
+        byteChannel = Files.newByteChannel(file, StandardOpenOption.READ);
+        byteChannel.position(byteChannel.size());
     }
 
     /**
      * @throws IOException If there is an error closing the file, or if it has been closed already.
      */
     public void close() throws IOException {
-        if (file == null) {
-            throw new IOException("File has been closed.");
+        if (!byteChannel.isOpen()) {
+            throw new IOException("Channel has been closed.");
         }
-        file.close();
-        file = null;
+        byteChannel.close();
     }
 
     /**
      * @throws IOException If an error reading or seeking occured, or if the fiel is closed.
      */
     public String getNextLine() throws IOException {
-        if (file == null) {
-            throw new IOException("File has been closed.");
+        if (!byteChannel.isOpen()) {
+            throw new IOException("Channel has been closed.");
         }
         // Used to store result to output.
-
         final ArrayList<Byte> line = new ArrayList<>(seekLength);
-        // Used to store position in file pre-read
-        long fp;
-        // Used to store position in file when this is called
-        final long startfp;
-        // Used to store read bytes
-        byte[] bytes;
-        // Distance seeked
-        int seekDistance;
-
         // Check current position, if 0 we are at the start of the file
         // and should throw an exception.
-        startfp = file.getFilePointer();
+        final long startfp = byteChannel.position();
         if (startfp == 0) {
             throw new EOFException("Reached Start of file");
         }
 
         // Keep looping until we get a full line, or the end of the file
         boolean keepLooping = true;
-        boolean gotNewLine;
         while (keepLooping) {
-            gotNewLine = false;
             // Get Current Position
-            fp = file.getFilePointer();
+            long fp = byteChannel.position();
 
             // Check how far to seek backwards (seekLength or to the start of the file)
+            final int seekDistance;
             if (fp < seekLength) {
                 // Seek to the start of the file;
                 seekDistance = (int) fp;
             } else {
                 // Seek to position current-seekLength
                 seekDistance = seekLength;
-                fp = fp - seekDistance;
+                fp -= seekDistance;
             }
             // Seek!
-            file.seek(fp);
+            byteChannel.position(fp);
 
-            bytes = new byte[seekDistance];
+            final ByteBuffer bytes = ByteBuffer.allocate(seekDistance);
             // Read into the bytes array
-            file.read(bytes);
+            byteChannel.read(bytes);
 
             // And loop looking for data
             // This uses seekDistance so that only wanted data is checked.
+            boolean gotNewLine = false;
             for (int i = seekDistance - 1; i >= 0; --i) {
                 // Check for New line Character, or a non carriage-return char
-                if (bytes[i] == '\n') {
+                if (bytes.get(i) == '\n') {
                     // Seek to the location of this character and exit this loop.
-                    file.seek(fp + i);
+                    byteChannel.position(fp + i);
                     gotNewLine = true;
                     break;
-                } else if (bytes[i] != '\r') {
+                } else if (bytes.get(i) != '\r') {
                     // Add to the result, the loop will continue going.
-                    line.add(0, bytes[i]);
+                    line.add(0, bytes.get(i));
                 }
             }
 
                 // find a new line anywhere. no more loops are possible, so Treat
                 // this as "got new line"
                 gotNewLine = true;
-                file.seek(0);
+                byteChannel.position(0);
             }
 
             // Do we need to continue?
             } else {
                 // We have not found a new line anywhere,
                 // Seek to the pre-read position, and repeat.
-                file.seek(fp);
+                byteChannel.position(fp);
             }
 
         }
         final StringBuilder result = new StringBuilder();
         for (int i = 0; i < numLines; ++i) {
             try {
-                result.insert(0, "\n");
+                result.insert(0, '\n');
                 result.insert(0, getNextLine());
             } catch (IOException e) {
                 break;

test-res/com/dmdirc/util/io/test5.txt

+
+Line 1
+Line 2
+Line 3

test/com/dmdirc/util/io/ReverseFileReaderTest.java

 
 package com.dmdirc.util.io;
 
-import java.io.File;
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.nio.file.Paths;
 import java.util.Stack;
 
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class ReverseFileReaderTest {
 
     @Test
     public void testIndividual() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get(getClass().getResource("test1.txt").toURI()));
         assertEquals("Line 7", reader.getNextLine());
         assertEquals("Line 6", reader.getNextLine());
         assertEquals("Line 5", reader.getNextLine());
     @Test
     public void testCarriageReturn() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test4.txt").toURI()));
+                Paths.get((getClass().getResource("test4.txt").toURI())));
         reader.getNextLine();
         assertEquals("Normal line", reader.getNextLine());
         reader.close();
     @Test
     public void testLongLine() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test4.txt").toURI()));
+                Paths.get((getClass().getResource("test4.txt").toURI())));
         assertEquals("This is a line that is longer than 50 characters, so " +
                 "should cause the reader to have to scan back multiple times.",
                 reader.getNextLine());
     @Test
     public void testStack() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         final Stack<String> lines = reader.getLines(10);
 
         assertEquals(7, lines.size());
     @Test
     public void testSmallStack() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         final Stack<String> lines = reader.getLines(3);
 
         assertEquals(3, lines.size());
         reader.close();
     }
 
+    @Test
+    public void testgetLinesAsString() throws IOException, URISyntaxException {
+        final ReverseFileReader reader = new ReverseFileReader(
+                Paths.get((getClass().getResource("test5.txt").toURI())));
+        final String lines = reader.getLinesAsString(3);
+        assertEquals("Line 1\nLine 2\nLine 3\n", lines);
+        reader.close();
+    }
+
+    @Test
+    public void testgetLinesAsStringLeadingNewline() throws IOException, URISyntaxException {
+        final ReverseFileReader reader = new ReverseFileReader(
+                Paths.get((getClass().getResource("test5.txt").toURI())));
+        final String lines = reader.getLinesAsString(4);
+        assertEquals("Line 1\nLine 2\nLine 3\n", lines);
+        reader.close();
+    }
+
+    @Test
+    public void testIllegalGetLinesAsString() throws IOException, URISyntaxException {
+        final ReverseFileReader reader = new ReverseFileReader(
+                Paths.get((getClass().getResource("test5.txt").toURI())));
+        reader.close();
+        final String lines = reader.getLinesAsString(4);
+        assertEquals("", lines);
+    }
+
     @Test
     public void testReset() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         assertEquals("Line 7", reader.getNextLine());
         assertEquals("Line 6", reader.getNextLine());
         reader.reset();
     @Test(expected=IOException.class)
     public void testIllegalClose() throws URISyntaxException, IOException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         reader.close();
         reader.close();
     }
     @Test(expected=IOException.class)
     public void testIllegalReset() throws URISyntaxException, IOException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         reader.close();
         reader.reset();
     }
     @Test(expected=IOException.class)
     public void testIllegalGetNextLine() throws URISyntaxException, IOException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         reader.close();
         reader.getNextLine();
     }
     @Test
     public void testSeekLength() throws IOException, URISyntaxException {
         final ReverseFileReader reader = new ReverseFileReader(
-                new File(getClass().getResource("test1.txt").toURI()));
+                Paths.get((getClass().getResource("test1.txt").toURI())));
         reader.setSeekLength((byte) 100);
         assertEquals((byte) 100, reader.getSeekLength());
     }