-package be.nikiroo.utils.streams;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map.Entry;
-
-import be.nikiroo.utils.StringUtils;
-
-/**
- * A simple {@link InputStream} that is buffered with a bytes array.
- * <p>
- * It is mostly intended to be used as a base class to create new
- * {@link InputStream}s with special operation modes, and to give some default
- * methods.
- *
- * @author niki
- */
-public class BufferedInputStream extends InputStream {
- /**
- * The size of the internal buffer (can be different if you pass your own
- * buffer, of course, and can also expand to search for longer "startsWith"
- * data).
- * <p>
- * Note that special "push-back" buffers can also be created during the life
- * of this stream.
- */
- static private final int BUFFER_SIZE = 4096;
-
- /** The current position in the buffer. */
- protected int start;
- /** The index of the last usable position of the buffer. */
- protected int stop;
- /** The buffer itself. */
- protected byte[] buffer;
- /** An End-Of-File (or {@link InputStream}, here) marker. */
- protected boolean eof;
-
- private boolean closed;
- private InputStream in;
- private int openCounter;
- private byte[] singleByteReader = new byte[1];
-
- /** array + offset of pushed-back buffers */
- private List<Entry<byte[], Integer>> backBuffers;
-
- private long bytesRead;
-
- /**
- * Create a new {@link BufferedInputStream} that wraps the given
- * {@link InputStream}.
- *
- * @param in
- * the {@link InputStream} to wrap
- */
- public BufferedInputStream(InputStream in) {
- this.in = in;
-
- this.buffer = new byte[BUFFER_SIZE];
- this.start = 0;
- this.stop = 0;
- this.backBuffers = new ArrayList<Entry<byte[], Integer>>();
- }
-
- /**
- * Create a new {@link BufferedInputStream} that wraps the given bytes array
- * as a data source.
- *
- * @param in
- * the array to wrap, cannot be NULL
- */
- public BufferedInputStream(byte[] in) {
- this(in, 0, in.length);
- }
-
- /**
- * Create a new {@link BufferedInputStream} that wraps the given bytes array
- * as a data source.
- *
- * @param in
- * the array to wrap, cannot be NULL
- * @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 BufferedInputStream(byte[] in, 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.buffer = in;
- this.start = offset;
- this.stop = length;
- this.backBuffers = new ArrayList<Entry<byte[], Integer>>();
- }
-
- /**
- * Return this very same {@link BufferedInputStream}, but keep a counter of
- * how many streams were open this way. When calling
- * {@link BufferedInputStream#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;
- }
-
- /**
- * Check if the current content (until eof) is equal to the given search
- * term.
- * <p>
- * Note: the search term size <b>must</b> be smaller or equal the internal
- * buffer size.
- *
- * @param search
- * the term to search for
- *
- * @return TRUE if the content that will be read starts with it
- *
- * @throws IOException
- * in case of I/O error or if the size of the search term is
- * greater than the internal buffer
- */
- public boolean is(String search) throws IOException {
- return is(StringUtils.getBytes(search));
- }
-
- /**
- * Check if the current content (until eof) is equal to the given search
- * term.
- * <p>
- * Note: the search term size <b>must</b> be smaller or equal the internal
- * buffer size.
- *
- * @param search
- * the term to search for
- *
- * @return TRUE if the content that will be read starts with it
- *
- * @throws IOException
- * in case of I/O error or if the size of the search term is
- * greater than the internal buffer
- */
- public boolean is(byte[] search) throws IOException {
- if (startsWith(search)) {
- return available() == search.length;
- }
-
- return false;
- }
-
- /**
- * Check if the current content (what will be read next) starts with the
- * given search term.
- * <p>
- * Note: the search term size <b>must</b> be smaller or equal the internal
- * buffer size.
- *
- * @param search
- * the term to search for
- *
- * @return TRUE if the content that will be read starts with it
- *
- * @throws IOException
- * in case of I/O error or if the size of the search term is
- * greater than the internal buffer
- */
- public boolean startsWith(String search) throws IOException {
- return startsWith(StringUtils.getBytes(search));
- }
-
- /**
- * Check if the current content (what will be read next) starts with the
- * given search term.
- * <p>
- * An empty string will always return true (unless the stream is closed,
- * which would throw an {@link IOException}).
- * <p>
- * Note: the search term size <b>must</b> be smaller or equal the internal
- * buffer size.
- *
- * @param search
- * the term to search for
- *
- * @return TRUE if the content that will be read starts with it
- *
- * @throws IOException
- * in case of I/O error or if the size of the search term is
- * greater than the internal buffer
- */
- public boolean startsWith(byte[] search) throws IOException {
- checkClose();
-
- while (consolidatePushBack(search.length) < search.length) {
- preRead();
- if (start >= stop) {
- // Not enough data left to start with that
- return false;
- }
-
- byte[] newBuffer = new byte[stop - start];
- System.arraycopy(buffer, start, newBuffer, 0, stop - start);
- pushback(newBuffer, 0);
- start = stop;
- }
-
- Entry<byte[], Integer> bb = backBuffers.get(backBuffers.size() - 1);
- byte[] bbBuffer = bb.getKey();
- int bbOffset = bb.getValue();
-
- return StreamUtils.startsWith(search, bbBuffer, bbOffset,
- bbBuffer.length);
- }
-
- /**
- * 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 spent (no more data to read or to process).
- *
- * @return TRUE if it is
- *
- * @throws IOException
- * in case of I/O error
- */
- public boolean eof() throws IOException {
- if (closed) {
- return true;
- }
-
- preRead();
- return !hasMoreData();
- }
-
- /**
- * Read the whole {@link InputStream} until the end and return the number of
- * bytes read.
- *
- * @return the number of bytes read
- *
- * @throws IOException
- * in case of I/O error
- */
- public long end() throws IOException {
- long skipped = 0;
- while (hasMoreData()) {
- skipped += skip(buffer.length);
- }
-
- return skipped;
- }
-
- @Override
- public int read() throws IOException {
- if (read(singleByteReader) < 0) {
- return -1;
- }
-
- return singleByteReader[0];
- }
-
- @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;
- }
-
- // Read from the pushed-back buffers if any
- if (backBuffers.isEmpty()) {
- preRead(); // an implementation could pushback in preRead()
- }
-
- if (!backBuffers.isEmpty()) {
- int read = 0;
-
- Entry<byte[], Integer> bb = backBuffers
- .remove(backBuffers.size() - 1);
- byte[] bbBuffer = bb.getKey();
- int bbOffset = bb.getValue();
- int bbSize = bbBuffer.length - bbOffset;
-
- if (bbSize > blen) {
- read = blen;
- System.arraycopy(bbBuffer, bbOffset, b, boff, read);
- pushback(bbBuffer, bbOffset + read);
- } else {
- read = bbSize;
- System.arraycopy(bbBuffer, bbOffset, b, boff, read);
- }
-
- return read;
- }
-
- int done = 0;
- while (hasMoreData() && done < blen) {
- preRead();
- if (hasMoreData()) {
- int now = Math.min(blen - done, stop - start);
- if (now > 0) {
- System.arraycopy(buffer, start, b, boff + done, now);
- start += 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 (!backBuffers.isEmpty() && n > 0) {
- Entry<byte[], Integer> bb = backBuffers
- .remove(backBuffers.size() - 1);
- byte[] bbBuffer = bb.getKey();
- int bbOffset = bb.getValue();
- int bbSize = bbBuffer.length - bbOffset;
-
- int localSkip = 0;
- localSkip = (int) Math.min(n, bbSize);
-
- n -= localSkip;
- bbSize -= localSkip;
-
- if (bbSize > 0) {
- pushback(bbBuffer, bbOffset + localSkip);
- }
- }
- while (hasMoreData() && n > 0) {
- preRead();
-
- long inBuffer = Math.min(n, available());
- start += inBuffer;
- n -= inBuffer;
- skipped += inBuffer;
- }
-
- return skipped;
- }
-
- @Override
- public int available() {
- if (closed) {
- return 0;
- }
-
- int avail = 0;
- for (Entry<byte[], Integer> entry : backBuffers) {
- avail += entry.getKey().length - entry.getValue();
- }
-
- return avail + Math.max(0, stop - start);
- }
-
- /**
- * 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 BufferedInputStream#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 BufferedInputStream#close()} once more
- * than {@link BufferedInputStream#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 BufferedInputStream#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 BufferedInputStream#close()} once more
- * than {@link BufferedInputStream#open()}.
- *
- * @param includingSubStream
- * also close the under-laying stream
- *
- * @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();
- }
- }
- }
- }
-
- /**
- * Consolidate the push-back buffers so the last one is at least the given
- * size, if possible.
- * <p>
- * If there is not enough data in the push-back buffers, they will all be
- * consolidated.
- *
- * @param size
- * the minimum size of the consolidated buffer, or -1 to force
- * the consolidation of all push-back buffers
- *
- * @return the size of the last, consolidated buffer; can be less than the
- * requested size if not enough data
- */
- protected int consolidatePushBack(int size) {
- int bbIndex = -1;
- int bbUpToSize = 0;
- for (Entry<byte[], Integer> entry : backBuffers) {
- bbIndex++;
- bbUpToSize += entry.getKey().length - entry.getValue();
-
- if (size >= 0 && bbUpToSize >= size) {
- break;
- }
- }
-
- // Index 0 means "the last buffer is already big enough"
- if (bbIndex > 0) {
- byte[] consolidatedBuffer = new byte[bbUpToSize];
- int consolidatedPos = 0;
- for (int i = 0; i <= bbIndex; i++) {
- Entry<byte[], Integer> bb = backBuffers
- .remove(backBuffers.size() - 1);
- byte[] bbBuffer = bb.getKey();
- int bbOffset = bb.getValue();
- int bbSize = bbBuffer.length - bbOffset;
- System.arraycopy(bbBuffer, bbOffset, consolidatedBuffer,
- consolidatedPos, bbSize);
- }
-
- pushback(consolidatedBuffer, 0);
- }
-
- return bbUpToSize;
- }
-
- /**
- * 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
- */
- protected boolean preRead() throws IOException {
- boolean hasRead = false;
- if (in != null && !eof && start >= stop) {
- start = 0;
- stop = read(in, buffer);
- if (stop > 0) {
- bytesRead += stop;
- }
-
- hasRead = true;
- }
-
- if (start >= stop) {
- eof = true;
- }
-
- return hasRead;
- }
-
- /**
- * Push back some data that will be read again at the next read call.
- *
- * @param buffer
- * the buffer to push back
- * @param offset
- * the offset at which to start reading in the buffer
- */
- protected void pushback(byte[] buffer, int offset) {
- backBuffers.add(
- new AbstractMap.SimpleEntry<byte[], Integer>(buffer, offset));
- }
-
- /**
- * Push back some data that will be read again at the next read call.
- *
- * @param buffer
- * the buffer to push back
- * @param offset
- * the offset at which to start reading in the buffer
- * @param len
- * the length to copy
- */
- protected void pushback(byte[] buffer, int offset, int len) {
- // TODO: not efficient!
- if (buffer.length != len) {
- byte[] lenNotSupportedYet = new byte[len];
- System.arraycopy(buffer, offset, lenNotSupportedYet, 0, len);
- buffer = lenNotSupportedYet;
- offset = 0;
- }
-
- pushback(buffer, offset);
- }
-
- /**
- * Read the under-laying stream into the given local buffer.
- *
- * @param in
- * the under-laying {@link InputStream}
- * @param buffer
- * the buffer we use in this {@link BufferedInputStream}
- *
- * @return the number of bytes read
- *
- * @throws IOException
- * in case of I/O error
- */
- protected int read(InputStream in, byte[] buffer) throws IOException {
- return in.read(buffer, 0, buffer.length);
- }
-
- /**
- * We have more data available in the buffer <b>or</b> we can, maybe, fetch
- * more.
- *
- * @return TRUE if it is the case, FALSE if not
- */
- protected boolean hasMoreData() {
- if (closed) {
- return false;
- }
-
- return !backBuffers.isEmpty() || (start < stop) || !eof;
- }
-
- /**
- * Check that the stream was not closed, and throw an {@link IOException} if
- * it was.
- *
- * @throws IOException
- * if it was closed
- */
- protected void checkClose() throws IOException {
- if (closed) {
- throw new IOException(
- "This BufferedInputStream was closed, you cannot use it anymore.");
- }
- }
-}