home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / java / io / randomaccessfile.java < prev    next >
Text File  |  1995-08-11  |  9KB  |  375 lines
  1. /*
  2.  * @(#)RandomAccessFile.java    1.9 95/01/31 David Brown
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. import java.io.File;
  23.  
  24. /*
  25.  * Random Access File.  Read-only or read-write modes.
  26.  * Can be constructed from a file descriptor, file name, or File object.
  27.  * This needs much more thought...
  28.  */
  29. public
  30. class RandomAccessFile {
  31.     int fd;
  32.  
  33.     /**
  34.      * Create a RandomAccessFile given a file name.
  35.      * Mode is "r" for read-only, "rw" for read+write.
  36.      * May throw IOException. The file name is 
  37.      * very system dependent!
  38.      */
  39.     public RandomAccessFile(String name, String mode) {
  40.     this(open(name, mode.equals("rw")));
  41.     }
  42.     
  43.     /**
  44.      * Create a RandomAccessFile given a file descriptor.
  45.      * May throw IOException. The use of file descriptor 
  46.      * is very system dependent!
  47.      */
  48.     public RandomAccessFile(int fd) {
  49.     this.fd = fd;
  50.     }
  51.     
  52.     /**
  53.      * Create a RandomAccessFile given a File object
  54.      * and mode ("r" or "rw").     
  55.      */
  56.     public RandomAccessFile(File file, String mode) {
  57.     this(file.getPath(), mode);
  58.     }
  59.  
  60.     /**
  61.      * Open a file, return the fd.  File is opened in
  62.      * read-write mode if writeable is true, else read-only.
  63.      */
  64.     private native int open(String name, boolean writeable);
  65.  
  66.     // 'Read' primitives
  67.     
  68.     /**
  69.      * Read a byte
  70.      */
  71.     public native int read();
  72.  
  73.     /**
  74.      * Read bytes
  75.      */
  76.     private native int readBytes(byte b[], int off, int len);
  77.  
  78.     /**
  79.      * Read an array of bytes
  80.      */
  81.     public int read(byte b[]) {
  82.     return readBytes(b, 0, b.length);
  83.     }
  84.     public int read(byte b[], int off, int len) {
  85.     return readBytes(b, off, len);
  86.     }
  87.  
  88.     // 'Write' primitives
  89.  
  90.     /**
  91.      * Write a byte.
  92.      */
  93.     public native void write(int b);
  94.  
  95.     /**
  96.      * Write bytes
  97.      */
  98.     private native void writeBytes(byte b[], int off, int len);
  99.  
  100.     /**
  101.      * Write an array of bytes
  102.      */
  103.     public void write(byte b[]) {
  104.     writeBytes(b, 0, b.length);
  105.     }
  106.     public void write(byte b[], int off, int len) {
  107.     writeBytes(b, off, len);
  108.     }
  109.  
  110.     // 'Random access' stuff
  111.  
  112.     /**
  113.      * Return the current location of the file pointer
  114.      */
  115.     public native int getFilePointer();
  116.  
  117.     /**
  118.      * Set the file pointer to the specified absolute position
  119.      */
  120.     public native void seek(int pos);
  121.  
  122.     /**
  123.      * Return the length of the file.
  124.      */
  125.     public native int length();
  126.  
  127.     /**
  128.      * Close the file. 
  129.      * (We need destructors!)
  130.      */
  131.     public native void close();
  132.  
  133.  
  134.     //
  135.     //  Some "reading/writing Java data types" methods stolen from
  136.     //  DataInputStream and DataOutputStream.
  137.     //
  138.     //    REMIND:  These don't belong here!  There eventually should be
  139.     //  a way to get a DataInputStream or DataOutputStream
  140.     //  based on a RandomAccessFile, or instead we could an interface
  141.     //  which describes the basic read() or write() functionality
  142.     //  (and then have a "PortableDataTypeIO" utility class which
  143.     //  had all the code to read/write primitive Java data types...)
  144.     //
  145.  
  146.     /**
  147.      * Read a boolean
  148.      */
  149.     public final boolean readBoolean() {
  150.     return read() != 0;
  151.     }
  152.  
  153.     /**
  154.      * Read a byte
  155.      */
  156.     public final byte readByte() {
  157.     return (byte)read();
  158.     }
  159.  
  160.     /**
  161.      * Read short
  162.      */
  163.     public final short readShort() {
  164.     return (short)(((read() << 8) & (0xFF << 8)) |
  165.                ((read() << 0) & (0xFF << 0)));
  166.     }
  167.  
  168.     /**
  169.      * Read char
  170.      */
  171.     public final char readChar() {
  172.     return (char)(((read() << 8) & (0xFF << 8)) |
  173.               ((read() << 0) & (0xFF << 0)));
  174.  
  175.     }
  176.  
  177.     /**
  178.      * Read int
  179.      */
  180.     public final int readInt() {
  181.     return ((read() << 24) & (0xFF << 24)) |
  182.            ((read() << 16) & (0xFF << 16)) |
  183.            ((read() <<  8) & (0xFF <<  8)) |
  184.            ((read() <<  0) & (0xFF <<  0));
  185.     }
  186.  
  187.     /**
  188.      * Read long
  189.      */
  190.     public final long readLong() {
  191.     return (((long)read() << 56) & ((long)0xFF << 56)) |
  192.            (((long)read() << 48) & ((long)0xFF << 48)) |
  193.            (((long)read() << 40) & ((long)0xFF << 40)) |
  194.            (((long)read() << 32) & ((long)0xFF << 32)) |
  195.            (((long)read() << 24) & ((long)0xFF << 24)) |
  196.            (((long)read() << 16) & ((long)0xFF << 16)) | 
  197.            (((long)read() <<  8) & ((long)0xFF <<  8)) |
  198.            (((long)read() <<  0) & ((long)0xFF <<  0));
  199.     }
  200.  
  201.     /**
  202.      * Read a line terminated by a '\n' or EOF.
  203.      */
  204.     public final String readLine() {
  205.     StringBuffer input = new StringBuffer();
  206.     int c;
  207.  
  208.     while (((c = read()) != -1) && (c != '\n')) {
  209.         input.appendChar((char)c);
  210.     }
  211.     if ((c == -1) && (input.length() == 0)) {
  212.         return null;
  213.     }
  214.     return input.toString();
  215.     }
  216.  
  217.     /**
  218.      * Read a UTF format string
  219.      */
  220.     public final String readUTF() {
  221.     int utflen = ((read() << 8) & 0xFF00) |
  222.                  ((read() << 0) & 0x00FF);
  223.     char str[] = new char[utflen];
  224.     int strlen = 0;
  225.  
  226.  
  227.     for (int i = 0 ; i < utflen ;) {
  228.         int c = read();
  229.         if ((c & 0x80) == 0) {
  230.         str[strlen++] = (char)c;
  231.         i++;
  232.         } else if ((c & 0xE0) == 0xC0) {
  233.         str[strlen++] = (char)(((c & 0x1F) << 6) | (read() & 0x3F));
  234.         i += 2;
  235.         } else {
  236.         str[strlen++] = (char)(((c & 0x0F) << 12) |
  237.                        ((read() & 0x3F) << 6) |
  238.                        (read() & 0x3F));
  239.         i += 3;
  240.         } 
  241.     }
  242.     return new String(str, 0, strlen);
  243.     }
  244.  
  245.  
  246.  
  247.     /**
  248.      * Write a boolean
  249.      */
  250.     public final void writeBoolean(boolean v) {
  251.     write(v ? 1 : 0);
  252.     //written++;
  253.     }
  254.  
  255.     /**
  256.      * Write a byte
  257.      */
  258.     public final void writeByte(int v) {
  259.     write(v);
  260.     //written++;
  261.     }
  262.  
  263.     /**
  264.      * Write short
  265.      */
  266.     public final void writeShort(int v) {
  267.     write((v >>> 8) & 0xFF);
  268.     write((v >>> 0) & 0xFF);
  269.     //written += 2;
  270.     }
  271.  
  272.     /**
  273.      * Write char
  274.      */
  275.     public final void writeChar(int v) {
  276.     write((v >>> 8) & 0xFF);
  277.     write((v >>> 0) & 0xFF);
  278.     //written += 2;
  279.     }
  280.  
  281.     /**
  282.      * Write int
  283.      */
  284.     public final void writeInt(int v) {
  285.     write((v >>> 24) & 0xFF);
  286.     write((v >>> 16) & 0xFF);
  287.     write((v >>>  8) & 0xFF);
  288.     write((v >>>  0) & 0xFF);
  289.     //written += 4;
  290.     }
  291.  
  292.     /**
  293.      * Write long
  294.      */
  295.     public final void writeLong(long v) {
  296.     write((int)(v >>> 56) & 0xFF);
  297.     write((int)(v >>> 48) & 0xFF);
  298.     write((int)(v >>> 40) & 0xFF);
  299.     write((int)(v >>> 32) & 0xFF);
  300.     write((int)(v >>> 24) & 0xFF);
  301.     write((int)(v >>> 16) & 0xFF);
  302.     write((int)(v >>>  8) & 0xFF);
  303.     write((int)(v >>>  0) & 0xFF);
  304.     //written += 8;
  305.     }
  306.  
  307.     /**
  308.      * Write a string as a sequence of bytes
  309.      * REMIND: need to add support for more data types
  310.      */
  311.     public final void writeBytes(String s) {
  312.     int len = s.length();
  313.     for (int i = 0 ; i < len ; i++) {
  314.         write((byte)s.charAt(i));
  315.     }
  316.     //written += len;
  317.     }
  318.  
  319.     /**
  320.      * Write a string as a sequence of chars
  321.      */
  322.     public final void writeChars(String s) {
  323.     int len = s.length();
  324.     for (int i = 0 ; i < len ; i++) {
  325.         int v = s.charAt(i);
  326.         write((v >>> 8) & 0xFF);
  327.         write((v >>> 0) & 0xFF);
  328.     }
  329.     //written += len * 2;
  330.     }
  331.  
  332.     /**
  333.      * Write string in UTF format
  334.      */
  335.     public final void writeUTF(String str) {
  336.     int strlen = str.length();
  337.     int utflen = 0;
  338.  
  339.     for (int i = 0 ; i < strlen ; i++) {
  340.         int c = str.charAt(i);
  341.         if ((c >= 0x0001) && (c <= 0x007F)) {
  342.         utflen++;
  343.         } else if (c > 0x03FF) {
  344.         utflen += 3;
  345.         } else {
  346.         utflen += 2;
  347.         }
  348.     }
  349.  
  350.     write((utflen >>> 8) & 0xFF);
  351.     write((utflen >>> 0) & 0xFF);
  352.     for (int i = 0 ; i < strlen ; i++) {
  353.         int c = str.charAt(i);
  354.         if ((c >= 0x0001) && (c <= 0x007F)) {
  355.         write(c);
  356.         } else if (c > 0x03FF) {
  357.         write(0xE0 | ((c >> 12) & 0x0F));
  358.         write(0x80 | ((c >>  6) & 0x3F));
  359.         write(0x80 | ((c >>  0) & 0x3F));
  360.         //written += 2;
  361.         } else {
  362.         write(0xC0 | ((c >>  6) & 0x1F));
  363.         write(0x80 | ((c >>  0) & 0x3F));
  364.         //written += 1;
  365.         }
  366.     }
  367.     //written += strlen + 2;
  368.     }
  369.  
  370.  
  371.  
  372.  
  373.  
  374. }
  375.