org.apache.commons.io.input.CharSequenceReader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-io Show documentation
Show all versions of commons-io Show documentation
The Apache Commons IO library contains utility classes, stream implementations, file filters,
file comparators, endian transformation classes, and much more.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.io.input;
import static org.apache.commons.io.IOUtils.EOF;
import java.io.Reader;
import java.io.Serializable;
import java.util.Objects;
/**
* {@link Reader} implementation that can read from String, StringBuffer,
* StringBuilder or CharBuffer.
*
* Note: Supports {@link #mark(int)} and {@link #reset()}.
*
*
* @since 1.4
*/
public class CharSequenceReader extends Reader implements Serializable {
private static final long serialVersionUID = 3724187752191401220L;
private final CharSequence charSequence;
private int idx;
private int mark;
/**
* The start index in the character sequence, inclusive.
*
* When de-serializing a CharSequenceReader that was serialized before
* this fields was added, this field will be initialized to 0, which
* gives the same behavior as before: start reading from the start.
*
*
* @see #start()
* @since 2.7
*/
private final int start;
/**
* The end index in the character sequence, exclusive.
*
* When de-serializing a CharSequenceReader that was serialized before
* this fields was added, this field will be initialized to {@code null},
* which gives the same behavior as before: stop reading at the
* CharSequence's length.
* If this field was an int instead, it would be initialized to 0 when the
* CharSequenceReader is de-serialized, causing it to not return any
* characters at all.
*
*
* @see #end()
* @since 2.7
*/
private final Integer end;
/**
* Constructs a new instance with the specified character sequence.
*
* @param charSequence The character sequence, may be {@code null}
*/
public CharSequenceReader(final CharSequence charSequence) {
this(charSequence, 0);
}
/**
* Constructs a new instance with a portion of the specified character sequence.
*
* The start index is not strictly enforced to be within the bounds of the
* character sequence. This allows the character sequence to grow or shrink
* in size without risking any {@link IndexOutOfBoundsException} to be thrown.
* Instead, if the character sequence grows smaller than the start index, this
* instance will act as if all characters have been read.
*
*
* @param charSequence The character sequence, may be {@code null}
* @param start The start index in the character sequence, inclusive
* @throws IllegalArgumentException if the start index is negative
* @since 2.7
*/
public CharSequenceReader(final CharSequence charSequence, final int start) {
this(charSequence, start, Integer.MAX_VALUE);
}
/**
* Constructs a new instance with a portion of the specified character sequence.
*
* The start and end indexes are not strictly enforced to be within the bounds
* of the character sequence. This allows the character sequence to grow or shrink
* in size without risking any {@link IndexOutOfBoundsException} to be thrown.
* Instead, if the character sequence grows smaller than the start index, this
* instance will act as if all characters have been read; if the character sequence
* grows smaller than the end, this instance will use the actual character sequence
* length.
*
*
* @param charSequence The character sequence, may be {@code null}
* @param start The start index in the character sequence, inclusive
* @param end The end index in the character sequence, exclusive
* @throws IllegalArgumentException if the start index is negative, or if the end index is smaller than the start index
* @since 2.7
*/
public CharSequenceReader(final CharSequence charSequence, final int start, final int end) {
if (start < 0) {
throw new IllegalArgumentException(
"Start index is less than zero: " + start);
}
if (end < start) {
throw new IllegalArgumentException(
"End index is less than start " + start + ": " + end);
}
// Don't check the start and end indexes against the CharSequence,
// to let it grow and shrink without breaking existing behavior.
this.charSequence = charSequence != null ? charSequence : "";
this.start = start;
this.end = end;
this.idx = start;
this.mark = start;
}
/**
* Returns the index in the character sequence to start reading from, taking into account its length.
*
* @return The start index in the character sequence (inclusive).
*/
private int start() {
return Math.min(charSequence.length(), start);
}
/**
* Returns the index in the character sequence to end reading at, taking into account its length.
*
* @return The end index in the character sequence (exclusive).
*/
private int end() {
/*
* end == null for de-serialized instances that were serialized before start and end were added.
* Use Integer.MAX_VALUE to get the same behavior as before - use the entire CharSequence.
*/
return Math.min(charSequence.length(), end == null ? Integer.MAX_VALUE : end);
}
/**
* Close resets the file back to the start and removes any marked position.
*/
@Override
public void close() {
idx = start;
mark = start;
}
/**
* Tells whether this stream is ready to be read.
*
* @return {@code true} if more characters from the character sequence are available, or {@code false} otherwise.
*/
@Override
public boolean ready() {
return idx < end();
}
/**
* Mark the current position.
*
* @param readAheadLimit ignored
*/
@Override
public void mark(final int readAheadLimit) {
mark = idx;
}
/**
* Mark is supported (returns true).
*
* @return {@code true}
*/
@Override
public boolean markSupported() {
return true;
}
/**
* Read a single character.
*
* @return the next character from the character sequence
* or -1 if the end has been reached.
*/
@Override
public int read() {
if (idx >= end()) {
return EOF;
}
return charSequence.charAt(idx++);
}
/**
* Read the specified number of characters into the array.
*
* @param array The array to store the characters in
* @param offset The starting position in the array to store
* @param length The maximum number of characters to read
* @return The number of characters read or -1 if there are
* no more
*/
@Override
public int read(final char[] array, final int offset, final int length) {
if (idx >= end()) {
return EOF;
}
Objects.requireNonNull(array, "array");
if (length < 0 || offset < 0 || offset + length > array.length) {
throw new IndexOutOfBoundsException("Array Size=" + array.length +
", offset=" + offset + ", length=" + length);
}
if (charSequence instanceof String) {
final int count = Math.min(length, end() - idx);
((String) charSequence).getChars(idx, idx + count, array, offset);
idx += count;
return count;
}
if (charSequence instanceof StringBuilder) {
final int count = Math.min(length, end() - idx);
((StringBuilder) charSequence).getChars(idx, idx + count, array, offset);
idx += count;
return count;
}
if (charSequence instanceof StringBuffer) {
final int count = Math.min(length, end() - idx);
((StringBuffer) charSequence).getChars(idx, idx + count, array, offset);
idx += count;
return count;
}
int count = 0;
for (int i = 0; i < length; i++) {
final int c = read();
if (c == EOF) {
return count;
}
array[offset + i] = (char)c;
count++;
}
return count;
}
/**
* Reset the reader to the last marked position (or the beginning if
* mark has not been called).
*/
@Override
public void reset() {
idx = mark;
}
/**
* Skip the specified number of characters.
*
* @param n The number of characters to skip
* @return The actual number of characters skipped
*/
@Override
public long skip(final long n) {
if (n < 0) {
throw new IllegalArgumentException(
"Number of characters to skip is less than zero: " + n);
}
if (idx >= end()) {
return 0;
}
final int dest = (int)Math.min(end(), idx + n);
final int count = dest - idx;
idx = dest;
return count;
}
/**
* Return a String representation of the underlying
* character sequence.
*
* @return The contents of the character sequence
*/
@Override
public String toString() {
final CharSequence subSequence = charSequence.subSequence(start(), end());
return subSequence.toString();
}
}