/** * Implementation of getClass() * * <p>Load a class through this namespace taking into account imports. * * <p>Check the cache first. If an unqualified name look for imported class or package. Else try * to load absolute name. * * <p>This method implements caching of unqualified names (normally imports). Qualified names are * cached by the BshClassManager. Unqualified absolute class names (e.g. unpackaged Foo) are * cached too so that we don't go searching through the imports for them each time. * * @return null if not found. */ private Class getClassImpl(String name) throws UtilEvalError { Class c = null; // Check the cache if (classCache != null) { c = classCache.get(name); if (c != null) return c; } // Unqualified (simple, non-compound) name boolean unqualifiedName = !Name.isCompound(name); // Unqualified name check imported if (unqualifiedName) { // Try imported class if (c == null) c = getImportedClassImpl(name); // if found as imported also cache it if (c != null) { cacheClass(name, c); return c; } } // Try absolute c = classForName(name); if (c != null) { // Cache unqualified names to prevent import check again if (unqualifiedName) cacheClass(name, c); return c; } // Not found if (Interpreter.DEBUG) Interpreter.debug("getClass(): " + name + " not found in " + this); return null; }
/** * Try to make the name into an imported class. This method takes into account only imports (class * or package) found directly in this NameSpace (no parent chain). */ private Class getImportedClassImpl(String name) throws UtilEvalError { // Try explicitly imported class, e.g. import foo.Bar; String fullname = null; if (importedClasses != null) fullname = importedClasses.get(name); // not sure if we should really recurse here for explicitly imported // class in parent... if (fullname != null) { /* Found the full name in imported classes. */ // Try to make the full imported name Class clas = classForName(fullname); // Handle imported inner class case if (clas == null) { // Imported full name wasn't found as an absolute class // If it is compound, try to resolve to an inner class. // (maybe this should happen in the BshClassManager?) if (Name.isCompound(fullname)) try { clas = getNameResolver(fullname).toClass(); } catch (ClassNotFoundException e) { /* not a class */ } else if (Interpreter.DEBUG) Interpreter.debug("imported unpackaged name not found:" + fullname); // If found cache the full name in the BshClassManager if (clas != null) { // (should we cache info in not a class case too?) getClassManager().cacheClassInfo(fullname, clas); return clas; } } else return clas; // It was explicitly imported, but we don't know what it is. // should we throw an error here?? return null; } /* Try imported packages, e.g. "import foo.bar.*;" in reverse order of import... (give later imports precedence...) */ if (importedPackages != null) for (int i = importedPackages.size() - 1; i >= 0; i--) { String s = importedPackages.get(i) + "." + name; Class c = classForName(s); if (c != null) return c; } BshClassManager bcm = getClassManager(); /* Try super import if available Note: we do this last to allow explicitly imported classes and packages to take priority. This method will also throw an error indicating ambiguity if it exists... */ if (bcm.hasSuperImport()) { String s = bcm.getClassNameByUnqName(name); if (s != null) return classForName(s); } return null; }