randomaccessfile.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 1,012 行 · 第 1/3 页

	  * @exception EOFException If end of file is reached before reading the String
	  * @exception UTFDataFormatException If the data is not in UTF-8 format
	  * @exception IOException If any other error occurs
	  *
	  * @see DataOutput
	  */
	public synchronized final String readUTF()
		throws EOFException, UTFDataFormatException, IOException {
		StringBuffer sb = new StringBuffer("");

		int num_bytes = readUnsignedShort();
		byte[] buf = new byte[num_bytes];
		readFully(buf);

		return (DataInputStream.convertFromUTF(buf));
	}

	/**
	  * This method reads raw bytes into the passed array until the array is
	  * full.  Note that this method blocks until the data is available and
	  * throws an exception if there is not enough data left in the stream to
	  * fill the buffer
	  *
	  * @param buf The buffer into which to read the data
	  *
	  * @exception EOFException If end of file is reached before filling the buffer
	  * @exception IOException If any other error occurs
	  */
	public final void readFully(byte[] buf) throws EOFException, IOException {
		readFully(buf, 0, buf.length);
	}

	/**
	  * This method reads raw bytes into the passed array <code>buf</code> starting
	  * <code>offset</code> bytes into the buffer.  The number of bytes read will be
	  * exactly <code>len</code>  Note that this method blocks until the data is 
	  * available and * throws an exception if there is not enough data left in 
	  * the stream to read <code>len</code> bytes.
	  *
	  * @param buf The buffer into which to read the data
	  * @param offset The offset into the buffer to start storing data
	  * @param len The number of bytes to read into the buffer
	  *
	  * @exception EOFException If end of file is reached before filling the buffer
	  * @exception IOException If any other error occurs
	  */
	public synchronized final void readFully(byte[] buf, int offset, int len)
		throws EOFException, IOException {
		int total_read = 0;

		while (total_read < len) {
			int bytes_read = read(buf, offset + total_read, len - total_read);
			if (bytes_read == -1)
				throw new EOFException("Unexpected end of stream");

			total_read += bytes_read;
		}
	}

	/**
	  * This method attempts to skip and discard the specified number of bytes 
	  * in the input stream.  It may actually skip fewer bytes than requested. 
	  * The actual number of bytes skipped is returned.  This method will not
	  * skip any bytes if passed a negative number of bytes to skip.
	  *
	  * @param num_bytes The requested number of bytes to skip.
	  *
	  * @return The number of bytes actually skipped.
	  *
	  * @exception IOException If an error occurs.
	  */
	public int skipBytes(int n) throws EOFException, IOException {
		if (n <= 0) {
			return 0;
		}

		final long file_length = this.length();
		final long file_position = this.getFilePointer();
		final int skip_length = (int)Math.min(n, file_length - file_position);
		fh.setPosition(file_position + skip_length);

		return skip_length;
	}

	/**
	  * This method writes a single byte of data to the file. The file must
	  * be open for read-write in order for this operation to succeed.
	  *
	  * @param The byte of data to write, passed as an int.
	  *
	  * @exception IOException If an error occurs
	  */
	public void write(int b) throws IOException {
		if (read_only) {
			throw new IOException("File is open read only");
		}

		final byte[] buf = new byte[1];
		buf[0] = (byte)b;

		fh.write(buf, 0, buf.length);
	}

	/**
	  * This method writes all the bytes in the specified array to the file.
	  * The file must be open read-write in order for this operation to succeed.
	  *
	  * @param buf The array of bytes to write to the file
	  */
	public void write(byte[] buf) throws IOException {
		if (read_only) {
			throw new IOException("File is open read only");
		}

		fh.write(buf, 0, buf.length);
	}

	/**
	  * This method writes <code>len</code> bytes to the file from the specified
	  * array starting at index <code>offset</code> into the array.
	  *
	  * @param buf The array of bytes to write to the file
	  * @param offset The index into the array to start writing file
	  * @param len The number of bytes to write
	  *
	  * @exception IOException If an error occurs
	  */
	public void write(byte[] buf, int offset, int len) throws IOException {
		if (read_only) {
			throw new IOException("File is open read only");
		}

		fh.write(buf, offset, len);
	}

	/**
	  * This method writes a Java <code>boolean</code> to the underlying output 
	  * stream. For a value of <code>true</code>, 1 is written to the stream.
	  * For a value of <code>false</code>, 0 is written.
	  *
	  * @param b The <code>boolean</code> value to write to the stream
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeBoolean(boolean b) throws IOException {
		int bool = DataOutputStream.convertFromBoolean(b);
		write(bool);
	}

	/**
	  * This method writes a Java <code>byte</code> value to the underlying
	  * output stream.
	  *
	  * @param b The <code>byte</code> to write to the stream, passed as an <code>int</code>.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeByte(int b) throws IOException {
		write(b);
	}

	/**
	  * This method writes all the bytes in a <code>String</code> out to the
	  * stream.  One byte is written for each character in the <code>String</code>.
	  * The high eight bits of each character are discarded.
	  *
	  * @param s The <code>String</code> to write to the stream
	  *
	  * @exception IOException If an error occurs
	  */
	public synchronized final void writeBytes(String s) throws IOException {
		if (s.length() == 0)
			return;

		byte[] buf = new byte[s.length()];

		for (int i = 0; i < s.length(); i++)
			buf[i] = (byte) (s.charAt(i) & 0xFF);

		write(buf);
	}

	/**
	  * This method writes a single <code>char</code> value to the stream,
	  * high byte first.
	  *
	  * @param c The <code>char</code> value to write, passed as an <code>int</code>.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeChar(int c) throws IOException {
		write(DataOutputStream.convertFromChar(c));
	}

	/**
	  * This method writes all the characters in a <code>String</code> to the
	  * stream.  There will be two bytes for each character value.  The high
	  * byte of the character will be written first.
	  *
	  * @param s The <code>String</code> to write to the stream.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeChars(String s) throws IOException {
		if (s.length() == 0)
			return;

		byte[] buf = DataOutputStream.getConvertedStringChars(s);
		write(buf);
	}

	/**
	  * This method writes a Java <code>short</code> to the stream, high byte
	  * first.  This method requires two bytes to encode the value.
	  *
	  * @param s The <code>short</code> value to write to the stream, passed as an <code>int</code>.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeShort(int s) throws IOException {
		write(DataOutputStream.convertFromShort(s));
	}

	/**
	  * This method writes a Java <code>int</code> to the stream, high bytes
	  * first.  This method requires four bytes to encode the value.
	  *
	  * @param i The <code>int</code> value to write to the stream.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeInt(int i) throws IOException {
		write(DataOutputStream.convertFromInt(i));
	}

	/**
	  * This method writes a Java <code>long</code> to the stream, high bytes
	  * first.  This method requires eight bytes to encode the value.
	  *
	  * @param l The <code>long</code> value to write to the stream.
	  *
	  * @exception IOException If an error occurs
	  */
	public final void writeLong(long l) throws IOException {
		write(DataOutputStream.convertFromLong(l));
	}

	/**
	  * This method writes a Java <code>float</code> value to the stream.  This
	  * value is written by first calling the method <code>Float.floatToIntBits</code>
	  * to retrieve an <code>int</code> representing the floating point number,
	  * then writing this <code>int</code> value to the stream exactly the same
	  * as the <code>writeInt()</code> method does.
	  *
	  * @param f The floating point number to write to the stream.
	  *
	  * @exception IOException If an error occurs
	  *
	  * @see writeInt
	  */
	public final void writeFloat(float f) throws IOException {
		int i = Float.floatToIntBits(f);
		writeInt(i);
	}

	/**
	  * This method writes a Java <code>double</code> value to the stream.  This
	  * value is written by first calling the method <code>Double.doubleToLongBits</code>
	  * to retrieve an <code>long</code> representing the floating point number,
	  * then writing this <code>long</code> value to the stream exactly the same
	  * as the <code>writeLong()</code> method does.
	  *
	  * @param d The double precision floating point number to write to the stream.
	  *
	  * @exception IOException If an error occurs
	  *
	  * @see writeLong
	  */
	public final void writeDouble(double d) throws IOException {
		long l = Double.doubleToLongBits(d);
		writeLong(l);
	}

	/**
	  * This method writes a Java <code>String</code> to the stream in a modified
	  * UTF-8 format.  First, two bytes are written to the stream indicating the
	  * number of bytes to follow.  Note that this is the number of bytes in the
	  * encoded <code>String</code> not the <code>String</code> length.  Next
	  * come the encoded characters.  Each character in the <code>String</code>
	  * is encoded as either one, two or three bytes.  For characters in the
	  * range of <code>&#92;u0001</code> to <code>&#92;u007F</code>, one byte is used.  The character
	  * value goes into bits 0-7 and bit eight is 0.  For characters in the range
	  * of <code>&#92;u0080</code> to <code>&#92;u007FF</code>, two bytes are used.  Bits
	  * 6-10 of the character value are encoded bits 0-4 of the first byte, with
	  * the high bytes having a value of "110".  Bits 0-5 of the character value
	  * are stored in bits 0-5 of the second byte, with the high bits set to
	  * "10".  This type of encoding is also done for the null character
	  * <code>&#92;u0000</code>.  This eliminates any C style NUL character values
	  * in the output.  All remaining characters are stored as three bytes.
	  * Bits 12-15 of the character value are stored in bits 0-3 of the first
	  * byte.  The high bits of the first bytes are set to "1110".  Bits 6-11
	  * of the character value are stored in bits 0-5 of the second byte.  The
	  * high bits of the second byte are set to "10".  And bits 0-5 of the
	  * character value are stored in bits 0-5 of byte three, with the high bits
	  * of that byte set to "10".
	  *
	  * @param s The <code>String</code> to write to the output in UTF format
	  *
	  * @exception IOException If an error occurs
	  */
	public synchronized final void writeUTF(String s) throws IOException {
		byte[] buf = DataOutputStream.convertToUTF(s);

		writeShort(buf.length);
		write(buf);
	}

	/**
	 *  This method creates a java.nio.channels.FileChannel.
	 * Nio does not allow one to create a file channel directly.
	 * A file channel must be created by first creating an instance of
	 * Input/Output/RandomAccessFile and invoking the getChannel() method on it.
	 */

	private FileChannel ch; /* cached associated file-channel */

	public FileChannel getChannel() {
		throw new RuntimeException("Not implemented yet");
		/*synchronized (this) {
			if (ch == null)
				ch = new gnu.java.nio.FileChannelImpl(native_fd, this);
		}
		return ch;*/
	}
}