mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 06:45:07 +02:00
8187443: Forest Consolidation: Move files to unified layout
Reviewed-by: darcy, ihse
This commit is contained in:
Erik Joelsson
parent
270fe13182
commit
3789983e89
56923 changed files with 3 additions and 15727 deletions
293
src/java.base/share/classes/java/io/LineNumberInputStream.java
Normal file
293
src/java.base/share/classes/java/io/LineNumberInputStream.java
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
/*
|
||||
* Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
package java.io;
|
||||
|
||||
/**
|
||||
* This class is an input stream filter that provides the added
|
||||
* functionality of keeping track of the current line number.
|
||||
* <p>
|
||||
* A line is a sequence of bytes ending with a carriage return
|
||||
* character ({@code '\u005Cr'}), a newline character
|
||||
* ({@code '\u005Cn'}), or a carriage return character followed
|
||||
* immediately by a linefeed character. In all three cases, the line
|
||||
* terminating character(s) are returned as a single newline character.
|
||||
* <p>
|
||||
* The line number begins at {@code 0}, and is incremented by
|
||||
* {@code 1} when a {@code read} returns a newline character.
|
||||
*
|
||||
* @author Arthur van Hoff
|
||||
* @see java.io.LineNumberReader
|
||||
* @since 1.0
|
||||
* @deprecated This class incorrectly assumes that bytes adequately represent
|
||||
* characters. As of JDK 1.1, the preferred way to operate on
|
||||
* character streams is via the new character-stream classes, which
|
||||
* include a class for counting line numbers.
|
||||
*/
|
||||
@Deprecated
|
||||
public
|
||||
class LineNumberInputStream extends FilterInputStream {
|
||||
int pushBack = -1;
|
||||
int lineNumber;
|
||||
int markLineNumber;
|
||||
int markPushBack = -1;
|
||||
|
||||
/**
|
||||
* Constructs a newline number input stream that reads its input
|
||||
* from the specified input stream.
|
||||
*
|
||||
* @param in the underlying input stream.
|
||||
*/
|
||||
public LineNumberInputStream(InputStream in) {
|
||||
super(in);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads the next byte of data from this input stream. The value
|
||||
* byte is returned as an {@code int} in the range
|
||||
* {@code 0} to {@code 255}. If no byte is available
|
||||
* because the end of the stream has been reached, the value
|
||||
* {@code -1} is returned. This method blocks until input data
|
||||
* is available, the end of the stream is detected, or an exception
|
||||
* is thrown.
|
||||
* <p>
|
||||
* The {@code read} method of
|
||||
* {@code LineNumberInputStream} calls the {@code read}
|
||||
* method of the underlying input stream. It checks for carriage
|
||||
* returns and newline characters in the input, and modifies the
|
||||
* current line number as appropriate. A carriage-return character or
|
||||
* a carriage return followed by a newline character are both
|
||||
* converted into a single newline character.
|
||||
*
|
||||
* @return the next byte of data, or {@code -1} if the end of this
|
||||
* stream is reached.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
* @see java.io.FilterInputStream#in
|
||||
* @see java.io.LineNumberInputStream#getLineNumber()
|
||||
*/
|
||||
@SuppressWarnings("fallthrough")
|
||||
public int read() throws IOException {
|
||||
int c = pushBack;
|
||||
|
||||
if (c != -1) {
|
||||
pushBack = -1;
|
||||
} else {
|
||||
c = in.read();
|
||||
}
|
||||
|
||||
switch (c) {
|
||||
case '\r':
|
||||
pushBack = in.read();
|
||||
if (pushBack == '\n') {
|
||||
pushBack = -1;
|
||||
}
|
||||
case '\n':
|
||||
lineNumber++;
|
||||
return '\n';
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads up to {@code len} bytes of data from this input stream
|
||||
* into an array of bytes. This method blocks until some input is available.
|
||||
* <p>
|
||||
* The {@code read} method of
|
||||
* {@code LineNumberInputStream} repeatedly calls the
|
||||
* {@code read} method of zero arguments to fill in the byte array.
|
||||
*
|
||||
* @param b the buffer into which the data is read.
|
||||
* @param off the start offset of the data.
|
||||
* @param len the maximum number of bytes read.
|
||||
* @return the total number of bytes read into the buffer, or
|
||||
* {@code -1} if there is no more data because the end of
|
||||
* this stream has been reached.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
* @see java.io.LineNumberInputStream#read()
|
||||
*/
|
||||
public int read(byte b[], int off, int len) throws IOException {
|
||||
if (b == null) {
|
||||
throw new NullPointerException();
|
||||
} else if ((off < 0) || (off > b.length) || (len < 0) ||
|
||||
((off + len) > b.length) || ((off + len) < 0)) {
|
||||
throw new IndexOutOfBoundsException();
|
||||
} else if (len == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int c = read();
|
||||
if (c == -1) {
|
||||
return -1;
|
||||
}
|
||||
b[off] = (byte)c;
|
||||
|
||||
int i = 1;
|
||||
try {
|
||||
for (; i < len ; i++) {
|
||||
c = read();
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
if (b != null) {
|
||||
b[off + i] = (byte)c;
|
||||
}
|
||||
}
|
||||
} catch (IOException ee) {
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Skips over and discards {@code n} bytes of data from this
|
||||
* input stream. The {@code skip} method may, for a variety of
|
||||
* reasons, end up skipping over some smaller number of bytes,
|
||||
* possibly {@code 0}. The actual number of bytes skipped is
|
||||
* returned. If {@code n} is negative, no bytes are skipped.
|
||||
* <p>
|
||||
* The {@code skip} method of {@code LineNumberInputStream} creates
|
||||
* a byte array and then repeatedly reads into it until
|
||||
* {@code n} bytes have been read or the end of the stream has
|
||||
* been reached.
|
||||
*
|
||||
* @param n the number of bytes to be skipped.
|
||||
* @return the actual number of bytes skipped.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
* @see java.io.FilterInputStream#in
|
||||
*/
|
||||
public long skip(long n) throws IOException {
|
||||
int chunk = 2048;
|
||||
long remaining = n;
|
||||
byte data[];
|
||||
int nr;
|
||||
|
||||
if (n <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
data = new byte[chunk];
|
||||
while (remaining > 0) {
|
||||
nr = read(data, 0, (int) Math.min(chunk, remaining));
|
||||
if (nr < 0) {
|
||||
break;
|
||||
}
|
||||
remaining -= nr;
|
||||
}
|
||||
|
||||
return n - remaining;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the line number to the specified argument.
|
||||
*
|
||||
* @param lineNumber the new line number.
|
||||
* @see #getLineNumber
|
||||
*/
|
||||
public void setLineNumber(int lineNumber) {
|
||||
this.lineNumber = lineNumber;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current line number.
|
||||
*
|
||||
* @return the current line number.
|
||||
* @see #setLineNumber
|
||||
*/
|
||||
public int getLineNumber() {
|
||||
return lineNumber;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of bytes that can be read from this input
|
||||
* stream without blocking.
|
||||
* <p>
|
||||
* Note that if the underlying input stream is able to supply
|
||||
* <i>k</i> input characters without blocking, the
|
||||
* {@code LineNumberInputStream} can guarantee only to provide
|
||||
* <i>k</i>/2 characters without blocking, because the
|
||||
* <i>k</i> characters from the underlying input stream might
|
||||
* consist of <i>k</i>/2 pairs of {@code '\u005Cr'} and
|
||||
* {@code '\u005Cn'}, which are converted to just
|
||||
* <i>k</i>/2 {@code '\u005Cn'} characters.
|
||||
*
|
||||
* @return the number of bytes that can be read from this input stream
|
||||
* without blocking.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
* @see java.io.FilterInputStream#in
|
||||
*/
|
||||
public int available() throws IOException {
|
||||
return (pushBack == -1) ? super.available()/2 : super.available()/2 + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks the current position in this input stream. A subsequent
|
||||
* call to the {@code reset} method repositions this stream at
|
||||
* the last marked position so that subsequent reads re-read the same bytes.
|
||||
* <p>
|
||||
* The {@code mark} method of
|
||||
* {@code LineNumberInputStream} remembers the current line
|
||||
* number in a private variable, and then calls the {@code mark}
|
||||
* method of the underlying input stream.
|
||||
*
|
||||
* @param readlimit the maximum limit of bytes that can be read before
|
||||
* the mark position becomes invalid.
|
||||
* @see java.io.FilterInputStream#in
|
||||
* @see java.io.LineNumberInputStream#reset()
|
||||
*/
|
||||
public void mark(int readlimit) {
|
||||
markLineNumber = lineNumber;
|
||||
markPushBack = pushBack;
|
||||
in.mark(readlimit);
|
||||
}
|
||||
|
||||
/**
|
||||
* Repositions this stream to the position at the time the
|
||||
* {@code mark} method was last called on this input stream.
|
||||
* <p>
|
||||
* The {@code reset} method of
|
||||
* {@code LineNumberInputStream} resets the line number to be
|
||||
* the line number at the time the {@code mark} method was
|
||||
* called, and then calls the {@code reset} method of the
|
||||
* underlying input stream.
|
||||
* <p>
|
||||
* Stream marks are intended to be used in
|
||||
* situations where you need to read ahead a little to see what's in
|
||||
* the stream. Often this is most easily done by invoking some
|
||||
* general parser. If the stream is of the type handled by the
|
||||
* parser, it just chugs along happily. If the stream is not of
|
||||
* that type, the parser should toss an exception when it fails,
|
||||
* which, if it happens within readlimit bytes, allows the outer
|
||||
* code to reset the stream and try another parser.
|
||||
*
|
||||
* @exception IOException if an I/O error occurs.
|
||||
* @see java.io.FilterInputStream#in
|
||||
* @see java.io.LineNumberInputStream#mark(int)
|
||||
*/
|
||||
public void reset() throws IOException {
|
||||
lineNumber = markLineNumber;
|
||||
pushBack = markPushBack;
|
||||
in.reset();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue