/** * The main method. * * @param args the arguments */ public static void main(String[] args) { RandomModificatorsClass randomClass = new RandomModificatorsClass(); Field[] flds = randomClass.getClass().getDeclaredFields(); System.out.println("VARIABLES: \n"); for (int i = 0; i < flds.length; i++) { String name = flds[i].getName(); flds[i].setAccessible(true); Class<?> type = flds[i].getType(); int modifier = flds[i].getModifiers(); System.out.print( "Name:" + name + "\nType:" + type + "\nModifier: " + Modifier.toString(modifier) + "\n\n"); } Method[] method = randomClass.getClass().getDeclaredMethods(); System.out.println("METHODS:\n"); for (int i = 0; i < method.length; i++) { String name = method[i].getName(); flds[i].setAccessible(true); Class<?> type = method[i].getReturnType(); int modifier = method[i].getModifiers(); System.out.print( "Name:" + name + "\nType:" + type + "\nModifier: " + Modifier.toString(modifier) + "\n\n"); } @SuppressWarnings("rawtypes") Constructor[] constr = randomClass.getClass().getDeclaredConstructors(); System.out.println("CONSTRUCTORS:\n"); for (int i = 0; i < constr.length; i++) { String name = constr[i].getName(); flds[i].setAccessible(true); int modifier = constr[i].getModifiers(); System.out.print( "Name:" + name + "\nType:" + "\nModifier: " + Modifier.toString(modifier) + "\n\n"); } }
public String toString(ConstantInfo pool[]) { String t = ""; t += java.lang.reflect.Modifier.toString(getAccessFlags()) + " "; t += getDescriptor(pool) + " "; t += getName(pool); return t; }
public void generate(JNIField field) { String name = field.getName(); Iterator<File> keys = files.keySet().iterator(); while (keys.hasNext()) { File key = keys.next(); String str = files.get(key); if (str.indexOf(name) != -1) { int modifiers = field.getModifiers(); String modifiersStr = Modifier.toString(modifiers); output("\t"); output(modifiersStr); if (modifiersStr.length() > 0) output(" "); output(field.getType().getTypeSignature3(false)); output(" "); output(field.getName()); output(" = "); output(getFieldValue(field)); outputln(";"); usedCount++; return; } } unusedCount++; // output("NOT USED=" + field.toString() + " \n"); }
public static void main(String... args) { try { Class<?> c = Class.forName(args[0]); int searchMods = 0x0; for (int i = 1; i < args.length; i++) { searchMods |= modifierFromString(args[i]); } Field[] flds = c.getDeclaredFields(); out.format( "Fields in Class '%s' containing modifiers: %s%n", c.getName(), Modifier.toString(searchMods)); boolean found = false; for (Field f : flds) { int foundMods = f.getModifiers(); // Require all of the requested modifiers to be present if ((foundMods & searchMods) == searchMods) { out.format( "%-8s [ synthetic=%-5b enum_constant=%-5b ]%n", f.getName(), f.isSynthetic(), f.isEnumConstant()); found = true; } } if (!found) { out.format("No matching fields%n"); } // production code should handle this exception more gracefully } catch (ClassNotFoundException x) { x.printStackTrace(); } }
/** * 将RyJbxx转换为xml格式的字符串 * * @param head XML的头名字<head>..</head> * @return 返回XML字符串 * @throws Exception */ public static String toXml(String head, ConsructionHeadVO headVo, Consruction1104RequestVO rj) throws Exception { StringBuffer sb = new StringBuffer(); Field[] field = rj.getClass().getDeclaredFields(); String ENDL = "\n"; String TABLE = "\t"; String name = ""; for (int i = 0; i < field.length; i++) { // 跳过表态属性 String mod = Modifier.toString(field[i].getModifiers()); if (mod.indexOf("static") != -1) { continue; } name = TEST.FirstStringToUpperCase(field[i].getName()); Method m = rj.getClass().getMethod("get" + name); String value = (String) m.invoke(rj); // 构造XML sb.append(TABLE) .append("<") .append(name) .append(">") .append(value) .append("</") .append(name) .append(">") .append(ENDL); } return "<" + head + ">" + sb.toString() + "</" + head + ">"; }
protected void formatName(StringBuilder formatted) { if (modifiers != 0) { formatted.append(Modifier.toString(modifiers)).append(" "); } formatted.append(returntype.getSimpleName()).append(" "); formatted.append(methodname); }
public static void main(String[] args) { // read class name from command line args or user input String name; if (args.length > 0) name = args[0]; else { Scanner in = new Scanner(System.in); System.out.println("Enter class name (e.g. java.util.Date): "); name = in.next(); } try { // print class name and superclass name (if != Object) Class cl = Class.forName(name); Class supercl = cl.getSuperclass(); String modifiers = Modifier.toString(cl.getModifiers()); if (modifiers.length() > 0) System.out.print(modifiers + " "); System.out.print("class " + name); if (supercl != null && supercl != Object.class) System.out.print(" extends " + supercl.getName()); System.out.print("\n{\n"); printConstructors(cl); System.out.println(); printMethods(cl); System.out.println(); printFields(cl); System.out.println("}"); } catch (ClassNotFoundException e) { e.printStackTrace(); } System.exit(0); }
/** * Returns a string containing a concise, human-readable description of this method. The format of * the string is: * * <ol> * <li>modifiers (if any) * <li>return type or 'void' * <li>declaring class name * <li>'(' * <li>parameter types, separated by ',' (if any) * <li>')' * <li>'throws' plus exception types, separated by ',' (if any) * </ol> * * For example: {@code public native Object java.lang.Method.invoke(Object,Object) throws * IllegalAccessException,IllegalArgumentException ,InvocationTargetException} * * @return a printable representation for this method */ @Override public String toString() { Class<?> returnType = getReturnType(); Class<?> declaringClass = getDeclaringClass(); String name = getName(); Class<?>[] parameterTypes = getParameterTypes(false); Class<?>[] exceptionTypes = getExceptionTypes(false); StringBuilder result = new StringBuilder(Modifier.toString(getModifiers())); if (result.length() != 0) result.append(' '); appendTypeName(result, returnType); result.append(' '); result.append(declaringClass.getName()); result.append('.'); result.append(name); result.append("("); result.append(toString(parameterTypes)); result.append(")"); if (exceptionTypes != null && exceptionTypes.length != 0) { result.append(" throws "); result.append(toString(exceptionTypes)); } return result.toString(); }
public static void main(String[] args) { String name; if (args.length > 0) { name = args[0]; } else { Scanner in = new Scanner(System.in); System.out.println("Enter class name (e.g. java.util.Date ):)"); name = in.next(); } try { Class<?> aClass = Class.forName(name); Class<?> superclass = aClass.getSuperclass(); String modifiers = Modifier.toString(aClass.getModifiers()); if (modifiers.length() > 0) { System.out.print(modifiers + " "); } System.out.print("class " + name); if (superclass != null && superclass != Object.class) { System.out.print(" extends " + superclass.getName()); } System.out.print("\n{\n"); printConstructors(aClass); System.out.println(); printMethods(aClass); System.out.println(); printFields(aClass); System.out.println("}"); } catch (ClassNotFoundException e) { e.printStackTrace(); } System.exit(0); }
public void generate(JNIField field) { String name = field.getName(); Enumeration keys = files.keys(); while (keys.hasMoreElements()) { Object key = keys.nextElement(); String str = (String) files.get(key); if (str.indexOf(name) != -1) { int modifiers = field.getModifiers(); String modifiersStr = Modifier.toString(modifiers); output("\t"); output(modifiersStr); if (modifiersStr.length() > 0) output(" "); output(field.getType().getTypeSignature3(false)); output(" "); output(field.getName()); output(" = "); output(getFieldValue(field)); outputln(";"); usedCount++; return; } } unusedCount++; // output("NOT USED=" + field.toString() + " \n"); }
public void dumpDeclaration( TabbedPrintWriter writer, ProgressListener pl, double done, double scale) throws IOException { if (fields == null) { /* This means that the class could not be loaded. * give up. */ return; } writer.startOp(writer.NO_PAREN, 0); /* Clear the SUPER bit, which is also used as SYNCHRONIZED bit. */ int modifiedModifiers = modifiers & ~(Modifier.SYNCHRONIZED | STRICTFP); if (clazz.isInterface()) /* interfaces are implicitily abstract */ modifiedModifiers &= ~Modifier.ABSTRACT; if (parent instanceof MethodAnalyzer) { /* method scope classes are implicitly private */ modifiedModifiers &= ~Modifier.PRIVATE; /* anonymous classes are implicitly final */ if (name == null) modifiedModifiers &= ~Modifier.FINAL; } String modif = Modifier.toString(modifiedModifiers); if (modif.length() > 0) writer.print(modif + " "); if (isStrictFP()) { /* The STRICTFP modifier is set. * We handle it, since java.lang.reflect.Modifier is too dumb. */ writer.print("strictfp "); } /* interface is in modif */ if (!clazz.isInterface()) writer.print("class "); writer.print(name); ClassInfo superClazz = clazz.getSuperclass(); if (superClazz != null && superClazz != ClassInfo.javaLangObject) { writer.breakOp(); writer.print(" extends " + (writer.getClassString(superClazz, Scope.CLASSNAME))); } ClassInfo[] interfaces = clazz.getInterfaces(); if (interfaces.length > 0) { writer.breakOp(); writer.print(clazz.isInterface() ? " extends " : " implements "); writer.startOp(writer.EXPL_PAREN, 1); for (int i = 0; i < interfaces.length; i++) { if (i > 0) { writer.print(", "); writer.breakOp(); } writer.print(writer.getClassString(interfaces[i], Scope.CLASSNAME)); } writer.endOp(); } writer.println(); writer.openBraceClass(); writer.tab(); dumpBlock(writer, pl, done, scale); writer.untab(); writer.closeBraceClass(); }
/** * append the modifier's source representation to the writer; return true if any source was * actually written to the writer (it is possible that no source was written out); this return * value allows callers to know whether to append a space if necessary */ boolean writeSource(PrintWriter pw) { String source = Modifier.toString(this.code); if (source.length() == 0) { return false; } pw.print(source); return true; }
public ClassBuffer createLocalClass(final String classDef) { final ClassBuffer cls = new ClassBuffer(context, indent); cls.setDefinition(classDef, classDef.trim().endsWith("{")); assert cls.privacy == 0 : "A local class cannot be " + Modifier.toString(cls.privacy); addToEnd(cls); setNotIndent(); return cls; }
public String toString() { return Modifier.toString(modifiers) + "(" + Integer.toHexString(modifiers) + ") " + name() + signature(); }
@Override public void visit(ConstructorDeclaration n, Object arg) { Set<String> consParaSet = new HashSet<String>(); List<String> consParalist = new ArrayList<String>(); currentConstructorMeta = new ConstructorMeta(); currentConstructorMeta.constructorName = n.getName(); currentConstructorMeta.constructorModifier = Modifier.toString(n.getModifiers()); if (n.getParameters() != null) { for (int i = 0; i < n.getParameters().size(); i++) { String consPara = n.getParameters().get(i).toString(); consParalist.add(consPara); String[] strings = consPara.split(" "); String consParaKey = currentConstructorMeta.constructorName; if (MapAndSet.constructorMap.containsKey(consParaKey)) { MapAndSet.constructorMap.get(consParaKey).add(consPara); MapAndSet.constructorMap.put(consParaKey, consParaSet); } else { consParaSet.add(consPara); MapAndSet.constructorMap.put(consParaKey, consParaSet); } String usesOrInterfaceKey = strings[0] + "," + currentConstructorMeta.constructorName; if (MapAndSet.usesMap.containsKey(usesOrInterfaceKey)) { // MapAndSet.usesOrInterfaceValue = // MapAndSet.usesMap.get(usesOrInterfaceKey); // MapAndSet.usesOrInterfaceValue = // MapAndSet.arrowsUpdate(MapAndSet.usesOrInterfaceValue, Arrows.uses.toString()); // MapAndSet.usesOrInterfaceMap.put(usesOrInterfaceKey, // MapAndSet.usesOrInterfaceValue); } else if (!MapAndSet.usesMap.containsKey(usesOrInterfaceKey)) { MapAndSet.usesMap.put(usesOrInterfaceKey, Arrows.uses.toString()); } } currentConstructorMeta.parameterList = consParalist; currentMeta.constructorMetas.add(currentConstructorMeta); } else { System.out.println("to check the ecnomy"); currentMeta.constructorMetas.add(currentConstructorMeta); } MapAndSet.classMetaMap.put(MapAndSet.className, currentMeta); }
public static int toString____Ljava_lang_String_2(MJIEnv env, int objRef) { StringBuilder sb = new StringBuilder(); FieldInfo fi = getFieldInfo(env, objRef); sb.append(Modifier.toString(fi.getModifiers())); sb.append(' '); sb.append(fi.getType()); sb.append(' '); sb.append(fi.getFullName()); int sref = env.newString(sb.toString()); return sref; }
public String getQualifiedName() { StringWriter sbuf = new StringWriter(); sbuf.write(Modifier.toString(getModifiers())); sbuf.write(' '); sbuf.write(getType().getQualifiedName()); sbuf.write(' '); sbuf.write(getContainingClass().getQualifiedName()); sbuf.write('.'); sbuf.write(getSimpleName()); return sbuf.toString(); }
private Method findMethod(Class<?> clz, Object[] args) throws LocalRunException { if (args == null || args.length == 0) { throw new LocalRunException("Input data can't be null"); } Method method = ClassUtils.findMethod(clz, "evaluate", args); // method "evaluate" can't be static if (Modifier.toString(method.getModifiers()).contains("static")) { throw new LocalRunException("'evaluate' method can't be static"); } return method; }
/** * Prints all fields of a class * * @param cl a class */ public static void printFields(Class cl) { Field[] fields = cl.getDeclaredFields(); for (Field f : fields) { Class type = f.getType(); String name = f.getName(); System.out.print(" "); String modifiers = Modifier.toString(f.getModifiers()); if (modifiers.length() > 0) System.out.print(modifiers + " "); System.out.println(type.getName() + " " + name + ";"); } }
protected IValueList parseModifiers(int modifiers) { IValueList extendedModifierList = new IValueList(values); for (String constructor : java.lang.reflect.Modifier.toString(modifiers).split(" ")) { Set<org.rascalmpl.value.type.Type> exConstr = typeStore.lookupConstructor(DATATYPE_RASCAL_AST_MODIFIER_NODE_TYPE, constructor); for (org.rascalmpl.value.type.Type con : exConstr) { extendedModifierList.add(values.constructor(con)); } } return extendedModifierList; }
private static void printFields(Class<?> aClass) { Field[] fields = aClass.getDeclaredFields(); for (Field field : fields) { String name = field.getName(); Class<?> type = field.getType(); System.out.print(" "); String s = Modifier.toString(field.getModifiers()); if (s.length() > 0) { System.out.print(s + " "); } System.out.print(type.getName() + " " + name + ";"); System.out.println(); } }
public static void main(String... args) { try { Class<?> c = Class.forName(args[0]); out.format("Class:%n %s%n%n", c.getCanonicalName()); out.format("Modifiers:%n %s%n%n", Modifier.toString(c.getModifiers())); out.format("Type Parameters:%n"); TypeVariable<?>[] tv = c.getTypeParameters(); if (tv.length != 0) { out.format(" "); for (TypeVariable<?> t : tv) out.format("%s ", t.getName()); out.format("%n%n"); } else { out.format(" -- No Type Parameters --%n%n"); } out.format("Implemented Interfaces:%n"); Type[] intfs = c.getGenericInterfaces(); if (intfs.length != 0) { for (Type intf : intfs) out.format(" %s%n", intf.toString()); out.format("%n"); } else { out.format(" -- No Implemented Interfaces --%n%n"); } out.format("Inheritance Path:%n"); List<Class<?>> l = new ArrayList<Class<?>>(); printAncestor(c, l); if (l.size() != 0) { for (Class<?> cl : l) out.format(" %s%n", cl.getCanonicalName()); out.format("%n"); } else { out.format(" -- No Super Classes --%n%n"); } out.format("Annotations:%n"); Annotation[] ann = c.getAnnotations(); if (ann.length != 0) { for (Annotation a : ann) out.format(" %s%n", a.toString()); out.format("%n"); } else { out.format(" -- No Annotations --%n%n"); } // production code should handle this exception more gracefully } catch (ClassNotFoundException x) { x.printStackTrace(); } }
protected static final Map<String, Method> scanMethod(Class o) { Map<String, Method> objAnnotation = new HashMap<String, Method>(); Method[] M = o.getDeclaredMethods(); for (Method m : M) { String ax = String.format( "%s %s %s(%s);", Modifier.toString(m.getModifiers()), m.getReturnType().getName(), m.getName(), Util.getParameterTypes(m.getParameterTypes())); System.out.println(ax); } return objAnnotation; }
public static void main(String[] args) throws JClassAlreadyExistsException, IOException { JCodeModel codeModel = new JCodeModel(); Class template = AbstractBaseWrapper.class; String packageName = template.getPackage().getName(); String className = template.getSimpleName().replace("Abstract", "") + "Impl"; JPackage generatedPackage = codeModel._package(packageName); JDefinedClass generatedClass = generatedPackage._class(JMod.FINAL, className); // Creates // a // new // class generatedClass._extends(template); for (Method method : template.getMethods()) { if (Modifier.isAbstract(method.getModifiers())) { System.out.println( "Found abstract method " + Modifier.toString(method.getModifiers()) + " " + method.getName()); JMethod generatedMethod = generatedClass.method(JMod.PUBLIC, method.getReturnType(), method.getName()); for (Parameter parameter : method.getParameters()) { generatedMethod.param(parameter.getModifiers(), parameter.getType(), parameter.getName()); } if (method.getReturnType().equals(Void.TYPE)) { generatedMethod.body().add(generateInvocation(method)); } else { generatedMethod.body()._return(generateInvocation(method)); } } } ByteArrayOutputStream out = new ByteArrayOutputStream(); codeModel.build(new SingleStreamCodeWriter(out)); System.out.println(out); }
public MethodVisitor visitMethod( int access, String name, String desc, String signature, String[] exceptions) { pn(""); pn("; -------------------------------------------------------------"); p(".method "); p(Modifier.toString(access)); p(" "); p(name); pn(desc); pn("; signature = " + signature); pn("; -------------------------------------------------------------\n"); if (exceptions != null) { for (int i = 0; i < exceptions.length; i++) { p(".throws "); pn(exceptions[i]); } } return new DumpMethodVisitor(); }
/** * Prints all constructors of a class * * @param cl a class */ public static void printConstructors(Class cl) { Constructor[] constructors = cl.getDeclaredConstructors(); for (Constructor c : constructors) { String name = c.getName(); System.out.print(" "); String modifiers = Modifier.toString(c.getModifiers()); if (modifiers.length() > 0) System.out.print(modifiers + " "); System.out.print(name + "("); // print parameter types Class[] paramTypes = c.getParameterTypes(); for (int j = 0; j < paramTypes.length; j++) { if (j > 0) System.out.print(", "); System.out.print(paramTypes[j].getName()); } System.out.println(");"); } }
public void visit( int version, int access, String name, String signature, String superName, String[] interfaces) { p(".class "); p(Modifier.toString(access)); p(" "); pn(name); if (superName != null) pn(".super " + superName); if (interfaces != null) { for (int i = 0; i < interfaces.length; i++) { p(".implements "); pn(interfaces[i]); } } }
private static void printConstructors(Class<?> aClass) { Constructor<?>[] constructors = aClass.getDeclaredConstructors(); for (Constructor<?> constructor : constructors) { String name = constructor.getName(); System.out.print(" "); String modifiers = Modifier.toString(aClass.getModifiers()); if (modifiers.length() > 0) { System.out.print(modifiers + " "); } System.out.print(name + "("); Class<?>[] parameterTypes = constructor.getParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { if (i > 0) { System.out.print(", "); } System.out.print(parameterTypes[i].getName()); } System.out.println(");"); } }
public FieldVisitor visitField( int access, String name, String desc, String signature, Object value) { p(".field "); p(Modifier.toString(access)); p(" "); p(name); p(" "); p(desc); if (value != null) { p(" = "); if (value instanceof String) { pn("\"" + value + "\""); } else { pn(value.toString()); } } else { pn(); } return null; }
private static void printMethods(Class<?> aClass) { Method[] methods = aClass.getDeclaredMethods(); for (Method method : methods) { String name = method.getName(); Class<?> returnType = method.getReturnType(); System.out.print(" "); String modifiers = Modifier.toString(method.getModifiers()); if (modifiers.length() > 0) { System.out.print(modifiers + " "); } System.out.print(returnType + " " + name + "("); Class<?>[] parameterTypes = method.getParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { if (i > 0) { System.out.print(", "); } System.out.print(parameterTypes[i].getName()); } System.out.println(");"); } }