/**@class java.io.RandomAccessFile
 implements java.io.DataOutput

 implements java.io.DataInput

 implements java.io.Closeable

@extends java.lang.Object

 Instances of this class support both reading and writing to a
 random access file. A random access file behaves like a large
 array of bytes stored in the file system. There is a kind of cursor,
 or index into the implied array, called the <em>file pointer</em>;
 input operations read bytes starting at the file pointer and advance
 the file pointer past the bytes read. If the random access file is
 created in read/write mode, then output operations are also available;
 output operations write bytes starting at the file pointer and advance
 the file pointer past the bytes written. Output operations that write
 past the current end of the implied array cause the array to be
 extended. The file pointer can be read by the
 {@code getFilePointer} method and set by the {@code seek}
 method.
 <p>
 It is generally true of all the reading routines in this class that
 if end-of-file is reached before the desired number of bytes has been
 read, an {@code EOFException} (which is a kind of
 {@code IOException}) is thrown. If any byte cannot be read for
 any reason other than end-of-file, an {@code IOException} other
 than {@code EOFException} is thrown. In particular, an
 {@code IOException} may be thrown if the stream has been closed.

 @author  unascribed
 @since   JDK1.0
*/
var RandomAccessFile = {

/**Returns the opaque file descriptor object associated with this
 stream.
@return {Object {java.io.FileDescriptor}} the file descriptor object associated with this stream.
@exception IOException  if an I/O error occurs.
@see java.io.FileDescriptor
*/
getFD : function(  ) {},

/**Returns the unique {@link java.nio.channels.java.io.FileChannel java.io.FileChannel}
 object associated with this file.

 <p> The {@link java.nio.channels.FileChannel#position()
 position} of the returned channel will always be equal to
 this object's file-pointer offset as returned by the {@link #getFilePointer getFilePointer} method.  Changing this object's
 file-pointer offset, whether explicitly or by reading or writing bytes,
 will change the position of the channel, and vice versa.  Changing the
 file's length via this object will change the length seen via the file
 channel, and vice versa.
@return {Object {java.nio.channels.FileChannel}} the file channel associated with this file
@since 1.4
@spec JSR-51
*/
getChannel : function(  ) {},

/**Reads a byte of data from this file. The byte is returned as an
 integer in the range 0 to 255 ({@code 0x00-0x0ff}). This
 method blocks if no input is yet available.
 <p>
 Although {@code RandomAccessFile} is not a subclass of
 {@code InputStream}, this method behaves in exactly the same
 way as the {@link java.io.InputStream#read()} method of
 {@code InputStream}.
@return {Number} the next byte of data, or {@code -1} if the end of the
             file has been reached.
@exception IOException  if an I/O error occurs. Not thrown if
                          end-of-file has been reached.
*/
read : function(  ) {},

/**Reads up to {@code len} bytes of data from this file into an
 array of bytes. This method blocks until at least one byte of input
 is available.
 <p>
 Although {@code RandomAccessFile} is not a subclass of
 {@code InputStream}, this method behaves in exactly the
 same way as the {@link java.io.InputStream#read(byte[], int, int)} method of
 {@code InputStream}.
@param {Object {byte[]}} b     the buffer into which the data is read.
@param {Number} off   the start offset in array {@code b}
                   at which the data is written.
@param {Number} len   the maximum number of bytes read.
@return {Number} the total number of bytes read into the buffer, or
             {@code -1} if there is no more data because the end of
             the file has been reached.
@exception IOException If the first byte cannot be read for any reason
 other than end of file, or if the random access file has been closed, or if
 some other I/O error occurs.
@exception NullPointerException If {@code b} is {@code null}.
@exception IndexOutOfBoundsException If {@code off} is negative,
 {@code len} is negative, or {@code len} is greater than
 {@code b.length - off}
*/
read : function(  ) {},

/**Reads up to {@code b.length} bytes of data from this file
 into an array of bytes. This method blocks until at least one byte
 of input is available.
 <p>
 Although {@code RandomAccessFile} is not a subclass of
 {@code InputStream}, this method behaves in exactly the
 same way as the {@link java.io.InputStream#read(byte[])} method of
 {@code InputStream}.
@param {Object {byte[]}} b   the buffer into which the data is read.
@return {Number} the total number of bytes read into the buffer, or
             {@code -1} if there is no more data because the end of
             this file has been reached.
@exception IOException If the first byte cannot be read for any reason
 other than end of file, or if the random access file has been closed, or if
 some other I/O error occurs.
@exception NullPointerException If {@code b} is {@code null}.
*/
read : function(  ) {},

/**Reads {@code b.length} bytes from this file into the byte
 array, starting at the current file pointer. This method reads
 repeatedly from the file 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 {Object {byte[]}} b   the buffer into which the data is read.
@exception EOFException  if this file reaches the end before reading
               all the bytes.
@exception IOException   if an I/O error occurs.
*/
readFully : function(  ) {},

/**Reads exactly {@code len} bytes from this file into the byte
 array, starting at the current file pointer. This method reads
 repeatedly from the file 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 {Object {byte[]}} b     the buffer into which the data is read.
@param {Number} off   the start offset of the data.
@param {Number} len   the number of bytes to read.
@exception EOFException  if this file reaches the end before reading
               all the bytes.
@exception IOException   if an I/O error occurs.
*/
readFully : function(  ) {},

/**Attempts to skip over {@code n} bytes of input discarding the
 skipped bytes.
 <p>

 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
 file before {@code n} bytes have been skipped is only one
 possibility. This method never throws an {@code EOFException}.
 The actual number of bytes skipped is returned.  If {@code n}
 is negative, no bytes are skipped.
@param {Number} n   the number of bytes to be skipped.
@return {Number} the actual number of bytes skipped.
@exception IOException  if an I/O error occurs.
*/
skipBytes : function(  ) {},

/**Writes the specified byte to this file. The write starts at
 the current file pointer.
@param {Number} b   the {@code byte} to be written.
@exception IOException  if an I/O error occurs.
*/
write : function(  ) {},

/**Writes {@code b.length} bytes from the specified byte array
 to this file, starting at the current file pointer.
@param {Object {byte[]}} b   the data.
@exception IOException  if an I/O error occurs.
*/
write : function(  ) {},

/**Writes {@code len} bytes from the specified byte array
 starting at offset {@code off} to this file.
@param {Object {byte[]}} b     the data.
@param {Number} off   the start offset in the data.
@param {Number} len   the number of bytes to write.
@exception IOException  if an I/O error occurs.
*/
write : function(  ) {},

/**Returns the current offset in this file.
@return {Number} the offset from the beginning of the file, in bytes,
             at which the next read or write occurs.
@exception IOException  if an I/O error occurs.
*/
getFilePointer : function(  ) {},

/**Sets the file-pointer offset, measured from the beginning of this
 file, at which the next read or write occurs.  The offset may be
 set beyond the end of the file. Setting the offset beyond the end
 of the file does not change the file length.  The file length will
 change only by writing after the offset has been set beyond the end
 of the file.
@param {Number} pos   the offset position, measured in bytes from the
                   beginning of the file, at which to set the file
                   pointer.
@exception IOException  if {@code pos} is less than
                          {@code 0} or if an I/O error occurs.
*/
seek : function(  ) {},

/**Returns the length of this file.
@return {Number} the length of this file, measured in bytes.
@exception IOException  if an I/O error occurs.
*/
length : function(  ) {},

/**Sets the length of this file.

 <p> If the present length of the file as returned by the
 {@code length} method is greater than the {@code newLength}
 argument then the file will be truncated.  In this case, if the file
 offset as returned by the {@code getFilePointer} method is greater
 than {@code newLength} then after this method returns the offset
 will be equal to {@code newLength}.

 <p> If the present length of the file as returned by the
 {@code length} method is smaller than the {@code newLength}
 argument then the file will be extended.  In this case, the contents of
 the extended portion of the file are not defined.
@param {Number} newLength    The desired length of the file
@exception IOException  If an I/O error occurs
@since 1.2
*/
setLength : function(  ) {},

/**Closes this random access file stream and releases any system
 resources associated with the stream. A closed random access
 file cannot perform input or output operations and cannot be
 reopened.

 <p> If this file has an associated channel then the channel is closed
 as well.
@exception IOException  if an I/O error occurs.
@revised 1.4
@spec JSR-51
*/
close : function(  ) {},

/**Reads a {@code boolean} from this file. This method reads a
 single byte from the file, starting at the current file pointer.
 A value of {@code 0} represents
 {@code false}. Any other value represents {@code true}.
 This method blocks until the byte is read, the end of the stream
 is detected, or an exception is thrown.
@return {Boolean} the {@code boolean} value read.
@exception EOFException  if this file has reached the end.
@exception IOException   if an I/O error occurs.
*/
readBoolean : function(  ) {},

/**Reads a signed eight-bit value from this file. This method reads a
 byte from the file, starting from the current file pointer.
 If the byte read is {@code b}, where
 <code>0&nbsp;&lt;=&nbsp;b&nbsp;&lt;=&nbsp;255</code>,
 then the result is:
 <blockquote><pre>
     (byte)(b)
 </pre></blockquote>
 <p>
 This method blocks until the byte is read, the end of the stream
 is detected, or an exception is thrown.
@return {Number} the next byte of this file as a signed eight-bit
             {@code byte}.
@exception EOFException  if this file has reached the end.
@exception IOException   if an I/O error occurs.
*/
readByte : function(  ) {},

/**Reads an unsigned eight-bit number from this file. This method reads
 a byte from this file, starting at the current file pointer,
 and returns that byte.
 <p>
 This method blocks until the byte is read, the end of the stream
 is detected, or an exception is thrown.
@return {Number} the next byte of this file, interpreted as an unsigned
             eight-bit number.
@exception EOFException  if this file has reached the end.
@exception IOException   if an I/O error occurs.
*/
readUnsignedByte : function(  ) {},

/**Reads a signed 16-bit number from this file. The method reads two
 bytes from this file, starting at the current file pointer.
 If the two bytes read, in order, are
 {@code b1} and {@code b2}, where each of the two values is
 between {@code 0} and {@code 255}, inclusive, then the
 result is equal to:
 <blockquote><pre>
     (short)((b1 &lt;&lt; 8) | b2)
 </pre></blockquote>
 <p>
 This method blocks until the two bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next two bytes of this file, interpreted as a signed
             16-bit number.
@exception EOFException  if this file reaches the end before reading
               two bytes.
@exception IOException   if an I/O error occurs.
*/
readShort : function(  ) {},

/**Reads an unsigned 16-bit number from this file. This method reads
 two bytes from the file, starting at the current file pointer.
 If the bytes read, in order, are
 {@code b1} and {@code b2}, where
 <code>0&nbsp;&lt;=&nbsp;b1, b2&nbsp;&lt;=&nbsp;255</code>,
 then the result is equal to:
 <blockquote><pre>
     (b1 &lt;&lt; 8) | b2
 </pre></blockquote>
 <p>
 This method blocks until the two bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next two bytes of this file, interpreted as an unsigned
             16-bit integer.
@exception EOFException  if this file reaches the end before reading
               two bytes.
@exception IOException   if an I/O error occurs.
*/
readUnsignedShort : function(  ) {},

/**Reads a character from this file. This method reads two
 bytes from the file, starting at the current file pointer.
 If the bytes read, in order, are
 {@code b1} and {@code b2}, where
 <code>0&nbsp;&lt;=&nbsp;b1,&nbsp;b2&nbsp;&lt;=&nbsp;255</code>,
 then the result is equal to:
 <blockquote><pre>
     (char)((b1 &lt;&lt; 8) | b2)
 </pre></blockquote>
 <p>
 This method blocks until the two bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {String} the next two bytes of this file, interpreted as a
                  {@code char}.
@exception EOFException  if this file reaches the end before reading
               two bytes.
@exception IOException   if an I/O error occurs.
*/
readChar : function(  ) {},

/**Reads a signed 32-bit integer from this file. This method reads 4
 bytes from the file, starting at the current file pointer.
 If the bytes read, in order, are {@code b1},
 {@code b2}, {@code b3}, and {@code b4}, where
 <code>0&nbsp;&lt;=&nbsp;b1, b2, b3, b4&nbsp;&lt;=&nbsp;255</code>,
 then the result is equal to:
 <blockquote><pre>
     (b1 &lt;&lt; 24) | (b2 &lt;&lt; 16) + (b3 &lt;&lt; 8) + b4
 </pre></blockquote>
 <p>
 This method blocks until the four bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next four bytes of this file, interpreted as an
             {@code int}.
@exception EOFException  if this file reaches the end before reading
               four bytes.
@exception IOException   if an I/O error occurs.
*/
readInt : function(  ) {},

/**Reads a signed 64-bit integer from this file. This method reads eight
 bytes from the file, starting at the current file pointer.
 If the bytes read, in order, are
 {@code b1}, {@code b2}, {@code b3},
 {@code b4}, {@code b5}, {@code b6},
 {@code b7}, and {@code b8,} where:
 <blockquote><pre>
     0 &lt;= b1, b2, b3, b4, b5, b6, b7, b8 &lt;=255,
 </pre></blockquote>
 <p>
 then the result is equal to:
 <blockquote><pre>
     ((long)b1 &lt;&lt; 56) + ((long)b2 &lt;&lt; 48)
     + ((long)b3 &lt;&lt; 40) + ((long)b4 &lt;&lt; 32)
     + ((long)b5 &lt;&lt; 24) + ((long)b6 &lt;&lt; 16)
     + ((long)b7 &lt;&lt; 8) + b8
 </pre></blockquote>
 <p>
 This method blocks until the eight bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next eight bytes of this file, interpreted as a
             {@code long}.
@exception EOFException  if this file reaches the end before reading
               eight bytes.
@exception IOException   if an I/O error occurs.
*/
readLong : function(  ) {},

/**Reads a {@code float} from this file. This method reads an
 {@code int} value, starting at the current file pointer,
 as if by the {@code readInt} method
 and then converts that {@code int} to a {@code float}
 using the {@code intBitsToFloat} method in class
 {@code Float}.
 <p>
 This method blocks until the four bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next four bytes of this file, interpreted as a
             {@code float}.
@exception EOFException  if this file reaches the end before reading
             four bytes.
@exception IOException   if an I/O error occurs.
@see java.io.RandomAccessFile#readInt()
@see java.lang.Float#intBitsToFloat(int)
*/
readFloat : function(  ) {},

/**Reads a {@code double} from this file. This method reads a
 {@code long} value, starting at the current file pointer,
 as if by the {@code readLong} method
 and then converts that {@code long} to a {@code double}
 using the {@code longBitsToDouble} method in
 class {@code Double}.
 <p>
 This method blocks until the eight bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {Number} the next eight bytes of this file, interpreted as a
             {@code double}.
@exception EOFException  if this file reaches the end before reading
             eight bytes.
@exception IOException   if an I/O error occurs.
@see java.io.RandomAccessFile#readLong()
@see java.lang.Double#longBitsToDouble(long)
*/
readDouble : function(  ) {},

/**Reads the next line of text from this file.  This method successively
 reads bytes from the file, starting at the current file pointer,
 until it reaches a line terminator or the end
 of the file.  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.

 <p> A line of text is terminated by a carriage-return character
 ({@code '\r'}), a newline character ({@code '\n'}), a
 carriage-return character immediately followed by a newline character,
 or the end of the file.  Line-terminating characters are discarded and
 are not included as part of the string returned.

 <p> 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 file is reached, or an exception is thrown.
@return {String} the next line of text from this file, or null if end
             of file is encountered before even one byte is read.
@exception IOException  if an I/O error occurs.
*/
readLine : function(  ) {},

/**Reads in a string from this file. The string has been encoded
 using a
 <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
 format.
 <p>
 The first two bytes are read, starting from the current file
 pointer, as if by
 {@code 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 modified UTF-8 format
 and are converted into characters.
 <p>
 This method blocks until all the bytes are read, the end of the
 stream is detected, or an exception is thrown.
@return {String} a Unicode string.
@exception EOFException            if this file reaches the end before
               reading all the bytes.
@exception IOException             if an I/O error occurs.
@exception UTFDataFormatException  if the bytes do not represent
               valid modified UTF-8 encoding of a Unicode string.
@see java.io.RandomAccessFile#readUnsignedShort()
*/
readUTF : function(  ) {},

/**Writes a {@code boolean} to the file as a one-byte value. The
 value {@code true} is written out as the value
 {@code (byte)1}; the value {@code false} is written out
 as the value {@code (byte)0}. The write starts at
 the current position of the file pointer.
@param {Boolean} v   a {@code boolean} value to be written.
@exception IOException  if an I/O error occurs.
*/
writeBoolean : function(  ) {},

/**Writes a {@code byte} to the file as a one-byte value. The
 write starts at the current position of the file pointer.
@param {Number} v   a {@code byte} value to be written.
@exception IOException  if an I/O error occurs.
*/
writeByte : function(  ) {},

/**Writes a {@code short} to the file as two bytes, high byte first.
 The write starts at the current position of the file pointer.
@param {Number} v   a {@code short} to be written.
@exception IOException  if an I/O error occurs.
*/
writeShort : function(  ) {},

/**Writes a {@code char} to the file as a two-byte value, high
 byte first. The write starts at the current position of the
 file pointer.
@param {Number} v   a {@code char} value to be written.
@exception IOException  if an I/O error occurs.
*/
writeChar : function(  ) {},

/**Writes an {@code int} to the file as four bytes, high byte first.
 The write starts at the current position of the file pointer.
@param {Number} v   an {@code int} to be written.
@exception IOException  if an I/O error occurs.
*/
writeInt : function(  ) {},

/**Writes a {@code long} to the file as eight bytes, high byte first.
 The write starts at the current position of the file pointer.
@param {Number} v   a {@code long} to be written.
@exception IOException  if an I/O error occurs.
*/
writeLong : function(  ) {},

/**Converts the float argument to an {@code int} using the
 {@code floatToIntBits} method in class {@code Float},
 and then writes that {@code int} value to the file as a
 four-byte quantity, high byte first. The write starts at the
 current position of the file pointer.
@param {Number} v   a {@code float} value to be written.
@exception IOException  if an I/O error occurs.
@see java.lang.Float#floatToIntBits(float)
*/
writeFloat : function(  ) {},

/**Converts the double argument to a {@code long} using the
 {@code doubleToLongBits} method in class {@code Double},
 and then writes that {@code long} value to the file as an
 eight-byte quantity, high byte first. The write starts at the current
 position of the file pointer.
@param {Number} v   a {@code double} value to be written.
@exception IOException  if an I/O error occurs.
@see java.lang.Double#doubleToLongBits(double)
*/
writeDouble : function(  ) {},

/**Writes the string to the file as a sequence of bytes. Each
 character in the string is written out, in sequence, by discarding
 its high eight bits. The write starts at the current position of
 the file pointer.
@param {String} s   a string of bytes to be written.
@exception IOException  if an I/O error occurs.
*/
writeBytes : function(  ) {},

/**Writes a string to the file as a sequence of characters. Each
 character is written to the data output stream as if by the
 {@code writeChar} method. The write starts at the current
 position of the file pointer.
@param {String} s   a {@code String} value to be written.
@exception IOException  if an I/O error occurs.
@see java.io.RandomAccessFile#writeChar(int)
*/
writeChars : function(  ) {},

/**Writes a string to the file using
 <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
 encoding in a machine-independent manner.
 <p>
 First, two bytes are written to the file, starting at the
 current file pointer, as if by the
 {@code writeShort} method giving the number of bytes to
 follow. This value is the number of bytes actually written out,
 not the length of the string. Following the length, each character
 of the string is output, in sequence, using the modified UTF-8 encoding
 for each character.
@param {String} str   a string to be written.
@exception IOException  if an I/O error occurs.
*/
writeUTF : function(  ) {},


};