com.google.common.io.LineReader Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
The newest version!
/*
* Copyright (C) 2007 The Guava Authors
*
* Licensed 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 com.google.common.io;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.io.CharStreams.createBuffer;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
import java.util.ArrayDeque;
import java.util.Queue;
import javax.annotation.CheckForNull;
/**
* A class for reading lines of text. Provides the same functionality as {@link
* java.io.BufferedReader#readLine()} but for all {@link Readable} objects, not just instances of
* {@link Reader}.
*
* @author Chris Nokleberg
* @since 1.0
*/
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class LineReader {
private final Readable readable;
@CheckForNull private final Reader reader;
private final CharBuffer cbuf = createBuffer();
private final char[] buf = cbuf.array();
private final Queue lines = new ArrayDeque<>();
private final LineBuffer lineBuf =
new LineBuffer() {
@Override
protected void handleLine(String line, String end) {
lines.add(line);
}
};
/** Creates a new instance that will read lines from the given {@code Readable} object. */
public LineReader(Readable readable) {
this.readable = checkNotNull(readable);
this.reader = (readable instanceof Reader) ? (Reader) readable : null;
}
/**
* Reads a line of text. A line is considered to be terminated by any one of a line feed ({@code
* '\n'}), a carriage return ({@code '\r'}), or a carriage return followed immediately by a
* linefeed ({@code "\r\n"}).
*
* @return a {@code String} containing the contents of the line, not including any
* line-termination characters, or {@code null} if the end of the stream has been reached.
* @throws IOException if an I/O error occurs
*/
@CanIgnoreReturnValue // to skip a line
@CheckForNull
public String readLine() throws IOException {
while (lines.peek() == null) {
Java8Compatibility.clear(cbuf);
// The default implementation of Reader#read(CharBuffer) allocates a
// temporary char[], so we call Reader#read(char[], int, int) instead.
int read = (reader != null) ? reader.read(buf, 0, buf.length) : readable.read(cbuf);
if (read == -1) {
lineBuf.finish();
break;
}
lineBuf.add(buf, 0, read);
}
return lines.poll();
}
}