@SuppressWarnings("rawtypes") private static final Class filePathToClass(String cpEntry, String path) { if (path.length() <= cpEntry.length()) { throw new IllegalArgumentException("Illegal path: cp=" + cpEntry + " path=" + path); } if (path.charAt(cpEntry.length()) != '/') { throw new IllegalArgumentException("Illegal path: cp=" + cpEntry + " path=" + path); } path = path.substring(cpEntry.length() + 1); path = path.replaceAll("/", ".").substring(0, path.length() - 6); try { return Class.forName(path, false, ClassLoader.getSystemClassLoader()); } catch (ClassNotFoundException e) { throw log.fail("Could not load class at path: " + path); } catch (NoClassDefFoundError ex) { log.debug(LOG_TAG, "Class at path " + path + " is unloadable"); return null; } }
@SuppressWarnings("rawtypes") protected static final Map<String, Field> fillOptions( Class<?>[] classes, Map<String, String> options, boolean ensureAllOptions) { // --Get Fillable Options Map<String, Field> canFill = new HashMap<String, Field>(); Map<String, Marker> required = new HashMap<String, Marker>(); Map<String, String> interner = new HashMap<String, String>(); for (Class c : classes) { Field[] fields = null; try { fields = c.getDeclaredFields(); } catch (Throwable e) { log.debug( LOG_TAG, "Could not check fields for class: " + c.getName() + " (caused by " + e.getClass() + ": " + e.getMessage() + ")"); continue; } for (Field f : fields) { Option o = f.getAnnotation(Option.class); if (o != null) { // (check if field is static) if ((f.getModifiers() & Modifier.STATIC) == 0) { log.err(LOG_TAG, "Option can only be applied to static field: " + c + "." + f); System.exit(ExitCode.BAD_OPTION.code); } // (required marker) Marker mark = null; if (o.required()) { mark = new Marker(); mark.unset(); } // (add main name) String name = o.name().toLowerCase(); if (name.equals("")) { name = f.getName().toLowerCase(); } if (canFill.containsKey(name)) { String name1 = canFill.get(name).getDeclaringClass().getCanonicalName() + "." + canFill.get(name).getName(); String name2 = f.getDeclaringClass().getCanonicalName() + "." + f.getName(); if (!name1.equals(name2)) { log.err( LOG_TAG, "Multiple declarations of option " + name + ": " + name1 + " and " + name2); System.exit(ExitCode.BAD_OPTION.code); } else { log.err( LOG_TAG, "Class is in classpath multiple times: " + canFill.get(name).getDeclaringClass().getCanonicalName()); } } canFill.put(name, f); if (mark != null) required.put(name, mark); interner.put(name, name); // (add alternate names) if (!o.alt().equals("")) { for (String alt : o.alt().split(" *, *")) { alt = alt.toLowerCase(); if (canFill.containsKey(alt) && !alt.equals(name)) throw new IllegalArgumentException( "Multiple declarations of option " + alt + ": " + canFill.get(alt) + " and " + f); canFill.put(alt, f); if (mark != null) required.put(alt, mark); interner.put(alt, name); } } } } } // --Fill Options for (String key : options.keySet()) { String rawKey = key; key = key.toLowerCase(); // (get values) String value = options.get(rawKey); Field target = canFill.get(key); // (mark required option as fulfilled) Marker mark = required.get(key); if (mark != null) { mark.set(); } // (fill the field) if (target != null) { // (case: declared option) fillField(target, value); } else if (ensureAllOptions) { // (case: undeclared option) // split the key int lastDotIndex = rawKey.lastIndexOf('.'); if (lastDotIndex < 0) { log.err(LOG_TAG, "Unrecognized option: " + key); System.exit(ExitCode.BAD_OPTION.code); } String className = rawKey.substring(0, lastDotIndex); String fieldName = rawKey.substring(lastDotIndex + 1); // get the class Class clazz = null; try { clazz = ClassLoader.getSystemClassLoader().loadClass(className); } catch (Exception e) { log.err(LOG_TAG, "Could not set option: " + rawKey + "; no such class: " + className); System.exit(ExitCode.BAD_OPTION.code); } // get the field try { target = clazz.getField(fieldName); } catch (Exception e) { log.err( LOG_TAG, "Could not set option: " + rawKey + "; no such field: " + fieldName + " in class: " + className); System.exit(ExitCode.BAD_OPTION.code); } fillField(target, value); } } // --Ensure Required boolean good = true; for (String key : required.keySet()) { if (!required.get(key).isSet()) { log.err( LOG_TAG, "Missing required option: " + interner.get(key) + " <in class: " + canFill.get(key).getDeclaringClass() + ">"); required.get(key).set(); // don't duplicate error messages good = false; } } if (!good) { System.exit(ExitCode.BAD_OPTION.code); } return canFill; }
private static final Class<?>[] getVisibleClasses(Map<String, String> options) { // --Variables List<Class<?>> classes = new ArrayList<Class<?>>(); // (get classpath) String pathSep = System.getProperty("path.separator"); String[] cp = System.getProperties().getProperty("java.class.path", null).split(pathSep); // --Configuration ensureScalaPath(options, cp); // --Fill Options // (get classes) for (String entry : cp) { // (should skip?) if (entry.equals(".") || entry.trim().length() == 0) { continue; } boolean isIgnored = false; for (String pattern : ignoredClasspath) { if (entry.matches(pattern)) { log.debug(LOG_TAG, "Ignoring options in classpath element: " + entry); isIgnored = true; break; } } if (isIgnored) { continue; } // (no, don't skip) File f = new File(entry); if (f.isDirectory()) { // --Case: Files LazyFileIterator iter = new LazyFileIterator(f, ".*class$"); while (iter.hasNext()) { // (get the associated class) Class<?> clazz = filePathToClass(entry, iter.next().getPath()); if (clazz != null) { // (add the class if it's valid) classes.add(clazz); } } } else if (!isIgnored(entry)) { // --Case: Jar try { JarFile jar = new JarFile(f); Enumeration<JarEntry> e = jar.entries(); while (e.hasMoreElements()) { // (for each jar file element) JarEntry jarEntry = e.nextElement(); String clazz = jarEntry.getName(); if (clazz.matches(".*class$")) { // (if it's a class) clazz = clazz.substring(0, clazz.length() - 6).replaceAll("/", "."); // (add it) try { classes.add(Class.forName(clazz, false, ClassLoader.getSystemClassLoader())); } catch (ClassNotFoundException ex) { throw Log.internal("Could not load class in jar: " + f + " at path: " + clazz); } catch (NoClassDefFoundError ex) { log.debug(LOG_TAG, "Could not scan class: " + clazz + " (in jar: " + f + ")"); } } } } catch (IOException e) { throw log.fail("Could not open jar file: " + f + "(are you sure the file exists?)"); } } else { // case: ignored jar } } return classes.toArray(new Class<?>[classes.size()]); }