Javadoc.
Better internal names.
Format tweaks.
MODIFY
src/main/java/org/apache/commons/io/input/CharSequenceInputStream.java
src/main/java/org/apache/commons/io/input/CharSequenceInputStream.java
import java.util.Objects;
/**
- * {@link InputStream} implementation that can read from String, StringBuffer,
- * StringBuilder or CharBuffer.
+ * Implements an {@link InputStream} to read from String, StringBuffer, StringBuilder or CharBuffer.
* <p>
* <strong>Note:</strong> Supports {@link #mark(int)} and {@link #reset()}.
* </p>
private static final int NO_MARK = -1;
private final CharsetEncoder charsetEncoder;
- private final CharBuffer cbuf;
- private final ByteBuffer bbuf;
+ private final CharBuffer cBuf;
+ private final ByteBuffer bBuf;
- private int mark_cbuf; // position in cbuf
- private int mark_bbuf; // position in bbuf
+ private int cBufMark; // position in cBuf
+ private int bBufMark; // position in bBuf
/**
- * Constructor, calls {@link #CharSequenceInputStream(CharSequence, Charset, int)}
- * with a buffer size of 2048.
+ * Constructs a new instance with a buffer size of 2048.
*
- * @param cs the input character sequence
- * @param charset the character set name to use
- * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
+ * @param cs the input character sequence.
+ * @param charset the character set name to use.
+ * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character.
*/
public CharSequenceInputStream(final CharSequence cs, final Charset charset) {
this(cs, charset, BUFFER_SIZE);
}
/**
- * Constructor.
+ * Constructs a new instance.
*
- * @param cs the input character sequence
- * @param charset the character set name to use
+ * @param cs the input character sequence.
+ * @param charset the character set name to use.
* @param bufferSize the buffer size to use.
- * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
+ * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character.
*/
public CharSequenceInputStream(final CharSequence cs, final Charset charset, final int bufferSize) {
// @formatter:off
@@ -79,32 +77,31 @@ public CharSequenceInputStream(final CharSequence cs, final Charset charset, fin
.onUnmappableCharacter(CodingErrorAction.REPLACE);
// @formatter:on
// Ensure that buffer is long enough to hold a complete character
- this.bbuf = ByteBuffer.allocate(ReaderInputStream.checkMinBufferSize(charsetEncoder, bufferSize));
- this.bbuf.flip();
- this.cbuf = CharBuffer.wrap(cs);
- this.mark_cbuf = NO_MARK;
- this.mark_bbuf = NO_MARK;
+ this.bBuf = ByteBuffer.allocate(ReaderInputStream.checkMinBufferSize(charsetEncoder, bufferSize));
+ this.bBuf.flip();
+ this.cBuf = CharBuffer.wrap(cs);
+ this.cBufMark = NO_MARK;
+ this.bBufMark = NO_MARK;
}
/**
- * Constructor, calls {@link #CharSequenceInputStream(CharSequence, String, int)}
- * with a buffer size of 2048.
+ * Constructs a new instance with a buffer size of 2048.
*
- * @param cs the input character sequence
- * @param charset the character set name to use
- * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
+ * @param cs the input character sequence.
+ * @param charset the character set name to use.
+ * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character.
*/
public CharSequenceInputStream(final CharSequence cs, final String charset) {
this(cs, charset, BUFFER_SIZE);
}
/**
- * Constructor, calls {@link #CharSequenceInputStream(CharSequence, Charset, int)}.
+ * Constructs a new instance.
*
- * @param cs the input character sequence
- * @param charset the character set name to use
+ * @param cs the input character sequence.
+ * @param charset the character set name to use.
* @param bufferSize the buffer size to use.
- * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
+ * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character.
*/
public CharSequenceInputStream(final CharSequence cs, final String charset, final int bufferSize) {
this(cs, Charset.forName(charset), bufferSize);
@@ -114,7 +111,7 @@ public CharSequenceInputStream(final CharSequence cs, final String charset, fina
* Return an estimate of the number of bytes remaining in the byte stream.
* @return the count of bytes that can be read without blocking (or returning EOF).
*
- * @throws IOException if an error occurs (probably not possible)
+ * @throws IOException if an error occurs (probably not possible).
*/
@Override
public int available() throws IOException {
@@ -122,7 +119,7 @@ public int available() throws IOException {
// per character, we can add the two to get a better estimate (e.g. if bbuf is empty)
// Note that the previous implementation (2.4) could return zero even though there were
// encoded bytes still available.
- return this.bbuf.remaining() + this.cbuf.remaining();
+ return this.bBuf.remaining() + this.cBuf.remaining();
}
@Override
@@ -134,27 +131,27 @@ public void close() throws IOException {
* Fills the byte output buffer from the input char buffer.
*
* @throws CharacterCodingException
- * an error encoding data
+ * an error encoding data.
*/
private void fillBuffer() throws CharacterCodingException {
- this.bbuf.compact();
- final CoderResult result = this.charsetEncoder.encode(this.cbuf, this.bbuf, true);
+ this.bBuf.compact();
+ final CoderResult result = this.charsetEncoder.encode(this.cBuf, this.bBuf, true);
if (result.isError()) {
result.throwException();
}
- this.bbuf.flip();
+ this.bBuf.flip();
}
/**
* {@inheritDoc}
- * @param readlimit max read limit (ignored)
+ * @param readlimit max read limit (ignored).
*/
@Override
public synchronized void mark(final int readlimit) {
- this.mark_cbuf = this.cbuf.position();
- this.mark_bbuf = this.bbuf.position();
- this.cbuf.mark();
- this.bbuf.mark();
+ this.cBufMark = this.cBuf.position();
+ this.bBufMark = this.bBuf.position();
+ this.cBuf.mark();
+ this.bBuf.mark();
// It would be nice to be able to use mark & reset on the cbuf and bbuf;
// however the bbuf is re-used so that won't work
}
@@ -167,11 +164,11 @@ public boolean markSupported() {
@Override
public int read() throws IOException {
for (;;) {
- if (this.bbuf.hasRemaining()) {
- return this.bbuf.get() & 0xFF;
+ if (this.bBuf.hasRemaining()) {
+ return this.bBuf.get() & 0xFF;
}
fillBuffer();
- if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
+ if (!this.bBuf.hasRemaining() && !this.cBuf.hasRemaining()) {
return EOF;
}
}
@@ -186,74 +183,73 @@ public int read(final byte[] b) throws IOException {
public int read(final byte[] array, int off, int len) throws IOException {
Objects.requireNonNull(array, "array");
if (len < 0 || (off + len) > array.length) {
- throw new IndexOutOfBoundsException("Array Size=" + array.length +
- ", offset=" + off + ", length=" + len);
+ throw new IndexOutOfBoundsException("Array Size=" + array.length + ", offset=" + off + ", length=" + len);
}
if (len == 0) {
return 0; // must return 0 for zero length read
}
- if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
+ if (!this.bBuf.hasRemaining() && !this.cBuf.hasRemaining()) {
return EOF;
}
int bytesRead = 0;
while (len > 0) {
- if (this.bbuf.hasRemaining()) {
- final int chunk = Math.min(this.bbuf.remaining(), len);
- this.bbuf.get(array, off, chunk);
+ if (this.bBuf.hasRemaining()) {
+ final int chunk = Math.min(this.bBuf.remaining(), len);
+ this.bBuf.get(array, off, chunk);
off += chunk;
len -= chunk;
bytesRead += chunk;
} else {
fillBuffer();
- if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
+ if (!this.bBuf.hasRemaining() && !this.cBuf.hasRemaining()) {
break;
}
}
}
- return bytesRead == 0 && !this.cbuf.hasRemaining() ? EOF : bytesRead;
+ return bytesRead == 0 && !this.cBuf.hasRemaining() ? EOF : bytesRead;
}
@Override
public synchronized void reset() throws IOException {
- /*
- * This is not the most efficient implementation, as it re-encodes from the beginning.
- *
- * Since the bbuf is re-used, in general it's necessary to re-encode the data.
- *
- * It should be possible to apply some optimisations however:
- * + use mark/reset on the cbuf and bbuf. This would only work if the buffer had not been (re)filled since
- * the mark. The code would have to catch InvalidMarkException - does not seem possible to check if mark is
- * valid otherwise. + Try saving the state of the cbuf before each fillBuffer; it might be possible to
- * restart from there.
- */
- if (this.mark_cbuf != NO_MARK) {
+ //
+ // This is not the most efficient implementation, as it re-encodes from the beginning.
+ //
+ // Since the bbuf is re-used, in general it's necessary to re-encode the data.
+ //
+ // It should be possible to apply some optimisations however:
+ // + use mark/reset on the cbuf and bbuf. This would only work if the buffer had not been (re)filled since
+ // the mark. The code would have to catch InvalidMarkException - does not seem possible to check if mark is
+ // valid otherwise. + Try saving the state of the cbuf before each fillBuffer; it might be possible to
+ // restart from there.
+ //
+ if (this.cBufMark != NO_MARK) {
// if cbuf is at 0, we have not started reading anything, so skip re-encoding
- if (this.cbuf.position() != 0) {
+ if (this.cBuf.position() != 0) {
this.charsetEncoder.reset();
- this.cbuf.rewind();
- this.bbuf.rewind();
- this.bbuf.limit(0); // rewind does not clear the buffer
- while(this.cbuf.position() < this.mark_cbuf) {
- this.bbuf.rewind(); // empty the buffer (we only refill when empty during normal processing)
- this.bbuf.limit(0);
+ this.cBuf.rewind();
+ this.bBuf.rewind();
+ this.bBuf.limit(0); // rewind does not clear the buffer
+ while(this.cBuf.position() < this.cBufMark) {
+ this.bBuf.rewind(); // empty the buffer (we only refill when empty during normal processing)
+ this.bBuf.limit(0);
fillBuffer();
}
}
- if (this.cbuf.position() != this.mark_cbuf) {
- throw new IllegalStateException("Unexpected CharBuffer position: actual=" + cbuf.position() + " " +
- "expected=" + this.mark_cbuf);
+ if (this.cBuf.position() != this.cBufMark) {
+ throw new IllegalStateException("Unexpected CharBuffer position: actual=" + cBuf.position() + " " +
+ "expected=" + this.cBufMark);
}
- this.bbuf.position(this.mark_bbuf);
- this.mark_cbuf = NO_MARK;
- this.mark_bbuf = NO_MARK;
+ this.bBuf.position(this.bBufMark);
+ this.cBufMark = NO_MARK;
+ this.bBufMark = NO_MARK;
}
}
@Override
public long skip(long n) throws IOException {
- /*
- * This could be made more efficient by using position to skip within the current buffer.
- */
+ //
+ // This could be made more efficient by using position to skip within the current buffer.
+ //
long skipped = 0;
while (n > 0 && available() > 0) {
this.read();

Javadoc.

Better internal names.
Format tweaks.