dcwthematicindex.java

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

        int[] values = null;

        try {
            int index = Arrays.binarySearch(indexData, valueIndex);
            if (index >= 0) {
                IndexRecord ir = indexData[index];
                int offset = ir.offset;
                int numvals = ir.numvals;

                if ((typeOfIndex == 'T') || (typeOfIndex == 'I')) {
                    if (numvals == 0) {
                        values = new int[1];
                        values[0] = offset;
                    } else {
                        values = new int[numvals];
                        reopen(offset);

                        for (int j = 0; j < numvals; j++) {
                            values[j] = readIndexWithFieldType(dataTypeSpecifier);
                        }
                    }

                    return values;

                } else if ((typeOfIndex == 'B') || (typeOfIndex == 'G')) {
                    // Don't really do anything with this type of
                    // index...

                    int shortread = numberOfRows / 16;
                    if ((numberOfRows % 16) != 0) {
                        shortread++;
                    }
                    if (Debug.debugging("vpfserver")) {
                        System.out.println("Reading a bunch of shorts: "
                                + shortread);
                        System.out.println("Starting at offset: "
                                + inputFile.getFilePointer());
                    }

                    BitSet bits = new BitSet(numberOfRows);
                    int cnt = 0;
                    for (int shortcnt = 0; shortcnt < shortread; shortcnt++) {
                        short s = inputFile.readShort();

                        for (int k = 0; k < 16; k++) {
                            cnt++;
                            if ((s & 0x1) == 1) {
                                bits.set(cnt);
                            }
                            s >>= 1;
                        }
                    }
                    StringBuffer prt = new StringBuffer();
                    for (int j = 1; j <= bits.size(); j++) {
                        if (bits.get(j)) {
                            prt.append(", " + j);
                        }
                    }
                    System.out.println(prt);

                } else {
                    throw new FormatException("Unidentied TMI format");
                }
            }
        } catch (EOFException e) {
            throw new FormatException("Hit Premature EOF in thematic index");
        } catch (IOException i) {
            throw new FormatException("Encountered IO Exception: "
                    + i.getMessage());
        }

        return values;
    }

    /**
     * Utility method to read rows.
     * 
     * @param ft the field type
     * @returns the value read from the file
     */
    private int readIndexWithFieldType(char ft) throws EOFException,
            FormatException {
        switch (ft) {
        case 'S':
            return (int) inputFile.readShort();
        case 'I':
            return inputFile.readInteger();
        }
        throw new FormatException("Unrecognized FieldTypeOfIndex");
    }

    private Object readIndexField(char dts, int textlen) throws EOFException,
            FormatException {
        switch (dts) {
        case 'I':
            return new Integer(inputFile.readInteger());
        case 'T':
            return inputFile.readFixedLengthString(textlen);
        case 'S':
            return new Short(inputFile.readShort());
        case 'F':
            return new Float(inputFile.readFloat());
        case 'R':
            return new Double(inputFile.readDouble());
        }
        throw new FormatException("Unrecognized field index type");
    }

    private String trim(String s) {
        StringBuffer ns = new StringBuffer();
        char foo[] = s.toCharArray();
        for (int i = 0; i < foo.length; i++) {
            if ((foo[i] == ' ') || (foo[i] == 0)) {
                break;
            }
            ns.append(foo[i]);
        }
        return ns.toString();
    }

    /**
     * Returns the number of distinct indexed values
     * 
     * @return the number of distinct indexed values
     */
    public int getNumberOfCodes() {
        return numberOfCodes;
    }

    /**
     * Returns the number of rows indexed
     * 
     * @return the number of rows indexed
     */
    public int getNumberOfRows() {
        return numberOfRows;
    }

    /**
     * Returns the type of index (refer to VPF spec for valid values)
     * 
     * @return the type of index (refer to VPF spec for valid values)
     */
    public char getTypeOfIndex() {
        return typeOfIndex;
    }

    /**
     * Returns the type of the field being indexed
     * 
     * @return the type of the field being indexed
     */
    public char getFieldTypeOfIndex() {
        return fieldTypeOfIndex;
    }

    /**
     * Returns the number of elements in the index field
     * 
     * @return the number of elements in the index field
     */
    public int getNumberOfDataElements() {
        return numberOfDataElement;
    }

    /**
     * Returns the datatype specifier
     * 
     * @return the datatype specifier
     */
    public char getDataTypeSpecifier() {
        return dataTypeSpecifier;
    }

    /**
     * Returns the name of the table being indexed
     * 
     * @return the name of the table being indexed
     */
    public String getTableIndexed() {
        return tableIndexed;
    }

    /**
     * Returns the name of the column being indexed
     * 
     * @return the name of the column being indexed
     */
    public String getColumnIndexed() {
        return columnIndexed;
    }

    public boolean getSorted() {
        return sorted;
    }

    /** Closes the associated input file. (may later get reopened) */
    public synchronized void close() throws FormatException {
        try {
            if (inputFile != null) {
                inputFile.close();
            }
            inputFile = null;
        } catch (IOException i) {
            throw new FormatException("DcwThematicIndex: Can't close file "
                    + filename + ": " + i.getMessage());
        }
    }

    /**
     * Reopen the associated input file.
     * 
     * @param offset the byte offset to seek to upon reopening the
     *        file. If offset is invalid (less than 1), then the input
     *        stream is in an undefined location.
     * @exception FormatException some error was encountered in
     *            reopening file or seeking to the desired row.
     * @see #close()
     */
    public synchronized void reopen(int offset) throws FormatException {
        try {
            if (inputFile == null) {
                inputFile = new BinaryBufferedFile(filename);
                inputFile.byteOrder(byteOrder);
            }
            if (offset > 0) {
                inputFile.seek(offset);
            }
        } catch (IOException i) {
            throw new FormatException("DcwThematicIndex: Can't open file "
                    + filename + ": " + i.getMessage());
        }
    }

}