import java.io.IOException;
import java.io.InputStream;
-import java.util.Arrays;
/**
* This {@link InputStream} can be separated into sub-streams (you can process
*
* @author niki
*/
-public class NextableInputStream extends InputStream {
+public class NextableInputStream extends BufferedInputStream {
private NextableInputStreamStep step;
private boolean started;
private boolean stopped;
- private boolean closed;
-
- private InputStream in;
- private int openCounter;
- private boolean eof;
- private int pos;
- private int len;
- private byte[] buffer;
-
- // special use, prefetched next buffer
- private byte[] buffer2;
- private int pos2;
- private int len2;
- private byte[] originalBuffer;
-
- private long bytesRead;
/**
* Create a new {@link NextableInputStream} that wraps the given
* case it will behave as a normal {@link InputStream})
*/
public NextableInputStream(InputStream in, NextableInputStreamStep step) {
- this.in = in;
+ super(in);
this.step = step;
-
- this.buffer = new byte[4096];
- this.originalBuffer = this.buffer;
- this.pos = 0;
- this.len = 0;
}
/**
*/
public NextableInputStream(byte[] in, NextableInputStreamStep step,
int offset, int length) {
- if (in == null) {
- throw new NullPointerException();
- } else if (offset < 0 || length < 0 || length > in.length - offset) {
- throw new IndexOutOfBoundsException();
- }
-
- this.in = null;
+ super(in, offset, length);
this.step = step;
-
- this.buffer = in;
- this.originalBuffer = this.buffer;
- this.pos = offset;
- this.len = length;
-
checkBuffer(true);
}
- /**
- * Return this very same {@link NextableInputStream}, but keep a counter of
- * how many streams were open this way. When calling
- * {@link NextableInputStream#close()}, decrease this counter if it is not
- * already zero instead of actually closing the stream.
- * <p>
- * You are now responsible for it — you <b>must</b> close it.
- * <p>
- * This method allows you to use a wrapping stream around this one and still
- * close the wrapping stream.
- *
- * @return the same stream, but you are now responsible for closing it
- *
- * @throws IOException
- * in case of I/O error or if the stream is closed
- */
- public synchronized InputStream open() throws IOException {
- checkClose();
- openCounter++;
- return this;
- }
-
/**
* Unblock the processing of the next sub-stream.
* <p>
return next(true);
}
- // max is buffer.size !
- public boolean startsWiths(String search) throws IOException {
- return startsWith(search.getBytes("UTF-8"));
- }
-
- // max is buffer.size !
- public boolean startsWith(byte[] search) throws IOException {
- if (search.length > originalBuffer.length) {
- throw new IOException(
- "This stream does not support searching for more than "
- + buffer.length + " bytes");
- }
-
- checkClose();
-
- if (available() < search.length) {
- preRead();
- }
-
- if (available() >= search.length) {
- // Easy path
- return startsWith(search, buffer, pos);
- } else if (!eof) {
- // Harder path
- if (buffer2 == null && buffer.length == originalBuffer.length) {
- buffer2 = Arrays.copyOf(buffer, buffer.length * 2);
-
- pos2 = buffer.length;
- len2 = in.read(buffer2, pos2, buffer.length);
- if (len2 > 0) {
- bytesRead += len2;
- }
-
- // Note: here, len/len2 = INDEX of last good byte
- len2 += pos2;
- }
-
- if (available() + (len2 - pos2) >= search.length) {
- return startsWith(search, buffer2, pos2);
- }
- }
-
- return false;
- }
-
- /**
- * The number of bytes read from the under-laying {@link InputStream}.
- *
- * @return the number of bytes
- */
- public long getBytesRead() {
- return bytesRead;
- }
-
- /**
- * Check if this stream is totally spent (no more data to read or to
- * process).
- * <p>
- * Note: an empty stream that is still not started will return FALSE, as we
- * don't know yet if it is empty.
- *
- * @return TRUE if it is
- */
- public boolean eof() {
- return closed || (len < 0 && !hasMoreData());
- }
-
- @Override
- public int read() throws IOException {
- checkClose();
-
- preRead();
- if (eof) {
- return -1;
- }
-
- return buffer[pos++];
- }
-
- @Override
- public int read(byte[] b) throws IOException {
- return read(b, 0, b.length);
- }
-
- @Override
- public int read(byte[] b, int boff, int blen) throws IOException {
- checkClose();
-
- if (b == null) {
- throw new NullPointerException();
- } else if (boff < 0 || blen < 0 || blen > b.length - boff) {
- throw new IndexOutOfBoundsException();
- } else if (blen == 0) {
- return 0;
- }
-
- int done = 0;
- while (hasMoreData() && done < blen) {
- preRead();
- if (hasMoreData()) {
- int now = Math.min(blen, len) - pos;
- if (now > 0) {
- System.arraycopy(buffer, pos, b, boff, now);
- pos += now;
- done += now;
- }
- }
- }
-
- return done > 0 ? done : -1;
- }
-
- @Override
- public long skip(long n) throws IOException {
- if (n <= 0) {
- return 0;
- }
-
- long skipped = 0;
- while (hasMoreData() && n > 0) {
- preRead();
-
- long inBuffer = Math.min(n, available());
- pos += inBuffer;
- n -= inBuffer;
- skipped += inBuffer;
- }
-
- return skipped;
- }
-
- @Override
- public int available() {
- if (closed) {
- return 0;
- }
-
- return Math.max(0, len - pos);
- }
-
- /**
- * Closes this stream and releases any system resources associated with the
- * stream.
- * <p>
- * Including the under-laying {@link InputStream}.
- * <p>
- * <b>Note:</b> if you called the {@link NextableInputStream#open()} method
- * prior to this one, it will just decrease the internal count of how many
- * open streams it held and do nothing else. The stream will actually be
- * closed when you have called {@link NextableInputStream#close()} once more
- * than {@link NextableInputStream#open()}.
- *
- * @exception IOException
- * in case of I/O error
- */
- @Override
- public synchronized void close() throws IOException {
- close(true);
- }
-
- /**
- * Closes this stream and releases any system resources associated with the
- * stream.
- * <p>
- * Including the under-laying {@link InputStream} if
- * <tt>incudingSubStream</tt> is true.
- * <p>
- * You can call this method multiple times, it will not cause an
- * {@link IOException} for subsequent calls.
- * <p>
- * <b>Note:</b> if you called the {@link NextableInputStream#open()} method
- * prior to this one, it will just decrease the internal count of how many
- * open streams it held and do nothing else. The stream will actually be
- * closed when you have called {@link NextableInputStream#close()} once more
- * than {@link NextableInputStream#open()}.
- *
- * @exception IOException
- * in case of I/O error
- */
- public synchronized void close(boolean includingSubStream)
- throws IOException {
- if (!closed) {
- if (openCounter > 0) {
- openCounter--;
- } else {
- closed = true;
- if (includingSubStream && in != null) {
- in.close();
- }
- }
- }
- }
-
/**
* Check if we still have some data in the buffer and, if not, fetch some.
*
* @throws IOException
* in case of I/O error
*/
- private boolean preRead() throws IOException {
- boolean hasRead = false;
- if (!eof && in != null && pos >= len && !stopped) {
- pos = 0;
- if (buffer2 != null) {
- buffer = buffer2;
- pos = pos2;
- len = len2;
-
- buffer2 = null;
- pos2 = 0;
- len2 = 0;
- } else {
- buffer = originalBuffer;
- len = in.read(buffer);
- if (len > 0) {
- bytesRead += len;
- }
- }
-
+ @Override
+ protected boolean preRead() throws IOException {
+ if (!stopped) {
+ boolean bufferChanged = super.preRead();
checkBuffer(true);
- hasRead = true;
+ return bufferChanged;
}
if (pos >= len) {
eof = true;
}
- return hasRead;
+ return false;
}
/**
*
* @return TRUE if it is the case, FALSE if not
*/
- private boolean hasMoreData() {
- return !closed && started && !(eof && pos >= len);
+ @Override
+ protected boolean hasMoreData() {
+ return started && super.hasMoreData();
}
/**
return false;
}
-
- /**
- * Check that the stream was not closed, and throw an {@link IOException} if
- * it was.
- *
- * @throws IOException
- * if it was closed
- */
- private void checkClose() throws IOException {
- if (closed) {
- throw new IOException(
- "This NextableInputStream was closed, you cannot use it anymore.");
- }
- }
-
- // buffer must be > search
- static private boolean startsWith(byte[] search, byte[] buffer, int offset) {
- boolean same = true;
- for (int i = 0; i < search.length; i++) {
- if (search[i] != buffer[offset + i]) {
- same = false;
- break;
- }
- }
-
- return same;
- }
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff