com.netease.cloud.services.nos.internal.RepeatableInputStream Maven / Gradle / Ivy
Show all versions of nos-sdk-java-publiccloud Show documentation
package com.netease.cloud.services.nos.internal;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A repeatable input stream wrapper for any input stream. This input stream
* relies on buffered data to repeat, and can therefore only be repeated when
* less data has been read than this buffer can hold.
*
* Note: Always use a {@link RepeatableFileInputStream} instead of this
* class if you are sourcing data from a file, as the file-based repeatable
* input stream can be repeated without any limitations.
*/
public class RepeatableInputStream extends InputStream {
private static final Logger log = LoggerFactory.getLogger(RepeatableInputStream.class);
private InputStream is = null;
private int bufferSize = 0;
private int bufferOffset = 0;
private long bytesReadPastMark = 0;
private byte[] buffer = null;
/**
* Creates a repeatable input stream based on another input stream.
*
* @param inputStream
* The input stream to wrap. The data read from the wrapped input
* stream is buffered as it is read, up to the buffer limit
* specified.
* @param bufferSize
* The number of bytes buffered by this class.
*/
public RepeatableInputStream(InputStream inputStream, int bufferSize) {
if (inputStream == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
this.is = inputStream;
this.bufferSize = bufferSize;
this.buffer = new byte[this.bufferSize];
if (log.isDebugEnabled()) {
log.debug("Underlying input stream will be repeatable up to "
+ this.buffer.length + " bytes");
}
}
/**
* Resets the input stream to the beginning by pointing the buffer offset to
* the beginning of the available data buffer.
*
* @throws IOException
* When the available buffer size has been exceeded, in which
* case the input stream data cannot be repeated.
*/
public void reset() throws IOException {
if (bytesReadPastMark <= bufferSize) {
if (log.isDebugEnabled()) {
log.debug("Reset after reading " + bytesReadPastMark + " bytes.");
}
bufferOffset = 0;
} else {
throw new IOException(
"Input stream cannot be reset as " + this.bytesReadPastMark
+ " bytes have been written, exceeding the available buffer size of " + this.bufferSize);
}
}
/**
* @see java.io.InputStream#markSupported()
*/
public boolean markSupported() {
return true;
}
/**
* This method can only be used while less data has been read from the input
* stream than fits into the buffer. The readLimit parameter is ignored
* entirely.
*/
public synchronized void mark(int readlimit) {
if (log.isDebugEnabled()) {
log.debug("Input stream marked at " + bytesReadPastMark + " bytes");
}
if (bytesReadPastMark <= bufferSize && buffer != null) {
/*
* Clear buffer of already-read data to make more space. It's safe
* to cast bytesReadPastMark to an int because it is known to be
* less than bufferSize, which is an int.
*/
byte[] newBuffer = new byte[this.bufferSize];
System.arraycopy(buffer, bufferOffset, newBuffer, 0, (int)(bytesReadPastMark - bufferOffset));
this.buffer = newBuffer;
this.bytesReadPastMark -= bufferOffset;
this.bufferOffset = 0;
} else {
// If mark is called after the buffer was already exceeded, create a new buffer.
this.bufferOffset = 0;
this.bytesReadPastMark = 0;
this.buffer = new byte[this.bufferSize];
}
}
/**
* @see java.io.InputStream#available()
*/
public int available() throws IOException {
return is.available();
}
/**
* @see java.io.InputStream#close()
*/
public void close() throws IOException {
is.close();
}
/**
* @see java.io.InputStream#read(byte[], int, int)
*/
public int read(byte[] out, int outOffset, int outLength) throws IOException {
byte[] tmp = new byte[outLength];
// Check whether we already have buffered data.
if (bufferOffset < bytesReadPastMark && buffer != null) {
// Data is being repeated, so read from buffer instead of wrapped input stream.
int bytesFromBuffer = tmp.length;
if (bufferOffset + bytesFromBuffer > bytesReadPastMark) {
bytesFromBuffer = (int) bytesReadPastMark - bufferOffset;
}
// Write to output.
System.arraycopy(buffer, bufferOffset, out, outOffset, bytesFromBuffer);
bufferOffset += bytesFromBuffer;
return bytesFromBuffer;
}
// Read data from input stream.
int count = is.read(tmp);
if (count <= 0) {
return count;
}
// Fill the buffer with data, as long as we won't exceed its capacity.
if (bytesReadPastMark + count <= bufferSize) {
System.arraycopy(tmp, 0, buffer, (int) bytesReadPastMark, count);
bufferOffset += count;
} else if (buffer != null) {
// We have exceeded the buffer capacity, after which point it is of no use. Free the memory.
if (log.isDebugEnabled()) {
log.debug("Buffer size " + bufferSize + " has been exceeded and the input stream "
+ "will not be repeatable until the next mark. Freeing buffer memory");
}
buffer = null;
}
// Write to output byte array.
System.arraycopy(tmp, 0, out, outOffset, count);
bytesReadPastMark += count;
return count;
}
/**
* @see java.io.InputStream#read()
*/
public int read() throws IOException {
byte[] tmp = new byte[1];
int count = read(tmp);
if (count != -1) {
return tmp[0];
} else {
return count;
}
}
public InputStream getWrappedInputStream() {
return is;
}
}