    001    /* Copyright 2000, 2001, Compaq Computer Corporation */
    002
    003    package javafe.filespace;
    004
    005
    006    import java.io.IOException;
    007    import java.util.Enumeration;
    008
    009    import javafe.genericfile.*;
    010
    011
    012    /**
    013     * This module implements the Query "interface" by using the Java
    014     * filespace classes (ClassPath, PathComponent, etc.) provided by the
    015     * javafe.filespace package.
    016     */
    017
    018    public class SlowQuery extends Query {
    019
    020        /***************************************************
    021         *                                                 *
    022         * Creation:                                       *
    023         *                                                 *
    024         **************************************************/
    025
    026        /**
    027         * The Java file space that corresponds to our classpath.
    028         */
    029        private Tree javaFileSpace;
    030
    031
    032        /**
    033         * Create an query engine that may be queried about packages and
    034         * classes in the classpath classpath.
    035         *
    036         */
    037        //@ requires classpath != null;
    038        public SlowQuery(String classpath) throws java.io.IOException {
    039            javaFileSpace = ClassPath.open(classpath, false);
    040        }
    041
    042        /**
    043         * Create an query engine that may be queried about packages and
    044         * classes in the current Java classpath (cf. ClassPath) at the
    045         * time the engine was created.  (I.e., later changes to the
    046         * current classpath have no effect on the query engine.)
    047         */
    048        public SlowQuery() throws java.io.IOException {
    049            javaFileSpace = ClassPath.open(false);
    050        }
    051
    052
    053        /***************************************************
    054         *                                                 *
    055         * Locating files:                                 *
    056         *                                                 *
    057         **************************************************/
    058
    059        /**
    060         * Return true iff the package P in the Java filespace is
    061         * "accessible".<p>
    062         *
    063         * Warning: the definition of accessible is host system dependent
    064         * and may in fact be defined as always true.<p>
    065         */
    066        //@ also
    067        //@   requires P != null;
    068        public boolean accessable(String[] P) {
    069            return (getPackage(P) != null);
    070        }
    071
    072
    073        /**
    074         * Attempt to locate the file typename+"."+extension in the package
    075         * P in the Java filespace.<p>
    076         *
    077         * If such a file is found, then a (non-null) GenericFile
    078         * representing it is returned.  Otherwise, null is returned.<p>
    079         */
    080        //@ also
    081        //@   requires P != null;
    082        //@   requires typename != null;
    083        //@   requires extension != null;
    084        public GenericFile findFile(String[] P, String typename,
    085                                            String extension) {
    086            return findFile(P,typename+"."+extension);
    087        }
    088
    089        //@ also
    090        //@   requires P != null;
    091        //@   requires filename != null;
    092        public GenericFile findFile(String[] P, String filename) {
    093            Tree Package = getPackage(P);
    094            if (Package==null)
    095                return null;
    096
    097            Tree node = Package.getChild(filename);
    098            if (node==null)
    099                return null;
    100
    101            return (GenericFile)node.data;          //@ nowarn Cast;
    102        }
    103
    104        //@ also
    105        //@   requires P != null;
    106        //@   requires typename != null;
    107        //@ requires extensions != null;
    108        public GenericFile findFile(String[] P, String typename,
    109                                            String[] extensions) {
    110    // FIXME - only utilizes the first package
    111            Tree Package = getPackage(P);
    112            if (Package==null)
    113                return null;
    114
    115            for (int i=0; i<extensions.length; ++i) {
    116                String extension = extensions[i];
    117                Tree node = Package.getChild(typename+"."+extension);
    118                if (node != null) return (GenericFile)node.data; //@ nowarn Cast;
    119            }
    120            return null;
    121         }
    122
    123        //@ also
    124        //@   requires P != null;
    125        public Enumeration findFiles(String[] P) {
    126            Tree Package = getPackage(P);
    127            if (Package==null)
    128                return null;
    129
    130            return Package.children();
    131        }
    132
    133        /*
    134         * Helper function: return the node corresponding to package P in
    135         * the Java filespace or null if there is no such corresponding
    136         * package.
    137         */
    138        //@ requires P != null;
    139        //@ requires \nonnullelements(P);
    140        private Tree getPackage(String[] P) {
    141            Tree Package = javaFileSpace;
    142
    143            for (int i=0; i<P.length; i++) {
    144                if (Package != null)
    145                    Package = Package.getChild(P[i]);
    146            }
    147
    148            return Package;
    149        }
    150
    151
    152        /***************************************************
    153         *                                                 *
    154         * Debugging functions:                            *
    155         *                                                 *
    156         **************************************************/
    157
    158        /** A simple test driver */
    159        //@ requires args != null;
    160        //@ requires \nonnullelements(args);
    161        public static void main(String[] args) throws IOException {
    162            /*
    163             * Parse command arguments:
    164             */
    165            if (args.length != 3) {
    166                System.out.println(
    167                    "Query: usage <package name> <typename> <extension>");
    168                return;
    169            }
    170
    171            Query Q = new SlowQuery();
    172            String[] P = StringUtil.parseList(args[0],'.');
    173
    174            if (!Q.accessable(P))
    175                System.out.println("Package not accessible.");
    176
    177            GenericFile result = Q.findFile(P, args[1], args[2]);
    178            if (result==null)
    179                System.out.println("Type not found.");
    180            else
    181                System.out.println("Type found @ " + result.getHumanName());
    182        }
    183    }