All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.xmlgraphics.image.codec.util.SeekableStream Maven / Gradle / Ivy

There is a newer version: 6.0.36
Show newest version
/*
 * 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.
 */

/* $Id: SeekableStream.java 1732018 2016-02-24 04:51:06Z gadams $ */

package org.apache.xmlgraphics.image.codec.util;

import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

/**
 * An abstract subclass of java.io.InputStream that allows seeking
 * within the input, similar to the RandomAccessFile class.
 * Additionally, the DataInput interface is supported and extended
 * to include support for little-endian representations of fundamental data
 * types.
 *
 * 

In addition to the familiar methods from InputStream, the * methods getFilePointer(), seek(), are defined as in * the RandomAccessFile class. The canSeekBackwards() * method will return true if it is permissible to seek to a * position earlier in the stream than the current value of * getFilePointer(). Some subclasses of * SeekableStream guarantee the ability to seek backwards while * others may not offer this feature in the interest of providing greater * efficiency for those users who do not require it. * *

The DataInput interface is supported as well. This included * the skipBytes() and readFully() methods and a * variety of read methods for various data types. * *

Three classes are provided for the purpose of adapting a standard * InputStream to the SeekableStream interface. * ForwardSeekableStream does not allows seeking backwards, but is * inexpensive to use. FileCacheSeekableStream maintains a copy of * all of the data read from the input in a temporary file; this file will be * discarded automatically when the FileSeekableStream is * finalized, or when the JVM exits normally. * FileCacheSeekableStream is intended to be reasonably efficient * apart from the unavoidable use of disk space. In circumstances where the * creation of a temporary file is not possible, * MemoryCacheSeekableStream may be used. * MemoryCacheSeekableStream creates a potentially large in-memory * buffer to store the stream data and so should be avoided when possible. * *

The FileSeekableStream class wraps a File or * RandomAccessFile. It forwards requests to the real underlying * file. It performs a limited amount of caching in order to avoid excessive * I/O costs. * *

The SegmentedSeekableStream class performs a different sort * of function. It creates a SeekableStream from another * SeekableStream by selecting a series of portions or "segments". * Each segment starts at a specified location within the source * SeekableStream and extends for a specified number of bytes. The * StreamSegmentMapper interface and StreamSegment * class may be used to compute the segment positions dynamically. * *

A convenience methods, wrapInputStream is provided to * construct a suitable SeekableStream instance whose data is * supplied by a given InputStream. The caller, by means of the * canSeekBackwards parameter, determines whether support for * seeking backwards is required. * */ public abstract class SeekableStream extends InputStream implements DataInput { /** * Returns a SeekableStream that will read from a * given InputStream, optionally including support * for seeking backwards. This is a convenience method that * avoids the need to instantiate specific subclasses of * SeekableStream depending on the current security * model. * * @param is An InputStream. * @param canSeekBackwards true if the ability to seek * backwards in the output is required. * @return An instance of SeekableStream. */ public static SeekableStream wrapInputStream(InputStream is, boolean canSeekBackwards) { SeekableStream stream = null; if (canSeekBackwards) { try { stream = new FileCacheSeekableStream(is); } catch (Exception e) { stream = new MemoryCacheSeekableStream(is); } } else { stream = new ForwardSeekableStream(is); } return stream; } // Methods from InputStream /** * Reads the next byte of data from the input stream. The value byte is * returned as an int in the range 0 to * 255. If no byte is available because the end of the stream * has been reached, the value -1 is returned. This method * blocks until input data is available, the end of the stream is detected, * or an exception is thrown. * *

A subclass must provide an implementation of this method. * * @return the next byte of data, or -1 if the end of the * stream is reached. * @exception IOException if an I/O error occurs. */ public abstract int read() throws IOException; /** * Reads up to len bytes of data from the input stream into * an array of bytes. An attempt is made to read as many as * len bytes, but a smaller number may be read, possibly * zero. The number of bytes actually read is returned as an integer. * *

This method blocks until input data is available, end of stream is * detected, or an exception is thrown. * *

If b is null, a * NullPointerException is thrown. * *

If off is negative, or len is negative, or * off+len is greater than the length of the array * b, then an IndexOutOfBoundsException is * thrown. * *

If len is zero, then no bytes are read and * 0 is returned; otherwise, there is an attempt to read at * least one byte. If no byte is available because the stream is at end of * stream, the value -1 is returned; otherwise, at least one * byte is read and stored into b. * *

The first byte read is stored into element b[off], the * next one into b[off+1], and so on. The number of bytes read * is, at most, equal to len. Let k be the number of * bytes actually read; these bytes will be stored in elements * b[off] through b[off+k-1], * leaving elements b[off+k] through * b[off+len-1] unaffected. * *

In every case, elements b[0] through * b[off] and elements b[off+len] through * b[b.length-1] are unaffected. * *

If the first byte cannot be read for any reason other than end of * stream, then an IOException is thrown. In particular, an * IOException is thrown if the input stream has been closed. * *

A subclass must provide an implementation of this method. * * @param b the buffer into which the data is read. * @param off the start offset in array b * at which the data is written. * @param len the maximum number of bytes to read. * @return the total number of bytes read into the buffer, or * -1 if there is no more data because the end of * the stream has been reached. * @exception IOException if an I/O error occurs. */ public abstract int read(byte[] b, int off, int len) throws IOException; // Implemented in InputStream: // // public int read(byte[] b) throws IOException { // public long skip(long n) throws IOException // public int available) throws IOException // public void close() throws IOException; /** Marked position, shared by {@link ForwardSeekableStream} */ protected long markPos = -1L; /** * Marks the current file position for later return using * the reset() method. */ public synchronized void mark(int readLimit) { try { markPos = getFilePointer(); } catch (IOException e) { markPos = -1L; } } /** * Returns the file position to its position at the time of * the immediately previous call to the mark() * method. */ public synchronized void reset() throws IOException { if (markPos != -1) { seek(markPos); } } /** * Returns true if marking is supported. * Marking is automatically supported for SeekableStream * subclasses that support seeking backeards. Subclasses that do * not support seeking backwards but do support marking must override * this method. */ public boolean markSupported() { return canSeekBackwards(); } /** * Returns true if this object supports calls to * seek(pos) with an offset pos smaller * than the current offset, as returned by getFilePointer. */ public boolean canSeekBackwards() { return false; } /** * Returns the current offset in this stream. * * @return the offset from the beginning of the stream, in bytes, * at which the next read occurs. * @exception IOException if an I/O error occurs. */ public abstract long getFilePointer() throws IOException; /** * Sets the offset, measured from the beginning of this * stream, at which the next read occurs. * *

If canSeekBackwards() returns false, * then setting pos to an offset smaller than * the current value of getFilePointer() will have * no effect. * * @param pos the offset position, measured in bytes from the * beginning of the stream, at which to set the stream * pointer. * @exception IOException if pos is less than * 0 or if an I/O error occurs. */ public abstract void seek(long pos) throws IOException; // Methods from RandomAccessFile /** * Reads b.length bytes from this stream into the byte * array, starting at the current stream pointer. This method reads * repeatedly from the stream until the requested number of bytes are * read. This method blocks until the requested number of bytes are * read, the end of the stream is detected, or an exception is thrown. * * @param b the buffer into which the data is read. * @exception EOFException if this stream reaches the end before reading * all the bytes. * @exception IOException if an I/O error occurs. */ public final void readFully(byte[] b) throws IOException { readFully(b, 0, b.length); } /** * Reads exactly len bytes from this stream into the byte * array, starting at the current stream pointer. This method reads * repeatedly from the stream until the requested number of bytes are * read. This method blocks until the requested number of bytes are * read, the end of the stream is detected, or an exception is thrown. * * @param b the buffer into which the data is read. * @param off the start offset of the data. * @param len the number of bytes to read. * @exception EOFException if this stream reaches the end before reading * all the bytes. * @exception IOException if an I/O error occurs. */ public final void readFully(byte[] b, int off, int len) throws IOException { int n = 0; do { int count = this.read(b, off + n, len - n); if (count < 0) { throw new EOFException(); } n += count; } while (n < len); } // Methods from DataInput, plus little-endian versions /** * Attempts to skip over n bytes of input discarding the * skipped bytes. *

* * This method may skip over some smaller number of bytes, possibly zero. * This may result from any of a number of conditions; reaching end of * stream before n bytes have been skipped is only one * possibility. This method never throws an EOFException. * The actual number of bytes skipped is returned. If n * is negative, no bytes are skipped. * * @param n the number of bytes to be skipped. * @return the actual number of bytes skipped. * @exception IOException if an I/O error occurs. */ public int skipBytes(int n) throws IOException { if (n <= 0) { return 0; } return (int)skip(n); } /** * Reads a boolean from this stream. This method reads a * single byte from the stream, starting at the current stream pointer. * A value of 0 represents * false. Any other value represents true. * This method blocks until the byte is read, the end of the stream * is detected, or an exception is thrown. * * @return the boolean value read. * @exception EOFException if this stream has reached the end. * @exception IOException if an I/O error occurs. */ public final boolean readBoolean() throws IOException { int ch = this.read(); if (ch < 0) { throw new EOFException(); } return (ch != 0); } /** * Reads a signed eight-bit value from this stream. This method reads a * byte from the stream, starting from the current stream pointer. * If the byte read is b, where * 0 <= b <= 255, * then the result is: *

     *     (byte)(b)
     * 
*

* This method blocks until the byte is read, the end of the stream * is detected, or an exception is thrown. * * @return the next byte of this stream as a signed eight-bit * byte. * @exception EOFException if this stream has reached the end. * @exception IOException if an I/O error occurs. */ public final byte readByte() throws IOException { int ch = this.read(); if (ch < 0) { throw new EOFException(); } return (byte)(ch); } /** * Reads an unsigned eight-bit number from this stream. This method reads * a byte from this stream, starting at the current stream pointer, * and returns that byte. *

* This method blocks until the byte is read, the end of the stream * is detected, or an exception is thrown. * * @return the next byte of this stream, interpreted as an unsigned * eight-bit number. * @exception EOFException if this stream has reached the end. * @exception IOException if an I/O error occurs. */ public final int readUnsignedByte() throws IOException { int ch = this.read(); if (ch < 0) { throw new EOFException(); } return ch; } /** * Reads a signed 16-bit number from this stream. * The method reads two * bytes from this stream, starting at the current stream pointer. * If the two bytes read, in order, are * b1 and b2, where each of the two values is * between 0 and 255, inclusive, then the * result is equal to: *

     *     (short)((b1 << 8) | b2)
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream, interpreted as a signed * 16-bit number. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final short readShort() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (short)((ch1 << 8) + (ch2 << 0)); } /** * Reads a signed 16-bit number from this stream in little-endian order. * The method reads two * bytes from this stream, starting at the current stream pointer. * If the two bytes read, in order, are * b1 and b2, where each of the two values is * between 0 and 255, inclusive, then the * result is equal to: *

     *     (short)((b2 << 8) | b1)
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream, interpreted as a signed * 16-bit number. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final short readShortLE() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (short)((ch2 << 8) + (ch1 << 0)); } /** * Reads an unsigned 16-bit number from this stream. This method reads * two bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1 and b2, where * 0 <= b1, b2 <= 255, * then the result is equal to: *

     *     (b1 << 8) | b2
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream, interpreted as an * unsigned 16-bit integer. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final int readUnsignedShort() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (ch1 << 8) + (ch2 << 0); } /** * Reads an unsigned 16-bit number from this stream in little-endian order. * This method reads * two bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1 and b2, where * 0 <= b1, b2 <= 255, * then the result is equal to: *

     *     (b2 << 8) | b1
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream, interpreted as an * unsigned 16-bit integer. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final int readUnsignedShortLE() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (ch2 << 8) + (ch1 << 0); } /** * Reads a Unicode character from this stream. This method reads two * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1 and b2, where * 0 <= b1, b2 <= 255, * then the result is equal to: *

     *     (char)((b1 << 8) | b2)
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream as a Unicode character. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final char readChar() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (char)((ch1 << 8) + (ch2 << 0)); } /** * Reads a Unicode character from this stream in little-endian order. * This method reads two * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1 and b2, where * 0 <= b1, b2 <= 255, * then the result is equal to: *

     *     (char)((b2 << 8) | b1)
     * 
*

* This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this stream as a Unicode character. * @exception EOFException if this stream reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final char readCharLE() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (char)((ch2 << 8) + (ch1 << 0)); } /** * Reads a signed 32-bit integer from this stream. This method reads 4 * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are b1, * b2, b3, and b4, where * 0 <= b1, b2, b3, b4 <= 255, * then the result is equal to: *

     *     (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
     * 
*

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as an * int. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final int readInt() throws IOException { int ch1 = this.read(); int ch2 = this.read(); int ch3 = this.read(); int ch4 = this.read(); if ((ch1 | ch2 | ch3 | ch4) < 0) { throw new EOFException(); } return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); } /** * Reads a signed 32-bit integer from this stream in little-endian order. * This method reads 4 * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are b1, * b2, b3, and b4, where * 0 <= b1, b2, b3, b4 <= 255, * then the result is equal to: *

     *     (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
     * 
*

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as an * int. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final int readIntLE() throws IOException { int ch1 = this.read(); int ch2 = this.read(); int ch3 = this.read(); int ch4 = this.read(); if ((ch1 | ch2 | ch3 | ch4) < 0) { throw new EOFException(); } return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0)); } /** * Reads an unsigned 32-bit integer from this stream. This method reads 4 * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are b1, * b2, b3, and b4, where * 0 <= b1, b2, b3, b4 <= 255, * then the result is equal to: *

     *     (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
     * 
*

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as a * long. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final long readUnsignedInt() throws IOException { long ch1 = this.read(); long ch2 = this.read(); long ch3 = this.read(); long ch4 = this.read(); if ((ch1 | ch2 | ch3 | ch4) < 0) { throw new EOFException(); } return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); } private byte[] ruileBuf = new byte[4]; /** * Reads an unsigned 32-bit integer from this stream in little-endian * order. This method reads 4 * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are b1, * b2, b3, and b4, where * 0 <= b1, b2, b3, b4 <= 255, * then the result is equal to: *

     *     (b4 << 24) | (b3 << 16) + (b2 << 8) + b1
     * 
*

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as a * long. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final long readUnsignedIntLE() throws IOException { this.readFully(ruileBuf); long ch1 = (ruileBuf[0] & 0xff); long ch2 = (ruileBuf[1] & 0xff); long ch3 = (ruileBuf[2] & 0xff); long ch4 = (ruileBuf[3] & 0xff); return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0)); } /** * Reads a signed 64-bit integer from this stream. This method reads eight * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1, b2, b3, * b4, b5, b6, * b7, and b8, where: *

     *     0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
     * 
*

* then the result is equal to: *

     *     ((long)b1 << 56) + ((long)b2 << 48)
     *     + ((long)b3 << 40) + ((long)b4 << 32)
     *     + ((long)b5 << 24) + ((long)b6 << 16)
     *     + ((long)b7 << 8) + b8
     * 
*

* This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this stream, interpreted as a * long. * @exception EOFException if this stream reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. */ public final long readLong() throws IOException { return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL); } /** * Reads a signed 64-bit integer from this stream in little-endian * order. This method reads eight * bytes from the stream, starting at the current stream pointer. * If the bytes read, in order, are * b1, b2, b3, * b4, b5, b6, * b7, and b8, where: *

     *     0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
     * 
*

* then the result is equal to: *

     *     ((long)b1 << 56) + ((long)b2 << 48)
     *     + ((long)b3 << 40) + ((long)b4 << 32)
     *     + ((long)b5 << 24) + ((long)b6 << 16)
     *     + ((long)b7 << 8) + b8
     * 
*

* This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this stream, interpreted as a * long. * @exception EOFException if this stream reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. */ public final long readLongLE() throws IOException { int i1 = readIntLE(); int i2 = readIntLE(); return ((long)i2 << 32) + (i1 & 0xFFFFFFFFL); } /** * Reads a float from this stream. This method reads an * int value, starting at the current stream pointer, * as if by the readInt method * and then converts that int to a float * using the intBitsToFloat method in class * Float. *

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as a * float. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final float readFloat() throws IOException { return Float.intBitsToFloat(readInt()); } /** * Reads a float from this stream in little-endian order. * This method reads an * int value, starting at the current stream pointer, * as if by the readInt method * and then converts that int to a float * using the intBitsToFloat method in class * Float. *

* This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this stream, interpreted as a * float. * @exception EOFException if this stream reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final float readFloatLE() throws IOException { return Float.intBitsToFloat(readIntLE()); } /** * Reads a double from this stream. This method reads a * long value, starting at the current stream pointer, * as if by the readLong method * and then converts that long to a double * using the longBitsToDouble method in * class Double. *

* This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this stream, interpreted as a * double. * @exception EOFException if this stream reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. */ public final double readDouble() throws IOException { return Double.longBitsToDouble(readLong()); } /** * Reads a double from this stream in little-endian order. * This method reads a * long value, starting at the current stream pointer, * as if by the readLong method * and then converts that long to a double * using the longBitsToDouble method in * class Double. *

* This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this stream, interpreted as a * double. * @exception EOFException if this stream reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. */ public final double readDoubleLE() throws IOException { return Double.longBitsToDouble(readLongLE()); } /** * Reads the next line of text from this stream. This method successively * reads bytes from the stream, starting at the current stream pointer, * until it reaches a line terminator or the end * of the stream. Each byte is converted into a character by taking the * byte's value for the lower eight bits of the character and setting the * high eight bits of the character to zero. This method does not, * therefore, support the full Unicode character set. * *

A line of text is terminated by a carriage-return character * ('\r'), a newline character ('\n'), a * carriage-return character immediately followed by a newline character, * or the end of the stream. Line-terminating characters are discarded and * are not included as part of the string returned. * *

This method blocks until a newline character is read, a carriage * return and the byte following it are read (to see if it is a newline), * the end of the stream is reached, or an exception is thrown. * * @return the next line of text from this stream, or null if end * of stream is encountered before even one byte is read. * @exception IOException if an I/O error occurs. */ public final String readLine() throws IOException { StringBuffer input = new StringBuffer(); int c = -1; boolean eol = false; while (!eol) { c = read(); switch (c) { case -1: case '\n': eol = true; break; case '\r': eol = true; long cur = getFilePointer(); if ((read()) != '\n') { seek(cur); } break; default: input.append((char)c); break; } } if ((c == -1) && (input.length() == 0)) { return null; } return input.toString(); } /** * Reads in a string from this stream. The string has been encoded * using a modified UTF-8 format. *

* The first two bytes are read, starting from the current stream * pointer, as if by * readUnsignedShort. This value gives the number of * following bytes that are in the encoded string, not * the length of the resulting string. The following bytes are then * interpreted as bytes encoding characters in the UTF-8 format * and are converted into characters. *

* This method blocks until all the bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return a Unicode string. * @exception EOFException if this stream reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * @exception java.io.UTFDataFormatException if the bytes do not represent * valid UTF-8 encoding of a Unicode string. */ public final String readUTF() throws IOException { return DataInputStream.readUTF(this); } /** * Releases any system resources associated with this stream * by calling the close() method. */ protected void finalize() throws Throwable { super.finalize(); close(); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy