org.eclipse.tracecompass.tmf.core/src/org/eclipse/linuxtools/tmf/core/io/BufferedRandomAccessFile.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 2014 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation, based on article by Nick Zhang
  11  *                   (http://www.javaworld.com/javatips/jw-javatip26.html)
  12  ******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.io;
  15
  16 import java.io.File;
  17 import java.io.IOException;
  18 import java.io.RandomAccessFile;
  19 import java.nio.charset.Charset;
  20
  21 /**
  22  * A class to mitigate the Java I/O inefficiency of RandomAccessFile.
  23  *
  24  * @version 1.0
  25  * @author Patrick Tasse
  26  */
  27 public class BufferedRandomAccessFile extends RandomAccessFile {
  28
  29     private static final int DEFAULT_BUF_SIZE = 8192;
  30     private static final Charset CHARSET_UTF8 = Charset.forName("UTF-8"); //$NON-NLS-1$
  31
  32     private final int BUF_SIZE;
  33     private final byte buffer[];
  34     private int buf_end = 0;
  35     private int buf_pos = 0;
  36     private long real_pos = 0;
  37     private final StringBuilder sb = new StringBuilder();
  38
  39     /**
  40      * Constructor using the default buffer size
  41      *
  42      * @param name
  43      *            File path. This is passed as-is to the RandomAccessFile's
  44      *            constructor.
  45      * @param mode
  46      *            File open mode ("r", "rw", etc.). This is passed as-is to
  47      *            RandomAccessFile's constructor.
  48      * @throws IOException
  49      *             If the file was not found or couldn't be opened with the
  50      *             request permissions
  51      */
  52     public BufferedRandomAccessFile(String name, String mode) throws IOException {
  53         this(name, mode, DEFAULT_BUF_SIZE);
  54     }
  55
  56     /**
  57      * Constructor using the default buffer size
  58      *
  59      * @param file
  60      *            File object. This is passed as-is to the RandomAccessFile's
  61      *            constructor.
  62      * @param mode
  63      *            File open mode ("r", "rw", etc.). This is passed as-is to
  64      *            RandomAccessFile's constructor.
  65      * @throws IOException
  66      *             If the file was not found or couldn't be opened with the
  67      *             request permissions
  68      */
  69     public BufferedRandomAccessFile(File file, String mode) throws IOException {
  70         this(file, mode, DEFAULT_BUF_SIZE);
  71     }
  72
  73     /**
  74      * Standard constructor.
  75      *
  76      * @param name
  77      *            File path. This is passed as-is to the RandomAccessFile's
  78      *            constructor.
  79      * @param mode
  80      *            File open mode ("r", "rw", etc.). This is passed as-is to
  81      *            RandomAccessFile's constructor.
  82      * @param bufsize
  83      *            Buffer size to use, in bytes
  84      * @throws IOException
  85      *             If the file was not found or couldn't be opened with the
  86      *             request permissions
  87      */
  88     public BufferedRandomAccessFile(String name, String mode, int bufsize) throws IOException {
  89         super(name, mode);
  90         invalidate();
  91         BUF_SIZE = bufsize;
  92         buffer = new byte[BUF_SIZE];
  93     }
  94
  95     /**
  96      * Standard constructor.
  97      *
  98      * @param file
  99      *            File object. This is passed as-is to the RandomAccessFile's
 100      *            constructor.
 101      * @param mode
 102      *            File open mode ("r", "rw", etc.). This is passed as-is to
 103      *            RandomAccessFile's constructor.
 104      * @param bufsize
 105      *            Buffer size to use, in bytes
 106      * @throws IOException
 107      *             If the file was not found or couldn't be opened with the
 108      *             request permissions
 109      */
 110     public BufferedRandomAccessFile(File file, String mode, int bufsize) throws IOException {
 111         super(file, mode);
 112         invalidate();
 113         BUF_SIZE = bufsize;
 114         buffer = new byte[BUF_SIZE];
 115     }
 116
 117     @Override
 118     public final int read() throws IOException {
 119         if (buf_pos >= buf_end) {
 120             if (fillBuffer() < 0) {
 121                 return -1;
 122             }
 123         }
 124         if (buf_end == 0) {
 125             return -1;
 126         }
 127         return (buffer[buf_pos++] & 0xff);
 128     }
 129
 130     @Override
 131     public int read(byte b[], int off, int len) throws IOException {
 132         int leftover = buf_end - buf_pos;
 133         if (len <= leftover) {
 134             System.arraycopy(buffer, buf_pos, b, off, len);
 135             buf_pos += len;
 136             return len;
 137         }
 138         for (int i = 0; i < len; i++) {
 139             int c = this.read();
 140             if (c != -1) {
 141                 b[off + i] = (byte) c;
 142             } else {
 143                 if (i == 0) {
 144                     return -1;
 145                 }
 146                 return i;
 147             }
 148         }
 149         return len;
 150     }
 151
 152     @Override
 153     public long getFilePointer() throws IOException {
 154         long l = real_pos;
 155         return (l - buf_end + buf_pos);
 156     }
 157
 158     @Override
 159     public void seek(long pos) throws IOException {
 160         int n = (int) (real_pos - pos);
 161         if (n >= 0 && n <= buf_end) {
 162             buf_pos = buf_end - n;
 163         } else {
 164             super.seek(pos);
 165             invalidate();
 166         }
 167     }
 168
 169     /**
 170      * Read the next line from the buffer (ie, until the next '\n'). The bytes
 171      * are interpreted as UTF-8 characters.
 172      *
 173      * @return The String that was read
 174      * @throws IOException
 175      *             If we failed reading the file
 176      */
 177     public final String getNextLine() throws IOException {
 178         String str = null;
 179         if (buf_end - buf_pos <= 0) {
 180             if (fillBuffer() < 0) {
 181                 return null;
 182             }
 183         }
 184         int lineend = -1;
 185         for (int i = buf_pos; i < buf_end; i++) {
 186             if (buffer[i] == '\n') {
 187                 lineend = i;
 188                 break;
 189             }
 190         }
 191         if (lineend < 0) {
 192             sb.delete(0, sb.length());
 193             int c;
 194             while (((c = read()) != -1) && (c != '\n')) {
 195                 sb.append((char) c);
 196             }
 197             if ((c == -1) && (sb.length() == 0)) {
 198                 return null;
 199             }
 200             if (sb.charAt(sb.length() - 1) == '\r') {
 201                 sb.deleteCharAt(sb.length() - 1);
 202             }
 203             return sb.toString();
 204         }
 205         if (lineend > 0 && buffer[lineend - 1] == '\r' && lineend > buf_pos) {
 206             str = new String(buffer, buf_pos, lineend - buf_pos - 1, CHARSET_UTF8);
 207         } else {
 208             str = new String(buffer, buf_pos, lineend - buf_pos, CHARSET_UTF8);
 209         }
 210         buf_pos = lineend + 1;
 211         return str;
 212     }
 213
 214     private int fillBuffer() throws IOException {
 215         int n = super.read(buffer, 0, BUF_SIZE);
 216         if (n >= 0) {
 217             real_pos += n;
 218             buf_end = n;
 219             buf_pos = 0;
 220         }
 221         return n;
 222     }
 223
 224     private void invalidate() throws IOException {
 225         buf_end = 0;
 226         buf_pos = 0;
 227         real_pos = super.getFilePointer();
 228     }
 229 }