--- /dev/null
+package be.nikiroo.utils.streams;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+
+/**
+ * This {@link InputStream} can be separated into sub-streams (you can process
+ * it as a normal {@link InputStream} but, when it is spent, you can call
+ * {@link NextableInputStream#next()} on it to unlock new data).
+ * <p>
+ * The separation in sub-streams is done via {@link NextableInputStreamStep}.
+ *
+ * @author niki
+ */
+public class NextableInputStream extends BufferedInputStream {
+ private NextableInputStreamStep step;
+ private boolean started;
+ private boolean stopped;
+
+ /**
+ * Create a new {@link NextableInputStream} that wraps the given
+ * {@link InputStream}.
+ *
+ * @param in
+ * the {@link InputStream} to wrap
+ * @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(InputStream in, NextableInputStreamStep step) {
+ super(in);
+ this.step = step;
+ }
+
+ /**
+ * 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) {
+ super(in, offset, length);
+ this.step = step;
+ checkBuffer(true);
+ }
+
+ /**
+ * Unblock the processing of the next sub-stream.
+ * <p>
+ * It can only be called when the "current" stream is spent (i.e., you must
+ * first process the stream until it is spent).
+ * <p>
+ * {@link IOException}s can happen when we have no data available in the
+ * buffer; in that case, we fetch more data to know if we can have a next
+ * sub-stream or not.
+ * <p>
+ * This is can be a blocking call when data need to be fetched.
+ *
+ * @return TRUE if we unblocked the next sub-stream, FALSE if not (i.e.,
+ * FALSE when there are no more sub-streams to fetch)
+ *
+ * @throws IOException
+ * in case of I/O error or if the stream is closed
+ */
+ public boolean next() throws IOException {
+ return next(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}.
+ * <p>
+ * This is can be a blocking call when data need to be fetched.
+ *
+ * @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);
+ }
+
+ /**
+ * Check if this stream is totally spent (no more data to read or to
+ * process).
+ * <p>
+ * Note: when the stream is divided into sub-streams, each sub-stream will
+ * report its own eof when spent.
+ *
+ * @return TRUE if it is
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ @Override
+ public boolean eof() throws IOException {
+ return super.eof();
+ }
+
+ /**
+ * Check if we still have some data in the buffer and, if not, fetch some.
+ *
+ * @return TRUE if we fetched some data, FALSE if there are still some in
+ * the buffer
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ @Override
+ protected boolean preRead() throws IOException {
+ if (!stopped) {
+ boolean bufferChanged = super.preRead();
+ checkBuffer(bufferChanged);
+ return bufferChanged;
+ }
+
+ if (start >= stop) {
+ eof = true;
+ }
+
+ return false;
+ }
+
+ @Override
+ protected boolean hasMoreData() {
+ return started && super.hasMoreData();
+ }
+
+ /**
+ * Check that the buffer didn't overshot to the next item, and fix
+ * {@link NextableInputStream#stop} if needed.
+ * <p>
+ * If {@link NextableInputStream#stop} is fixed,
+ * {@link NextableInputStream#eof} and {@link NextableInputStream#stopped}
+ * are set to TRUE.
+ *
+ * @param newBuffer
+ * we changed the buffer, we need to clear some information in
+ * the {@link NextableInputStreamStep}
+ */
+ private void checkBuffer(boolean newBuffer) {
+ if (step != null && stop >= 0) {
+ if (newBuffer) {
+ step.clearBuffer();
+ }
+
+ int stopAt = step.stop(buffer, start, stop, eof);
+ if (stopAt >= 0) {
+ stop = stopAt;
+ eof = true;
+ stopped = true;
+ }
+ }
+ }
+
+ /**
+ * The implementation of {@link NextableInputStream#next()} and
+ * {@link NextableInputStream#nextAll()}.
+ * <p>
+ * This is can be a blocking call when data need to be fetched.
+ *
+ * @param all
+ * TRUE for {@link NextableInputStream#nextAll()}, FALSE for
+ * {@link NextableInputStream#next()}
+ *
+ * @return TRUE if we unblocked the next sub-stream, FALSE if not (i.e.,
+ * FALSE when there are no more sub-streams to fetch)
+ *
+ * @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 started, must be stopped and no more data to continue
+ // i.e., sub-stream must be spent
+ if (!stopped || hasMoreData()) {
+ return false;
+ }
+
+ if (step != null) {
+ stop = step.getResumeLen();
+ start += step.getResumeSkip();
+ eof = step.getResumeEof();
+ stopped = false;
+
+ if (all) {
+ step = null;
+ }
+
+ checkBuffer(false);
+
+ return true;
+ }
+
+ return false;
+
+ // // consider that if EOF, there is no next
+ // if (start >= stop) {
+ // // Make sure, block if necessary
+ // preRead();
+ //
+ // return hasMoreData();
+ // }
+ //
+ // return true;
+ }
+
+ /**
+ * Display a DEBUG {@link String} representation of this object.
+ * <p>
+ * Do <b>not</b> use for release code.
+ */
+ @Override
+ public String toString() {
+ String data = "";
+ if (stop > 0) {
+ try {
+ data = new String(Arrays.copyOfRange(buffer, 0, stop), "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ }
+ if (data.length() > 200) {
+ data = data.substring(0, 197) + "...";
+ }
+ }
+ String rep = String.format(
+ "Nextable %s: %d -> %d [eof: %s] [more data: %s]: %s",
+ (stopped ? "stopped" : "running"), start, stop, "" + eof, ""
+ + hasMoreData(), data);
+
+ return rep;
+ }
+}