private static void adjustFilter() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(FILTER_PATH)); // Set field public javaClass.getField("mode").setPublic(); javaClass.getField("text").setPublic(); javaClass.getField("enable").setPublic(); // Add hashCode method and equals method javaClass.addImport("com.hippo.util.HashCodeUtils"); javaClass.addMethod("\t@Override\n" + "\tpublic int hashCode() {\n" + "\t\treturn HashCodeUtils.hashCode(mode, text);\n" + "\t}"); javaClass.addImport("com.hippo.yorozuya.ObjectUtils"); javaClass.addMethod("\t@Override\n" + "\tpublic boolean equals(Object o) {\n" + "\t\tif (!(o instanceof Filter)) {\n" + "\t\t\treturn false;\n" + "\t\t}\n" + "\n" + "\t\tFilter filter = (Filter) o;\n" + "\t\treturn filter.mode == mode && ObjectUtils.equal(filter.text, text);\n" + "\t}"); FileWriter fileWriter = new FileWriter(FILTER_PATH); fileWriter.write(javaClass.toString()); fileWriter.close(); } }
private static void adjustQuickSearch() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(QUICK_SEARCH_PATH)); // Set all field public javaClass.getField("id").setPublic(); javaClass.getField("name").setPublic(); javaClass.getField("mode").setPublic(); javaClass.getField("category").setPublic(); javaClass.getField("keyword").setPublic(); javaClass.getField("advanceSearch").setPublic(); javaClass.getField("minRating").setPublic(); javaClass.getField("time").setPublic(); javaClass.addMethod("\t@Override\n" + "\tpublic String toString() {\n" + "\t\treturn name;\n" + "\t}"); FileWriter fileWriter = new FileWriter(QUICK_SEARCH_PATH); fileWriter.write(javaClass.toString()); fileWriter.close(); }
private static void adjustLocalFavoriteInfo() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(LOCAL_FAVORITE_INFO_PATH));
private static void adjustBookmarkInfo() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(BOOKMARK_INFO_PATH));
private static void adjustHistoryInfo() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(HISTORY_INFO_PATH));
private static void adjustDownloadInfo() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(DOWNLOAD_INFO_PATH));
/** * Parse the given String data into a new {@link JavaType} instance. * * @param data the data to parse * @return the new {@link JavaType} instance * @throws ParserException if no parser is capable of parsing the provided data * @throws IllegalStateException if no parser is available in the classPath */ public static JavaType<?> parse(final String data) { return parse(JavaType.class, data); }
/** * Open the given {@link File}, parsing its contents into a new {@link JavaType} instance. */ public static JavaType<?> parse(final File file) throws FileNotFoundException { return parse(JavaType.class, file); }
/** * Parse the given character array into a new {@link JavaType} instance. */ public static JavaType<?> parse(final char[] data) { return parse(JavaType.class, data); }
/** * Parse the given String data into a new {@link JavaType} instance. */ public static JavaType<?> parse(final String data) { return parse(JavaType.class, data); }
/** * Parse the given {@link URL} data into a new {@link JavaType} instance. * * @param url the url to read from * @return a the new {@link JavaType} instance * @throws IOException if the reading fails * @throws ParserException if no parser is capable of parsing the provided data * @throws IllegalStateException if no parser is available in the classPath */ public static JavaType<?> parse(final URL url) throws IOException { return parse(JavaType.class, url); }
private static <T extends JavaType<?>> T internalParse(final Class<T> type, final InputStream data) { try { return parse(type, data); } finally { Streams.closeQuietly(data); } } }
@Override public <NESTED_TYPE extends JavaSource<?>> NESTED_TYPE addNestedType(String declaration) { JavaSource<?> nestedType = Roaster.parse(JavaSource.class, declaration); return (NESTED_TYPE) addNestedType(nestedType); }
private Optional<String> parseDocumentationFor(Class<?> clazz, Path file) { try { JavaType<?> parsed = Roaster.parse(file.toFile()); JavaDoc<?> s = parsed.getJavaDoc(); return Optional.of(s.getText()); } catch (FileNotFoundException e) { logger.warn("exception occurred while attempting to parse file {} for class {}", file, clazz, e); return Optional.absent(); } }
private org.eclipse.jdt.core.dom.Type parseTypeBound(String bound) { String stub = "public class Stub<T extends " + bound + "> {}"; JavaClassSource temp = Roaster.parse(JavaClassSource.class, stub); TypeParameter v = (TypeParameter) temp.getTypeVariables().get(0).getInternal(); return (org.eclipse.jdt.core.dom.Type) v.typeBounds().get(0); } }
private static AnnotationTypeMemberDeclaration parseElement(JavaAnnotationSource parent, String declaration) { if (!declaration.trim().endsWith(";")) { declaration = declaration + ";"; } String stub = "public @interface Stub { " + declaration + " }"; JavaAnnotationSource temp = (JavaAnnotationSource) Roaster.parse(stub); List<AnnotationElementSource> fields = temp.getAnnotationElements(); AnnotationTypeMemberDeclaration newField = (AnnotationTypeMemberDeclaration) fields.get(0).getInternal(); return (AnnotationTypeMemberDeclaration) ASTNode.copySubtree(((ASTNode) parent.getInternal()).getAST(), newField); }
public EnumConstantImpl(final JavaEnumSource parent, final String declaration) { init(parent); String stub = "public enum Stub { " + declaration + " }"; JavaEnumSource temp = (JavaEnumSource) Roaster.parse(stub); List<EnumConstantSource> constants = temp.getEnumConstants(); EnumConstantDeclaration newField = (EnumConstantDeclaration) constants.get(0).getInternal(); EnumConstantDeclaration subtree = (EnumConstantDeclaration) ASTNode.copySubtree(ast, newField); this.enumConstant = subtree; }
@Override public FieldSource<O> setLiteralInitializer(final String value) { String stub = "public class Stub { private Object stub = " + value + " }"; JavaClass<?> temp = Roaster.parse(JavaClass.class, stub); VariableDeclarationFragment tempFrag = (VariableDeclarationFragment) temp.getFields().get(0).getInternal(); fragment.setInitializer((Expression) ASTNode.copySubtree(ast, tempFrag.getInitializer())); return this; }
public static org.eclipse.jdt.core.dom.Type fromString(String resolvedType, AST ast) { String stub = "public class Stub { " + resolvedType + " field; }"; JavaClassSource temp = (JavaClassSource) Roaster.parse(stub); List<FieldSource<JavaClassSource>> fields = temp.getFields(); org.eclipse.jdt.core.dom.Type fieldType = ((FieldDeclaration) ((VariableDeclarationFragment) fields.get(0) .getInternal()).getParent()).getType(); return (org.eclipse.jdt.core.dom.Type) ASTNode.copySubtree(ast, fieldType); } }
public TypeImpl(final O origin, final Type<O> parent, final String type) { init(origin); this.parent = parent; String stub = "public class Stub { private " + type + " getType(){return null;} }"; JavaClassSource temp = (JavaClassSource) Roaster.parse(stub); List<MethodSource<JavaClassSource>> methods = temp.getMethods(); MethodDeclaration newMethod = (MethodDeclaration) methods.get(0).getInternal(); org.eclipse.jdt.core.dom.Type subtree = (org.eclipse.jdt.core.dom.Type) ASTNode.copySubtree(cu.getAST(), newMethod.getReturnType2()); this.type = subtree; }