*/
public class NextableInputStream extends InputStream {
private NextableInputStreamStep step;
+ private boolean started;
private boolean stopped;
+ private boolean closed;
private InputStream in;
+ private int openCounter;
private boolean eof;
- private int pos = 0;
- private int len = 0;
- private byte[] buffer = new byte[4096];
+ private int pos;
+ private int len;
+ private byte[] buffer;
+
+ private long bytesRead;
/**
* Create a new {@link NextableInputStream} that wraps the given
public NextableInputStream(InputStream in, NextableInputStreamStep step) {
this.in = in;
this.step = step;
+
+ this.buffer = new byte[4096];
+ this.pos = 0;
+ this.len = 0;
+ }
+
+ /**
+ * Create a new {@link NextableInputStream} that wraps the given bytes array
+ * as a data source.
+ *
+ * @param in
+ * the array to wrap, cannot be NULL
+ * @param step
+ * how to separate it into sub-streams (can be NULL, but in that
+ * case it will behave as a normal {@link InputStream})
+ */
+ public NextableInputStream(byte[] in, NextableInputStreamStep step) {
+ this(in, step, 0, in.length);
+ }
+
+ /**
+ * Create a new {@link NextableInputStream} that wraps the given bytes array
+ * as a data source.
+ *
+ * @param in
+ * the array to wrap, cannot be NULL
+ * @param step
+ * how to separate it into sub-streams (can be NULL, but in that
+ * case it will behave as a normal {@link InputStream})
+ * @param offset
+ * the offset to start the reading at
+ * @param length
+ * the number of bytes to take into account in the array,
+ * starting from the offset
+ *
+ * @throws NullPointerException
+ * if the array is NULL
+ * @throws IndexOutOfBoundsException
+ * if the offset and length do not correspond to the given array
+ */
+ 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;
+ this.step = step;
+
+ this.buffer = in;
+ 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;
}
/**
* @return TRUE if we unblocked the next sub-stream, FALSE if not
*
* @throws IOException
- * in case of I/O error
+ * in case of I/O error or if the stream is closed
*/
public boolean next() throws IOException {
- if (!hasMoreData() && stopped) {
- len = step.getResumeLen();
- pos += step.getResumeSkip();
- eof = false;
+ return next(false);
+ }
- if (!preRead()) {
- checkBuffer(false);
- }
+ /**
+ * Unblock the next sub-stream as would have done
+ * {@link NextableInputStream#next()}, but disable the sub-stream systems.
+ * <p>
+ * That is, the next stream, if any, will be the last one and will not be
+ * subject to the {@link NextableInputStreamStep}.
+ *
+ * @return TRUE if we unblocked the next sub-stream, FALSE if not
+ *
+ * @throws IOException
+ * in case of I/O error or if the stream is closed
+ */
+ public boolean nextAll() throws IOException {
+ return next(true);
+ }
- // consider that if EOF, there is no next
- return hasMoreData();
- }
+ public boolean startWith() {
+ // TODO
+ return false;
+ }
+ public boolean startWiths() {
+ // TODO
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).
+ *
+ * @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;
@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) {
}
@Override
- public int available() throws IOException {
+ public long skip(long n) throws IOException {
+ // TODO Auto-generated method stub
+ return super.skip(n);
+ }
+
+ @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.
*
if (!eof && in != null && pos >= len && !stopped) {
pos = 0;
len = in.read(buffer);
+ if (len > 0) {
+ bytesRead += len;
+ }
+
checkBuffer(true);
hasRead = true;
}
* @return TRUE if it is the case, FALSE if not
*/
private boolean hasMoreData() {
- return !(eof && pos >= len);
+ return !closed && started && !(eof && pos >= len);
}
/**
* the {@link NextableInputStreamStep}
*/
private void checkBuffer(boolean newBuffer) {
- if (step != null) {
+ if (step != null && len > 0) {
if (newBuffer) {
step.clearBuffer();
}
}
}
}
+
+ /**
+ * The implementation of {@link NextableInputStream#next()} and
+ * {@link NextableInputStream#nextAll()}.
+ *
+ * @param all
+ * TRUE for {@link NextableInputStream#nextAll()}, FALSE for
+ * {@link NextableInputStream#next()}
+ *
+ * @return TRUE if we unblocked the next sub-stream, FALSE if not
+ *
+ * @throws IOException
+ * in case of I/O error or if the stream is closed
+ */
+ private boolean next(boolean all) throws IOException {
+ checkClose();
+
+ if (!started) {
+ // First call before being allowed to read
+ started = true;
+
+ if (all) {
+ step = null;
+ }
+
+ return true;
+ }
+
+ if (step != null && !hasMoreData() && stopped) {
+ len = step.getResumeLen();
+ pos += step.getResumeSkip();
+ eof = false;
+
+ if (all) {
+ step = null;
+ }
+
+ if (!preRead()) {
+ checkBuffer(false);
+ }
+
+ // consider that if EOF, there is no next
+ return 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.");
+ }
+ }
}
byte[] expected = new byte[] { 42, 12, 0, 127 };
NextableInputStream in = new NextableInputStream(
new ByteArrayInputStream(expected), null);
+ in.next();
byte[] actual = IOUtils.toByteArray(in);
assertEquals(
new ByteArrayInputStream(expected),
new NextableInputStreamStep(12));
- checkNext(this, false, "FIRST", in, new byte[] { 42 });
+ checkNext(this, "FIRST", in, new byte[] { 42 });
}
});
new ByteArrayInputStream(data),
new NextableInputStreamStep(12));
- checkNext(this, false, "FIRST", in, new byte[] { 42 });
- checkNext(this, true, "SECOND", in, new byte[] { 0, 127 });
- checkNext(this, true, "THIRD", in, new byte[] { 51, 11 });
+ checkNext(this, "FIRST", in, new byte[] { 42 });
+ checkNext(this, "SECOND", in, new byte[] { 0, 127 });
+ checkNext(this, "THIRD", in, new byte[] { 51, 11 });
}
});
NextableInputStream subIn12 = new NextableInputStream(in4,
new NextableInputStreamStep(12));
- checkNext(this, false, "SUB FIRST", subIn12, new byte[] { 42 });
- checkNext(this, true, "SUB SECOND", subIn12, new byte[] { 0 });
+ in4.next();
+ checkNext(this, "SUB FIRST", subIn12, new byte[] { 42 });
+ checkNext(this, "SUB SECOND", subIn12, new byte[] { 0 });
assertEquals("The subIn still has some data", false,
subIn12.next());
- checkNext(this, true, "MAIN LAST", in4,
- new byte[] { 127, 12, 5 });
+ checkNext(this, "MAIN LAST", in4, new byte[] { 127, 12, 5 });
}
});
new ByteArrayInputStream(data),
new NextableInputStreamStep('\n'));
- checkNext(this, false, "FIRST", in, ln1.getBytes("UTF-8"));
- checkNext(this, true, "SECOND", in, ln2.getBytes("UTF-8"));
+ checkNext(this, "FIRST", in, ln1.getBytes("UTF-8"));
+ checkNext(this, "SECOND", in, ln2.getBytes("UTF-8"));
+ }
+ });
+
+ addTest(new TestCase("nextAll()") {
+ @Override
+ public void test() throws Exception {
+ byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
+ NextableInputStream in = new NextableInputStream(
+ new ByteArrayInputStream(data),
+ new NextableInputStreamStep(12));
+
+ checkNext(this, "FIRST", in, new byte[] { 42 });
+ checkNextAll(this, "REST", in, new byte[] { 0, 127, 12, 51, 11,
+ 12 });
+ assertEquals("The stream still has some data", false, in.next());
+ }
+ });
+
+ addTest(new TestCase("getBytesRead()") {
+ @Override
+ public void test() throws Exception {
+ byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
+ NextableInputStream in = new NextableInputStream(
+ new ByteArrayInputStream(data),
+ new NextableInputStreamStep(12));
+
+ in.nextAll();
+ IOUtils.toByteArray(in);
+
+ assertEquals("The number of bytes read is not correct",
+ data.length, in.getBytesRead());
+ }
+ });
+
+ addTest(new TestCase("bytes array input") {
+ @Override
+ public void test() throws Exception {
+ byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
+ NextableInputStream in = new NextableInputStream(data,
+ new NextableInputStreamStep(12));
+
+ checkNext(this, "FIRST", in, new byte[] { 42 });
+ checkNext(this, "SECOND", in, new byte[] { 0, 127 });
+ checkNext(this, "THIRD", in, new byte[] { 51, 11 });
}
});
}
- static void checkNext(TestCase test, boolean callNext, String prefix,
- NextableInputStream in, byte[] expected) throws Exception {
- if (callNext) {
- test.assertEquals("Cannot get " + prefix + " entry", true,
- in.next());
+ static void checkNext(TestCase test, String prefix, NextableInputStream in,
+ byte[] expected) throws Exception {
+ test.assertEquals("Cannot get " + prefix + " entry", true, in.next());
+ byte[] actual = IOUtils.toByteArray(in);
+ test.assertEquals("The " + prefix
+ + " resulting array has not the correct number of items",
+ expected.length, actual.length);
+ for (int i = 0; i < actual.length; i++) {
+ test.assertEquals("Item " + i + " (0-based) is not the same",
+ expected[i], actual[i]);
}
+ }
+
+ static void checkNextAll(TestCase test, String prefix,
+ NextableInputStream in, byte[] expected) throws Exception {
+ test.assertEquals("Cannot get " + prefix + " entries", true,
+ in.nextAll());
byte[] actual = IOUtils.toByteArray(in);
test.assertEquals("The " + prefix
+ " resulting array has not the correct number of items",
git://git.nikiroo.be / fanfix-jexer.git / commitdiff