fileinputreader.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

// **********************************************************************
// 
// <copyright>
// 
//  BBN Technologies
//  10 Moulton Street
//  Cambridge, MA 02138
//  [phone]
// 
//  Copyright (C) BBNT Solutions LLC. All rights reserved.
// 
// </copyright>
// **********************************************************************
// 
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/io/FileInputReader.java,v $
// $RCSfile: FileInputReader.java,v $
// $Revision: 1.2.2.1 $
// $Date: 2004/10/14 18:27:01 $
// $Author: dietrick $
// 
// **********************************************************************


package com.bbn.openmap.io;

import com.bbn.openmap.util.Debug;
import java.io.*;

/**
 * This class wraps a java.io.RandomAccessFile to allow us to choose
 * the byte-order of the underlying file.  It has a user-settable
 * byte-ordering, which is then used to properly implement the various
 * multibyte reading members.  Used for reading local files.
 *
 * @see java.io.RandomAccessFile 
 * @see com.bbn.openmap.io.InputReader 
 * @see com.bbn.openmap.io.BinaryFile
 */
public class FileInputReader implements InputReader {
    /** The underlying file input */
    protected RandomAccessFile inputFile = null;
    protected String name = null;

    /**
     * Constructs a new BinaryFile with the specified file as the
     * input.  The default byte-order is LSB first.  Reads start at
     * the first byte of the file.
     *
     * @param f the file to be opened for reading
     * @exception IOException pass-through errors from opening a
     * RandomAccessFile with f
     * @see java.io.RandomAccessFile 
     */
    public FileInputReader(File f) throws IOException {
        if (Debug.debugging("binaryfile")) {
            Debug.output("FileInputReader created from " + f.getAbsolutePath());
        }
        init(f);
    }

    /**
     * Constructs a new BinaryFile with the specified file as the
     * input.  The default byte-order is LSB first.  Reads start at
     * the first byte of the file.
     *
     * @param f the path to the file to be opened for reading.
     * @exception IOException pass-through errors from opening a
     * RandomAccessFile with f
     * @see java.io.RandomAccessFile 
     */
    public FileInputReader(String f) throws IOException {
        if (Debug.debugging("binaryfile")) {
            Debug.output("FileInputReader created from " + f);
        }
        init(new File(f));
    }

    /**
     * Get the file name.
     */
    public String getName() {
        return name;
    }

    /**
     * Initialize the underlying RandomAccessFile.  If it's found, but
     * there are too many files open, it calls
     * BinaryFile.closeClosable to try to get an open file pointer
     * from the system, and then tries again.
     * @param f a java.io.File
     * @throws IOException
     */
    protected void init(File f) throws IOException {
        try {
            name = f.getName();
            inputFile = new RandomAccessFile(f, "r");
        } catch (IOException i) {
            if (i instanceof FileNotFoundException) {
                throw i;
            }
            
            if (f.canRead()) {
                BinaryFile.closeClosable();
                inputFile = new RandomAccessFile(f, "r");
            } else {
                throw i;
            }
        }       
    }

    /**
     * Get the RandomAccessFile, for quering purposes only.  Don't use
     * it to get data!
     */
    public RandomAccessFile getInputFile() {
        return inputFile;
    }

    /**
     * Skip over n bytes in the input file
     *
     * @param n the number of bytes to skip
     * @return the actual number of bytes skipped.  annoying, isn't it?
     * @exception IOException Any IO errors that occur in skipping bytes
     * in the underlying file
     */
    public long skipBytes(long n) throws IOException {
        return inputFile.skipBytes((int)n);
    }

    /**
     * Get the index of the next character to be read
     *
     * @return the index
     * @exception IOException Any IO errors that occur in accessing
     * the underlying file
     */
    public long getFilePointer() throws IOException {
        return inputFile.getFilePointer();
    }

    /**
     * Set the index of the next character to be read.
     *
     * @param pos the position to seek to.
     * @exception IOException Any IO Errors that occur in seeking the
     * underlying file.
     */
    public void seek(long pos) throws IOException {
        inputFile.seek(pos);
    }

    /**
     * Local files only.  Retrieve the length of the file being accessed.
     *
     * @return the length of the file (counted in bytes)
     * @exception IOException Any IO errors that occur in accessing the
     * underlying file.
     */
    public long length() throws IOException {
        return inputFile.length();
    }

    /**
     * Return how many bytes left to be read in the file.
     *
     * @return the number of bytes remaining to be read (counted in bytes)
     * @exception IOException Any IO errors encountered in accessing the file
     */
    public long available() throws IOException {
        return(length() - getFilePointer());
    }

    /** 
     * Closes the underlying file
     *
     * @exception IOException Any IO errors encountered in accessing the file
     */
    public void close() throws IOException {
        if (Debug.debugging("binaryfile")) {
            Debug.output("FileInputReader.close()");
        }
        try {
            if (inputFile != null) inputFile.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        inputFile = null;
    }

    /**
     * Read from the file.
     *
     * @return one byte from the file.  -1 for EOF
     * @exception IOException Any IO errors encountered in reading from the file
     */
    public int read() throws IOException {
        return inputFile.read();
    }

    /**
     * Read from the file
     *
     * @param b The byte array to read into
     * @param off the first array position to read into
     * @param len the number of bytes to read
     * @return the number of bytes read
     * @exception IOException Any IO errors encountered in reading from the file
     */
    public int read(byte b[], int off, int len) throws IOException {
        return inputFile.read(b, off, len);
    }

    /** 
     * Read from the file.
     *
     * @param b the byte array to read into.  Equivelent to 
     * <code>read(b, 0, b.length)</code>
     * @return the number of bytes read
     * @exception IOException Any IO errors encountered in reading from the file
     * @see java.io.RandomAccessFile#read(byte[])
     */
    public int read(byte b[]) throws IOException {
        return inputFile.read(b);
    }

    /** 
     * Read from the file.
     *
     * @param howmany the number of bytes to read
     * @param allowless if we can return fewer bytes than requested
     * @return the array of bytes read.
     * @exception FormatException Any IO Exceptions, plus an end-of-file
     * encountered after reading some, but now enough, bytes when allowless
     * was <code>false</code>
     * @exception EOFException Encountered an end-of-file while allowless 
     * was <code>false</code>, but NO bytes had been read.
     */
    public byte[] readBytes(int howmany, boolean allowless) 
        throws EOFException, FormatException {

        byte foo[] = new byte[howmany];
        int gotsofar = 0;
        int err = 0;
        try {
            while (gotsofar < howmany) {
                err = inputFile.read(foo, gotsofar, howmany - gotsofar);

                if (err == -1) {
                    if (allowless) {
                        //return a smaller array, so the caller can tell how much
                        //they really got
                        byte retval[] = new byte[gotsofar];
                        System.arraycopy(foo, 0, retval, 0, gotsofar);
                        return retval;
                    } else { //some kind of failure...
                        if (gotsofar > 0) {
                            throw new FormatException("EOF while reading data");
                        } else {
                            throw new EOFException();
                        }
                    }
                }
                gotsofar += err;
            }
        } catch (IOException i) {
            throw new FormatException("FileInputReader: readBytes IOException: " + i.getMessage());
        }
        return foo;
    }

}