src/be/nikiroo/utils/streams/BufferedInputStream.java

   1 package be.nikiroo.utils.streams;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5 import java.util.Arrays;
   6
   7 import be.nikiroo.utils.StringUtils;
   8
   9 /**
  10  * A simple {@link InputStream} that is buffered with a bytes array.
  11  * <p>
  12  * It is mostly intended to be used as a base class to create new
  13  * {@link InputStream}s with special operation modes, and to give some default
  14  * methods.
  15  *
  16  * @author niki
  17  */
  18 public class BufferedInputStream extends InputStream {
  19         /**
  20          * The size of the internal buffer (can be different if you pass your own
  21          * buffer, of course).
  22          * <p>
  23          * A second buffer of twice the size can sometimes be created as needed for
  24          * the {@link BufferedInputStream#startsWith(byte[])} search operation.
  25          */
  26         static private final int BUFFER_SIZE = 4096;
  27
  28         /** The current position in the buffer. */
  29         protected int start;
  30         /** The index of the last usable position of the buffer. */
  31         protected int stop;
  32         /** The buffer itself. */
  33         protected byte[] buffer;
  34         /** An End-Of-File (or {@link InputStream}, here) marker. */
  35         protected boolean eof;
  36
  37         private boolean closed;
  38         private InputStream in;
  39         private int openCounter;
  40
  41         // special use, prefetched next buffer
  42         private byte[] buffer2;
  43         private int pos2;
  44         private int len2;
  45         private byte[] originalBuffer;
  46
  47         private long bytesRead;
  48
  49         /**
  50          * Create a new {@link BufferedInputStream} that wraps the given
  51          * {@link InputStream}.
  52          *
  53          * @param in
  54          *            the {@link InputStream} to wrap
  55          */
  56         public BufferedInputStream(InputStream in) {
  57                 this.in = in;
  58
  59                 this.buffer = new byte[BUFFER_SIZE];
  60                 this.originalBuffer = this.buffer;
  61                 this.start = 0;
  62                 this.stop = 0;
  63         }
  64
  65         /**
  66          * Create a new {@link BufferedInputStream} that wraps the given bytes array
  67          * as a data source.
  68          *
  69          * @param in
  70          *            the array to wrap, cannot be NULL
  71          */
  72         public BufferedInputStream(byte[] in) {
  73                 this(in, 0, in.length);
  74         }
  75
  76         /**
  77          * Create a new {@link BufferedInputStream} that wraps the given bytes array
  78          * as a data source.
  79          *
  80          * @param in
  81          *            the array to wrap, cannot be NULL
  82          * @param offset
  83          *            the offset to start the reading at
  84          * @param length
  85          *            the number of bytes to take into account in the array,
  86          *            starting from the offset
  87          *
  88          * @throws NullPointerException
  89          *             if the array is NULL
  90          * @throws IndexOutOfBoundsException
  91          *             if the offset and length do not correspond to the given array
  92          */
  93         public BufferedInputStream(byte[] in, int offset, int length) {
  94                 if (in == null) {
  95                         throw new NullPointerException();
  96                 } else if (offset < 0 || length < 0 || length > in.length - offset) {
  97                         throw new IndexOutOfBoundsException();
  98                 }
  99
 100                 this.in = null;
 101
 102                 this.buffer = in;
 103                 this.originalBuffer = this.buffer;
 104                 this.start = offset;
 105                 this.stop = length;
 106         }
 107
 108         /**
 109          * The internal buffer size (can be useful to know for search methods).
 110          *
 111          * @return the size of the internal buffer, in bytes.
 112          */
 113         public int getInternalBufferSize() {
 114                 return originalBuffer.length;
 115         }
 116
 117         /**
 118          * Return this very same {@link BufferedInputStream}, but keep a counter of
 119          * how many streams were open this way. When calling
 120          * {@link BufferedInputStream#close()}, decrease this counter if it is not
 121          * already zero instead of actually closing the stream.
 122          * <p>
 123          * You are now responsible for it &mdash; you <b>must</b> close it.
 124          * <p>
 125          * This method allows you to use a wrapping stream around this one and still
 126          * close the wrapping stream.
 127          *
 128          * @return the same stream, but you are now responsible for closing it
 129          *
 130          * @throws IOException
 131          *             in case of I/O error or if the stream is closed
 132          */
 133         public synchronized InputStream open() throws IOException {
 134                 checkClose();
 135                 openCounter++;
 136                 return this;
 137         }
 138
 139         /**
 140          * Check if the current content (until eof) is equal to the given search
 141          * term.
 142          * <p>
 143          * Note: the search term size <b>must</b> be smaller or equal the internal
 144          * buffer size.
 145          *
 146          * @param search
 147          *            the term to search for
 148          *
 149          * @return TRUE if the content that will be read starts with it
 150          *
 151          * @throws IOException
 152          *             in case of I/O error or if the size of the search term is
 153          *             greater than the internal buffer
 154          */
 155         public boolean is(String search) throws IOException {
 156                 return is(StringUtils.getBytes(search));
 157         }
 158
 159         /**
 160          * Check if the current content (until eof) is equal to the given search
 161          * term.
 162          * <p>
 163          * Note: the search term size <b>must</b> be smaller or equal the internal
 164          * buffer size.
 165          *
 166          * @param search
 167          *            the term to search for
 168          *
 169          * @return TRUE if the content that will be read starts with it
 170          *
 171          * @throws IOException
 172          *             in case of I/O error or if the size of the search term is
 173          *             greater than the internal buffer
 174          */
 175         public boolean is(byte[] search) throws IOException {
 176                 if (startsWith(search)) {
 177                         return (stop - start) == search.length;
 178                 }
 179
 180                 return false;
 181         }
 182
 183         /**
 184          * Check if the current content (what will be read next) starts with the
 185          * given search term.
 186          * <p>
 187          * Note: the search term size <b>must</b> be smaller or equal the internal
 188          * buffer size.
 189          *
 190          * @param search
 191          *            the term to search for
 192          *
 193          * @return TRUE if the content that will be read starts with it
 194          *
 195          * @throws IOException
 196          *             in case of I/O error or if the size of the search term is
 197          *             greater than the internal buffer
 198          */
 199         public boolean startsWith(String search) throws IOException {
 200                 return startsWith(StringUtils.getBytes(search));
 201         }
 202
 203         /**
 204          * Check if the current content (what will be read next) starts with the
 205          * given search term.
 206          * <p>
 207          * An empty string will always return true (unless the stream is closed,
 208          * which would throw an {@link IOException}).
 209          * <p>
 210          * Note: the search term size <b>must</b> be smaller or equal the internal
 211          * buffer size.
 212          *
 213          * @param search
 214          *            the term to search for
 215          *
 216          * @return TRUE if the content that will be read starts with it
 217          *
 218          * @throws IOException
 219          *             in case of I/O error or if the size of the search term is
 220          *             greater than the internal buffer
 221          */
 222         public boolean startsWith(byte[] search) throws IOException {
 223                 if (search.length > originalBuffer.length) {
 224                         throw new IOException(
 225                                         "This stream does not support searching for more than "
 226                                                         + buffer.length + " bytes");
 227                 }
 228
 229                 checkClose();
 230
 231                 if (available() < search.length) {
 232                         preRead();
 233                 }
 234
 235                 if (available() >= search.length) {
 236                         // Easy path
 237                         return StreamUtils.startsWith(search, buffer, start, stop);
 238                 } else if (in != null && !eof) {
 239                         // Harder path
 240                         if (buffer2 == null && buffer.length == originalBuffer.length) {
 241                                 buffer2 = Arrays.copyOf(buffer, buffer.length * 2);
 242
 243                                 pos2 = buffer.length;
 244                                 len2 = read(in, buffer2, pos2, buffer.length);
 245                                 if (len2 > 0) {
 246                                         bytesRead += len2;
 247                                 }
 248
 249                                 // Note: here, len/len2 = INDEX of last good byte
 250                                 len2 += pos2;
 251                         }
 252
 253                         return StreamUtils.startsWith(search, buffer2, pos2, len2);
 254                 }
 255
 256                 return false;
 257         }
 258
 259         /**
 260          * The number of bytes read from the under-laying {@link InputStream}.
 261          *
 262          * @return the number of bytes
 263          */
 264         public long getBytesRead() {
 265                 return bytesRead;
 266         }
 267
 268         /**
 269          * Check if this stream is spent (no more data to read or to
 270          * process).
 271          *
 272          * @return TRUE if it is
 273          *
 274          * @throws IOException
 275          *             in case of I/O error
 276          */
 277         public boolean eof() throws IOException {
 278                 if (closed) {
 279                         return true;
 280                 }
 281
 282                 preRead();
 283                 return !hasMoreData();
 284         }
 285
 286         /**
 287          * Read the whole {@link InputStream} until the end and return the number of
 288          * bytes read.
 289          *
 290          * @return the number of bytes read
 291          *
 292          * @throws IOException
 293          *             in case of I/O error
 294          */
 295         public long end() throws IOException {
 296                 long skipped = 0;
 297                 while (hasMoreData()) {
 298                         skipped += skip(buffer.length);
 299                 }
 300
 301                 return skipped;
 302         }
 303
 304         @Override
 305         public int read() throws IOException {
 306                 checkClose();
 307
 308                 preRead();
 309                 if (eof) {
 310                         return -1;
 311                 }
 312
 313                 return buffer[start++];
 314         }
 315
 316         @Override
 317         public int read(byte[] b) throws IOException {
 318                 return read(b, 0, b.length);
 319         }
 320
 321         @Override
 322         public int read(byte[] b, int boff, int blen) throws IOException {
 323                 checkClose();
 324
 325                 if (b == null) {
 326                         throw new NullPointerException();
 327                 } else if (boff < 0 || blen < 0 || blen > b.length - boff) {
 328                         throw new IndexOutOfBoundsException();
 329                 } else if (blen == 0) {
 330                         return 0;
 331                 }
 332
 333                 int done = 0;
 334                 while (hasMoreData() && done < blen) {
 335                         preRead();
 336                         if (hasMoreData()) {
 337                                 int now = Math.min(blen - done, stop - start);
 338                                 if (now > 0) {
 339                                         System.arraycopy(buffer, start, b, boff + done, now);
 340                                         start += now;
 341                                         done += now;
 342                                 }
 343                         }
 344                 }
 345
 346                 return done > 0 ? done : -1;
 347         }
 348
 349         @Override
 350         public long skip(long n) throws IOException {
 351                 if (n <= 0) {
 352                         return 0;
 353                 }
 354
 355                 long skipped = 0;
 356                 while (hasMoreData() && n > 0) {
 357                         preRead();
 358
 359                         long inBuffer = Math.min(n, available());
 360                         start += inBuffer;
 361                         n -= inBuffer;
 362                         skipped += inBuffer;
 363                 }
 364
 365                 return skipped;
 366         }
 367
 368         @Override
 369         public int available() {
 370                 if (closed) {
 371                         return 0;
 372                 }
 373
 374                 return Math.max(0, stop - start);
 375         }
 376
 377         /**
 378          * Closes this stream and releases any system resources associated with the
 379          * stream.
 380          * <p>
 381          * Including the under-laying {@link InputStream}.
 382          * <p>
 383          * <b>Note:</b> if you called the {@link BufferedInputStream#open()} method
 384          * prior to this one, it will just decrease the internal count of how many
 385          * open streams it held and do nothing else. The stream will actually be
 386          * closed when you have called {@link BufferedInputStream#close()} once more
 387          * than {@link BufferedInputStream#open()}.
 388          *
 389          * @exception IOException
 390          *                in case of I/O error
 391          */
 392         @Override
 393         public synchronized void close() throws IOException {
 394                 close(true);
 395         }
 396
 397         /**
 398          * Closes this stream and releases any system resources associated with the
 399          * stream.
 400          * <p>
 401          * Including the under-laying {@link InputStream} if
 402          * <tt>incudingSubStream</tt> is true.
 403          * <p>
 404          * You can call this method multiple times, it will not cause an
 405          * {@link IOException} for subsequent calls.
 406          * <p>
 407          * <b>Note:</b> if you called the {@link BufferedInputStream#open()} method
 408          * prior to this one, it will just decrease the internal count of how many
 409          * open streams it held and do nothing else. The stream will actually be
 410          * closed when you have called {@link BufferedInputStream#close()} once more
 411          * than {@link BufferedInputStream#open()}.
 412          *
 413          * @param includingSubStream
 414          *            also close the under-laying stream
 415          *
 416          * @exception IOException
 417          *                in case of I/O error
 418          */
 419         public synchronized void close(boolean includingSubStream)
 420                         throws IOException {
 421                 if (!closed) {
 422                         if (openCounter > 0) {
 423                                 openCounter--;
 424                         } else {
 425                                 closed = true;
 426                                 if (includingSubStream && in != null) {
 427                                         in.close();
 428                                 }
 429                         }
 430                 }
 431         }
 432
 433         /**
 434          * Check if we still have some data in the buffer and, if not, fetch some.
 435          *
 436          * @return TRUE if we fetched some data, FALSE if there are still some in
 437          *         the buffer
 438          *
 439          * @throws IOException
 440          *             in case of I/O error
 441          */
 442         protected boolean preRead() throws IOException {
 443                 boolean hasRead = false;
 444                 if (in != null && !eof && start >= stop) {
 445                         start = 0;
 446                         if (buffer2 != null) {
 447                                 buffer = buffer2;
 448                                 start = pos2;
 449                                 stop = len2;
 450
 451                                 buffer2 = null;
 452                                 pos2 = 0;
 453                                 len2 = 0;
 454                         } else {
 455                                 buffer = originalBuffer;
 456
 457                                 stop = read(in, buffer, 0, buffer.length);
 458                                 if (stop > 0) {
 459                                         bytesRead += stop;
 460                                 }
 461                         }
 462
 463                         hasRead = true;
 464                 }
 465
 466                 if (start >= stop) {
 467                         eof = true;
 468                 }
 469
 470                 return hasRead;
 471         }
 472
 473         /**
 474          * Read the under-laying stream into the local buffer.
 475          *
 476          * @param in
 477          *            the under-laying {@link InputStream}
 478          * @param buffer
 479          *            the buffer we use in this {@link BufferedInputStream}
 480          * @param off
 481          *            the offset
 482          * @param len
 483          *            the length in bytes
 484          *
 485          * @return the number of bytes read
 486          *
 487          * @throws IOException
 488          *             in case of I/O error
 489          */
 490         protected int read(InputStream in, byte[] buffer, int off, int len)
 491                         throws IOException {
 492                 return in.read(buffer, off, len);
 493         }
 494
 495         /**
 496          * We have more data available in the buffer <b>or</b> we can, maybe, fetch
 497          * more.
 498          *
 499          * @return TRUE if it is the case, FALSE if not
 500          */
 501         protected boolean hasMoreData() {
 502                 if (closed) {
 503                         return false;
 504                 }
 505
 506                 return (start < stop) || !eof;
 507         }
 508
 509         /**
 510          * Check that the stream was not closed, and throw an {@link IOException} if
 511          * it was.
 512          *
 513          * @throws IOException
 514          *             if it was closed
 515          */
 516         protected void checkClose() throws IOException {
 517                 if (closed) {
 518                         throw new IOException(
 519                                         "This BufferedInputStream was closed, you cannot use it anymore.");
 520                 }
 521         }
 522 }