| /* |
| * 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 java.io; |
| |
| import android.system.ErrnoException; |
| import dalvik.system.CloseGuard; |
| import java.nio.ByteOrder; |
| import java.nio.channels.FileChannel; |
| import java.nio.charset.ModifiedUtf8; |
| import java.nio.NioUtils; |
| import java.util.Arrays; |
| import libcore.io.IoBridge; |
| import libcore.io.Libcore; |
| import libcore.io.Memory; |
| import libcore.io.SizeOf; |
| import static android.system.OsConstants.*; |
| |
| /** |
| * Allows reading from and writing to a file in a random-access manner. This is |
| * different from the uni-directional sequential access that a |
| * {@link FileInputStream} or {@link FileOutputStream} provides. If the file is |
| * opened in read/write mode, write operations are available as well. The |
| * position of the next read or write operation can be moved forwards and |
| * backwards after every operation. |
| */ |
| public class RandomAccessFile implements DataInput, DataOutput, Closeable { |
| /** |
| * The FileDescriptor representing this RandomAccessFile. |
| */ |
| private FileDescriptor fd; |
| |
| // The unique file channel associated with this FileInputStream (lazily |
| // initialized). |
| private FileChannel channel; |
| |
| private int mode; |
| |
| private final CloseGuard guard = CloseGuard.get(); |
| |
| private final byte[] scratch = new byte[8]; |
| |
| /** |
| * Constructs a new {@code RandomAccessFile} based on {@code file} and opens |
| * it according to the access string in {@code mode}. |
| * <p><a id="accessmode"/> |
| * {@code mode} may have one of following values: |
| * <table border="0"> |
| * <tr> |
| * <td>{@code "r"}</td> |
| * <td>The file is opened in read-only mode. An {@code IOException} is |
| * thrown if any of the {@code write} methods is called.</td> |
| * </tr> |
| * <tr> |
| * <td>{@code "rw"}</td> |
| * <td>The file is opened for reading and writing. If the file does not |
| * exist, it will be created.</td> |
| * </tr> |
| * <tr> |
| * <td>{@code "rws"}</td> |
| * <td>The file is opened for reading and writing. Every change of the |
| * file's content or metadata must be written synchronously to the target |
| * device.</td> |
| * </tr> |
| * <tr> |
| * <td>{@code "rwd"}</td> |
| * <td>The file is opened for reading and writing. Every change of the |
| * file's content must be written synchronously to the target device.</td> |
| * </tr> |
| * </table> |
| * |
| * @param file |
| * the file to open. |
| * @param mode |
| * the file access <a href="#accessmode">mode</a>, either {@code |
| * "r"}, {@code "rw"}, {@code "rws"} or {@code "rwd"}. |
| * @throws FileNotFoundException |
| * if the file cannot be opened or created according to {@code |
| * mode}. |
| * @throws IllegalArgumentException |
| * if {@code mode} is not {@code "r"}, {@code "rw"}, {@code |
| * "rws"} or {@code "rwd"}. |
| */ |
| public RandomAccessFile(File file, String mode) throws FileNotFoundException { |
| int flags; |
| if (mode.equals("r")) { |
| flags = O_RDONLY; |
| } else if (mode.equals("rw") || mode.equals("rws") || mode.equals("rwd")) { |
| flags = O_RDWR | O_CREAT; |
| if (mode.equals("rws")) { |
| // Sync data and metadata with every write |
| flags |= O_SYNC; |
| } else if (mode.equals("rwd")) { |
| // Sync data, but not necessarily metadata |
| flags |= O_DSYNC; |
| } |
| } else { |
| throw new IllegalArgumentException("Invalid mode: " + mode); |
| } |
| this.mode = flags; |
| this.fd = IoBridge.open(file.getPath(), flags); |
| |
| guard.open("close"); |
| } |
| |
| /** |
| * Constructs a new {@code RandomAccessFile} based on the file named {@code |
| * fileName} and opens it according to the access string in {@code mode}. |
| * The file path may be specified absolutely or relative to the system |
| * property {@code "user.dir"}. |
| * |
| * @param fileName |
| * the name of the file to open. |
| * @param mode |
| * the file access <a href="#accessmode">mode</a>, either {@code |
| * "r"}, {@code "rw"}, {@code "rws"} or {@code "rwd"}. |
| * @throws FileNotFoundException |
| * if the file cannot be opened or created according to {@code |
| * mode}. |
| * @throws IllegalArgumentException |
| * if {@code mode} is not {@code "r"}, {@code "rw"}, {@code |
| * "rws"} or {@code "rwd"}. |
| */ |
| public RandomAccessFile(String fileName, String mode) throws FileNotFoundException { |
| this(new File(fileName), mode); |
| } |
| |
| /** |
| * Closes this file. |
| * |
| * @throws IOException |
| * if an error occurs while closing this file. |
| */ |
| public void close() throws IOException { |
| guard.close(); |
| synchronized (this) { |
| if (channel != null && channel.isOpen()) { |
| channel.close(); |
| } |
| IoBridge.closeAndSignalBlockedThreads(fd); |
| } |
| } |
| |
| @Override protected void finalize() throws Throwable { |
| try { |
| if (guard != null) { |
| guard.warnIfOpen(); |
| } |
| close(); |
| } finally { |
| super.finalize(); |
| } |
| } |
| |
| /** |
| * Gets this file's {@link FileChannel} object. |
| * <p> |
| * The file channel's {@link FileChannel#position() position} is the same |
| * as this file's file pointer offset (see {@link #getFilePointer()}). Any |
| * changes made to this file's file pointer offset are also visible in the |
| * file channel's position and vice versa. |
| * |
| * Closing the channel closes the RandomAccessFile as well. The instance |
| * of FileChannel returned is always the same even if the RandomAccessFile |
| * or the FileChannel have been closed. |
| * |
| * @return this file's file channel instance. |
| */ |
| public final synchronized FileChannel getChannel() { |
| if(channel == null) { |
| channel = NioUtils.newFileChannel(this, fd, mode); |
| } |
| return channel; |
| } |
| |
| /** |
| * Gets this file's {@link FileDescriptor}. This represents the operating |
| * system resource for this random access file. |
| * |
| * @return this file's file descriptor object. |
| * @throws IOException |
| * if an error occurs while getting the file descriptor of this |
| * file. |
| */ |
| public final FileDescriptor getFD() throws IOException { |
| return fd; |
| } |
| |
| /** |
| * Gets the current position within this file. All reads and |
| * writes take place at the current file pointer position. |
| * |
| * @return the current offset in bytes from the beginning of the file. |
| * |
| * @throws IOException |
| * if an error occurs while getting the file pointer of this |
| * file. |
| */ |
| public long getFilePointer() throws IOException { |
| try { |
| return Libcore.os.lseek(fd, 0L, SEEK_CUR); |
| } catch (ErrnoException errnoException) { |
| throw errnoException.rethrowAsIOException(); |
| } |
| } |
| |
| /** |
| * Returns the length of this file in bytes. |
| * |
| * @return the file's length in bytes. |
| * @throws IOException |
| * if this file is closed or some other I/O error occurs. |
| */ |
| public long length() throws IOException { |
| try { |
| return Libcore.os.fstat(fd).st_size; |
| } catch (ErrnoException errnoException) { |
| throw errnoException.rethrowAsIOException(); |
| } |
| } |
| |
| /** |
| * Reads a single byte from the current position in this file and returns it |
| * as an integer in the range from 0 to 255. Returns -1 if the end of the |
| * file has been reached. Blocks until one byte has been read, the end of |
| * the file is detected, or an exception is thrown. |
| * |
| * @return the byte read or -1 if the end of the file has been reached. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public int read() throws IOException { |
| return (read(scratch, 0, 1) != -1) ? scratch[0] & 0xff : -1; |
| } |
| |
| /** |
| * Reads bytes from the current position in this file and stores them in the |
| * byte array {@code buffer}. The maximum number of bytes read corresponds |
| * to the size of {@code buffer}. Blocks until at least one byte has been |
| * read, the end of the file is detected, or an exception is thrown. |
| * Returns the number of bytes actually read or -1 if the end of the file |
| * has been reached. See also {@link #readFully}. |
| * |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public int read(byte[] buffer) throws IOException { |
| return read(buffer, 0, buffer.length); |
| } |
| |
| /** |
| * Reads up to {@code byteCount} bytes from the current position in this file |
| * and stores them in the byte array {@code buffer} starting at {@code |
| * byteOffset}. Blocks until at least one byte has been |
| * read, the end of the file is detected, or an exception is thrown. |
| * Returns the number of bytes actually read or -1 if the end of the stream has been reached. |
| * See also {@link #readFully}. |
| * |
| * @throws IndexOutOfBoundsException |
| * if {@code byteOffset < 0 || byteCount < 0 || byteOffset + byteCount > buffer.length}. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public int read(byte[] buffer, int byteOffset, int byteCount) throws IOException { |
| return IoBridge.read(fd, buffer, byteOffset, byteCount); |
| } |
| |
| /** |
| * Reads a boolean from the current position in this file. Blocks until one |
| * byte has been read, the end of the file is reached or an exception is |
| * thrown. |
| * |
| * @return the next boolean value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeBoolean(boolean) |
| */ |
| public final boolean readBoolean() throws IOException { |
| int temp = this.read(); |
| if (temp < 0) { |
| throw new EOFException(); |
| } |
| return temp != 0; |
| } |
| |
| /** |
| * Reads an 8-bit byte from the current position in this file. Blocks until |
| * one byte has been read, the end of the file is reached or an exception is |
| * thrown. |
| * |
| * @return the next signed 8-bit byte value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeBoolean(boolean) |
| */ |
| public final byte readByte() throws IOException { |
| int temp = this.read(); |
| if (temp < 0) { |
| throw new EOFException(); |
| } |
| return (byte) temp; |
| } |
| |
| /** |
| * Reads a big-endian 16-bit character from the current position in this file. Blocks until |
| * two bytes have been read, the end of the file is reached or an exception is |
| * thrown. |
| * |
| * @return the next char value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeChar(int) |
| */ |
| public final char readChar() throws IOException { |
| return (char) readShort(); |
| } |
| |
| /** |
| * Reads a big-endian 64-bit double from the current position in this file. Blocks |
| * until eight bytes have been read, the end of the file is reached or an |
| * exception is thrown. |
| * |
| * @return the next double value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeDouble(double) |
| */ |
| public final double readDouble() throws IOException { |
| return Double.longBitsToDouble(readLong()); |
| } |
| |
| /** |
| * Reads a big-endian 32-bit float from the current position in this file. Blocks |
| * until four bytes have been read, the end of the file is reached or an |
| * exception is thrown. |
| * |
| * @return the next float value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeFloat(float) |
| */ |
| public final float readFloat() throws IOException { |
| return Float.intBitsToFloat(readInt()); |
| } |
| |
| /** |
| * Equivalent to {@code readFully(dst, 0, dst.length);}. |
| */ |
| public final void readFully(byte[] dst) throws IOException { |
| readFully(dst, 0, dst.length); |
| } |
| |
| /** |
| * Reads {@code byteCount} bytes from this stream and stores them in the byte |
| * array {@code dst} starting at {@code offset}. If {@code byteCount} is zero, then this |
| * method returns without reading any bytes. Otherwise, this method blocks until |
| * {@code byteCount} bytes have been read. If insufficient bytes are available, |
| * {@code EOFException} is thrown. If an I/O error occurs, {@code IOException} is |
| * thrown. When an exception is thrown, some bytes may have been consumed from the stream |
| * and written into the array. |
| * |
| * @param dst |
| * the byte array into which the data is read. |
| * @param offset |
| * the offset in {@code dst} at which to store the bytes. |
| * @param byteCount |
| * the number of bytes to read. |
| * @throws EOFException |
| * if the end of the source stream is reached before enough |
| * bytes have been read. |
| * @throws IndexOutOfBoundsException |
| * if {@code offset < 0} or {@code byteCount < 0}, or |
| * {@code offset + byteCount > dst.length}. |
| * @throws IOException |
| * if a problem occurs while reading from this stream. |
| * @throws NullPointerException |
| * if {@code dst} is null. |
| */ |
| public final void readFully(byte[] dst, int offset, int byteCount) throws IOException { |
| Arrays.checkOffsetAndCount(dst.length, offset, byteCount); |
| while (byteCount > 0) { |
| int result = read(dst, offset, byteCount); |
| if (result < 0) { |
| throw new EOFException(); |
| } |
| offset += result; |
| byteCount -= result; |
| } |
| } |
| |
| /** |
| * Reads a big-endian 32-bit integer from the current position in this file. Blocks |
| * until four bytes have been read, the end of the file is reached or an |
| * exception is thrown. |
| * |
| * @return the next int value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeInt(int) |
| */ |
| public final int readInt() throws IOException { |
| readFully(scratch, 0, SizeOf.INT); |
| return Memory.peekInt(scratch, 0, ByteOrder.BIG_ENDIAN); |
| } |
| |
| /** |
| * Reads a line of text form the current position in this file. A line is |
| * represented by zero or more characters followed by {@code '\n'}, {@code |
| * '\r'}, {@code "\r\n"} or the end of file marker. The string does not |
| * include the line terminating sequence. |
| * <p> |
| * Blocks until a line terminating sequence has been read, the end of the |
| * file is reached or an exception is thrown. |
| * |
| * @return the contents of the line or {@code null} if no characters have |
| * been read before the end of the file has been reached. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public final String readLine() throws IOException { |
| StringBuilder line = new StringBuilder(80); // Typical line length |
| boolean foundTerminator = false; |
| long unreadPosition = 0; |
| while (true) { |
| int nextByte = read(); |
| switch (nextByte) { |
| case -1: |
| return line.length() != 0 ? line.toString() : null; |
| case (byte) '\r': |
| if (foundTerminator) { |
| seek(unreadPosition); |
| return line.toString(); |
| } |
| foundTerminator = true; |
| /* Have to be able to peek ahead one byte */ |
| unreadPosition = getFilePointer(); |
| break; |
| case (byte) '\n': |
| return line.toString(); |
| default: |
| if (foundTerminator) { |
| seek(unreadPosition); |
| return line.toString(); |
| } |
| line.append((char) nextByte); |
| } |
| } |
| } |
| |
| /** |
| * Reads a big-endian 64-bit long from the current position in this file. Blocks until |
| * eight bytes have been read, the end of the file is reached or an |
| * exception is thrown. |
| * |
| * @return the next long value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeLong(long) |
| */ |
| public final long readLong() throws IOException { |
| readFully(scratch, 0, SizeOf.LONG); |
| return Memory.peekLong(scratch, 0, ByteOrder.BIG_ENDIAN); |
| } |
| |
| /** |
| * Reads a big-endian 16-bit short from the current position in this file. Blocks until |
| * two bytes have been read, the end of the file is reached or an exception |
| * is thrown. |
| * |
| * @return the next short value from this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeShort(int) |
| */ |
| public final short readShort() throws IOException { |
| readFully(scratch, 0, SizeOf.SHORT); |
| return Memory.peekShort(scratch, 0, ByteOrder.BIG_ENDIAN); |
| } |
| |
| /** |
| * Reads an unsigned 8-bit byte from the current position in this file and |
| * returns it as an integer. Blocks until one byte has been read, the end of |
| * the file is reached or an exception is thrown. |
| * |
| * @return the next unsigned byte value from this file as an int. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeByte(int) |
| */ |
| public final int readUnsignedByte() throws IOException { |
| int temp = this.read(); |
| if (temp < 0) { |
| throw new EOFException(); |
| } |
| return temp; |
| } |
| |
| /** |
| * Reads an unsigned big-endian 16-bit short from the current position in this file and |
| * returns it as an integer. Blocks until two bytes have been read, the end of |
| * the file is reached or an exception is thrown. |
| * |
| * @return the next unsigned short value from this file as an int. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #writeShort(int) |
| */ |
| public final int readUnsignedShort() throws IOException { |
| return ((int) readShort()) & 0xffff; |
| } |
| |
| /** |
| * Reads a string that is encoded in {@link DataInput modified UTF-8} from |
| * this file. The number of bytes that must be read for the complete string |
| * is determined by the first two bytes read from the file. Blocks until all |
| * required bytes have been read, the end of the file is reached or an |
| * exception is thrown. |
| * |
| * @return the next string encoded in {@link DataInput modified UTF-8} from |
| * this file. |
| * @throws EOFException |
| * if the end of this file is detected. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @throws UTFDataFormatException |
| * if the bytes read cannot be decoded into a character string. |
| * @see #writeUTF(String) |
| */ |
| public final String readUTF() throws IOException { |
| int utfSize = readUnsignedShort(); |
| if (utfSize == 0) { |
| return ""; |
| } |
| byte[] buf = new byte[utfSize]; |
| if (read(buf, 0, buf.length) != buf.length) { |
| throw new EOFException(); |
| } |
| return ModifiedUtf8.decode(buf, new char[utfSize], 0, utfSize); |
| } |
| |
| /** |
| * Moves this file's file pointer to a new position, from where following |
| * {@code read}, {@code write} or {@code skip} operations are done. The |
| * position may be greater than the current length of the file, but the |
| * file's length will only change if the moving of the pointer is followed |
| * by a {@code write} operation. |
| * |
| * @param offset |
| * the new file pointer position. |
| * @throws IOException |
| * if this file is closed, {@code pos < 0} or another I/O error |
| * occurs. |
| */ |
| public void seek(long offset) throws IOException { |
| if (offset < 0) { |
| throw new IOException("offset < 0: " + offset); |
| } |
| try { |
| Libcore.os.lseek(fd, offset, SEEK_SET); |
| } catch (ErrnoException errnoException) { |
| throw errnoException.rethrowAsIOException(); |
| } |
| } |
| |
| /** |
| * Sets the length of this file to {@code newLength}. If the current file is |
| * smaller, it is expanded but the contents from the previous end of the |
| * file to the new end are undefined. The file is truncated if its current |
| * size is bigger than {@code newLength}. If the current file pointer |
| * position is in the truncated part, it is set to the end of the file. |
| * |
| * @param newLength |
| * the new file length in bytes. |
| * @throws IllegalArgumentException |
| * if {@code newLength < 0}. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public void setLength(long newLength) throws IOException { |
| if (newLength < 0) { |
| throw new IllegalArgumentException("newLength < 0"); |
| } |
| try { |
| Libcore.os.ftruncate(fd, newLength); |
| } catch (ErrnoException errnoException) { |
| throw errnoException.rethrowAsIOException(); |
| } |
| |
| long filePointer = getFilePointer(); |
| if (filePointer > newLength) { |
| seek(newLength); |
| } |
| |
| } |
| |
| /** |
| * Skips over {@code count} bytes in this file. Less than {@code count} |
| * bytes are skipped if the end of the file is reached or an exception is |
| * thrown during the operation. Nothing is done if {@code count} is |
| * negative. |
| * |
| * @param count |
| * the number of bytes to skip. |
| * @return the number of bytes actually skipped. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| */ |
| public int skipBytes(int count) throws IOException { |
| if (count > 0) { |
| long currentPos = getFilePointer(), eof = length(); |
| int newCount = (int) ((currentPos + count > eof) ? eof - currentPos : count); |
| seek(currentPos + newCount); |
| return newCount; |
| } |
| return 0; |
| } |
| |
| /** |
| * Writes the entire contents of the byte array {@code buffer} to this file, |
| * starting at the current file pointer. |
| * |
| * @param buffer |
| * the buffer to write. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| */ |
| public void write(byte[] buffer) throws IOException { |
| write(buffer, 0, buffer.length); |
| } |
| |
| /** |
| * Writes {@code byteCount} bytes from the byte array {@code buffer} to this |
| * file, starting at the current file pointer and using {@code byteOffset} as |
| * the first position within {@code buffer} to get bytes. |
| * |
| * @throws IndexOutOfBoundsException |
| * if {@code byteCount < 0}, {@code byteOffset < 0} or {@code byteCount + |
| * byteOffset} is greater than the size of {@code buffer}. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| */ |
| public void write(byte[] buffer, int byteOffset, int byteCount) throws IOException { |
| IoBridge.write(fd, buffer, byteOffset, byteCount); |
| } |
| |
| /** |
| * Writes a byte to this file, starting at the current file pointer. Only |
| * the least significant byte of the integer {@code oneByte} is written. |
| * |
| * @param oneByte |
| * the byte to write to this file. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #read() |
| */ |
| public void write(int oneByte) throws IOException { |
| scratch[0] = (byte) (oneByte & 0xff); |
| write(scratch, 0, 1); |
| } |
| |
| /** |
| * Writes a boolean to this file as a single byte (1 for true, 0 for false), starting at the |
| * current file pointer. |
| * |
| * @param val |
| * the boolean to write to this file. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #readBoolean() |
| */ |
| public final void writeBoolean(boolean val) throws IOException { |
| write(val ? 1 : 0); |
| } |
| |
| /** |
| * Writes an 8-bit byte to this file, starting at the current file pointer. |
| * Only the least significant byte of the integer {@code val} is written. |
| * |
| * @param val |
| * the byte to write to this file. |
| * @throws IOException |
| * if this file is closed or another I/O error occurs. |
| * @see #readByte() |
| * @see #readUnsignedByte() |
| */ |
| public final void writeByte(int val) throws IOException { |
| write(val & 0xFF); |
| } |
| |
| /** |
| * Writes the low order 8-bit bytes from a string to this file, starting at |
| * the current file pointer. |
| * |
| * @param str |
| * the string containing the bytes to write to this file |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| */ |
| public final void writeBytes(String str) throws IOException { |
| byte[] bytes = new byte[str.length()]; |
| for (int index = 0; index < str.length(); index++) { |
| bytes[index] = (byte) (str.charAt(index) & 0xFF); |
| } |
| write(bytes); |
| } |
| |
| /** |
| * Writes a big-endian 16-bit character to this file, starting at the current file |
| * pointer. Only the two least significant bytes of the integer {@code val} |
| * are written, with the high byte first. |
| * |
| * @param val |
| * the char to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readChar() |
| */ |
| public final void writeChar(int val) throws IOException { |
| writeShort(val); |
| } |
| |
| /** |
| * Writes big-endian 16-bit characters from {@code str} to this file, starting at the |
| * current file pointer. |
| * |
| * @param str |
| * the string to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readChar() |
| */ |
| public final void writeChars(String str) throws IOException { |
| write(str.getBytes("UTF-16BE")); |
| } |
| |
| /** |
| * Writes a big-endian 64-bit double to this file, starting at the current file |
| * pointer. The bytes are those returned by |
| * {@link Double#doubleToLongBits(double)}, meaning a canonical NaN is used. |
| * |
| * @param val |
| * the double to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readDouble() |
| */ |
| public final void writeDouble(double val) throws IOException { |
| writeLong(Double.doubleToLongBits(val)); |
| } |
| |
| /** |
| * Writes a big-endian 32-bit float to this file, starting at the current file pointer. |
| * The bytes are those returned by {@link Float#floatToIntBits(float)}, meaning a canonical NaN |
| * is used. |
| * |
| * @param val |
| * the float to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readFloat() |
| */ |
| public final void writeFloat(float val) throws IOException { |
| writeInt(Float.floatToIntBits(val)); |
| } |
| |
| /** |
| * Writes a big-endian 32-bit integer to this file, starting at the current file |
| * pointer. |
| * |
| * @param val |
| * the int to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readInt() |
| */ |
| public final void writeInt(int val) throws IOException { |
| Memory.pokeInt(scratch, 0, val, ByteOrder.BIG_ENDIAN); |
| write(scratch, 0, SizeOf.INT); |
| } |
| |
| /** |
| * Writes a big-endian 64-bit long to this file, starting at the current file |
| * pointer. |
| * |
| * @param val |
| * the long to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readLong() |
| */ |
| public final void writeLong(long val) throws IOException { |
| Memory.pokeLong(scratch, 0, val, ByteOrder.BIG_ENDIAN); |
| write(scratch, 0, SizeOf.LONG); |
| } |
| |
| /** |
| * Writes a big-endian 16-bit short to this file, starting at the current file |
| * pointer. Only the two least significant bytes of the integer {@code val} |
| * are written. |
| * |
| * @param val |
| * the short to write to this file. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @see #readShort() |
| * @see DataInput#readUnsignedShort() |
| */ |
| public final void writeShort(int val) throws IOException { |
| Memory.pokeShort(scratch, 0, (short) val, ByteOrder.BIG_ENDIAN); |
| write(scratch, 0, SizeOf.SHORT); |
| } |
| |
| /** |
| * Writes a string encoded with {@link DataInput modified UTF-8} to this |
| * file, starting at the current file pointer. |
| * |
| * @param str |
| * the string to write in {@link DataInput modified UTF-8} |
| * format. |
| * @throws IOException |
| * if an I/O error occurs while writing to this file. |
| * @throws UTFDataFormatException |
| * if the encoded string is longer than 65535 bytes. |
| * @see #readUTF() |
| */ |
| public final void writeUTF(String str) throws IOException { |
| write(ModifiedUtf8.encode(str)); |
| } |
| } |
