List of usage examples for java.lang.reflect Modifier isAbstract
public static boolean isAbstract(int mod)
From source file:ca.sqlpower.object.annotation.SPAnnotationProcessor.java
/** * Generates and returns source code for a commitProperty method based on * setter methods annotated with {@link Mutator} used in a given * {@link SPObject} class. The purpose of this commitProperty method is to * allow a session {@link SPPersister} to commit a persisted property change * into an {@link SPSession}. This helper method will be called by the * session {@link SPPersister#commit()} method. * /* w w w .j a v a 2 s. c om*/ * @param visitedClass * The {@link SPObject} class that is being visited by the * annotation processor. * @param setters * The {@link Map} of property setter methods to their property * types that can be used by an {@link SPPersister} to persist * properties into an {@link SPSession}. * @param mutatorExtraParameters * The {@link Multimap} of setter methods mapped to each of its * extra parameters (second parameter and onwards). * @param mutatorThrownTypes * The {@link Multimap} of property setter methods to their * thrown exceptions. * @param tabs * The number of tab characters to use to indent this generated * method block. * @return The source code for the generated commitProperty method. * @see SPPersister#persistProperty(String, String, * ca.sqlpower.dao.SPPersister.DataType, Object) * @see SPPersister#commit() */ private String generateCommitPropertyMethod(Class<? extends SPObject> visitedClass, Map<String, Class<?>> setters, Multimap<String, MutatorParameterObject> mutatorExtraParameters, Multimap<String, Class<? extends Exception>> mutatorThrownTypes, int tabs) { StringBuilder sb = new StringBuilder(); final String genericObjectField = "o"; final String objectField = "castedObject"; final String propertyNameField = "propertyName"; final String newValueField = "newValue"; final String converterField = "converter"; final String exceptionField = "e"; final String dataTypeField = "dataType"; boolean firstIf = true; // commitProperty method header. // public void commitProperty( // SPObject o, // String propertyName, // Object newValue, // DataType dataType, // SessionPersisterSuperConverter converter) // throws SPPersistenceException { println(sb, tabs, String.format("public void %s(%s %s, %s %s, %s %s, %s %s, %s %s) throws %s {", COMMIT_PROPERTY_METHOD_NAME, SPObject.class.getSimpleName(), genericObjectField, String.class.getSimpleName(), propertyNameField, Object.class.getSimpleName(), newValueField, DataType.class.getSimpleName(), dataTypeField, SessionPersisterSuperConverter.class.getSimpleName(), converterField, SPPersistenceException.class.getSimpleName())); tabs++; if (!setters.isEmpty()) { // If the SPObject class this persister helper handles is abstract, // use the type generic defined in the class header. // Otherwise, use the SPObject class directly. if (Modifier.isAbstract(visitedClass.getModifiers())) { // T castedObject = (T) o; println(sb, tabs, String.format("%s %s = (%s) %s;", TYPE_GENERIC_PARAMETER, objectField, TYPE_GENERIC_PARAMETER, genericObjectField)); } else { // <visitedClass> castedObject = (<visitedClass>) o; println(sb, tabs, String.format("%s %s = (%s) %s;", visitedClass.getSimpleName(), objectField, visitedClass.getSimpleName(), genericObjectField)); } // Search for the matching property name and set the value. for (Entry<String, Class<?>> e : setters.entrySet()) { String methodName = e.getKey(); Class<?> type = e.getValue(); print(sb, tabs, ""); if (!firstIf) { niprint(sb, "} else "); } // if (propertyName.equals("<method to property name>") { niprintln(sb, String.format("if (%s.equals(\"%s\")) {", propertyNameField, SPAnnotationProcessorUtils.convertMethodToProperty(methodName))); tabs++; boolean throwsExceptions = mutatorThrownTypes.containsKey(e.getKey()); if (throwsExceptions) { println(sb, tabs, "try {"); tabs++; } // Assign each extra argument value of setter methods to variables // to pass into the call to the setter afterwards. for (MutatorParameterObject extraParam : mutatorExtraParameters.get(methodName)) { // <extraParam type> <extraParam name> = // <extraParam type>.valueOf("<extraParam name>"); println(sb, tabs, String.format("%s %s = %s.valueOf(\"%s\");", extraParam.getType().getSimpleName(), extraParam.getName(), extraParam.getType().getSimpleName(), extraParam.getValue())); } // Pass in the actual property value as the first argument to the setter. String conversionType; if (type == Object.class) { conversionType = dataTypeField + ".getRepresentation()"; } else { conversionType = type.getSimpleName() + ".class"; } // castedObject.<setter>( // (<type>) converter.convertToComplexType( // newValue, <dataType.getRepresentation | type.class>); print(sb, tabs, String.format("%s.%s((%s) %s.%s(%s, %s)", objectField, methodName, type.getSimpleName(), converterField, CONVERT_TO_COMPLEX_TYPE_METHOD_NAME, newValueField, conversionType)); // Pass in the variables holding the extra argument values. for (MutatorParameterObject extraParam : mutatorExtraParameters.get(methodName)) { // , <extraParam name> niprint(sb, ", " + extraParam.getName()); } niprintln(sb, ");"); tabs--; // Catch any exceptions that the setter throws. if (throwsExceptions) { for (Class<? extends Exception> thrownType : mutatorThrownTypes.get(methodName)) { // } catch (<Exception type> e) { println(sb, tabs, String.format("} catch (%s %s) {", thrownType.getSimpleName(), exceptionField)); tabs++; // throw new SPPersistenceException( // castedObject.getUUID(), // createSPPersistenceExceptionMessage( // castedObject, // propertyName), // e); println(sb, tabs, String.format("throw new %s(%s.%s(), %s(%s, %s), %s);", SPPersistenceException.class.getSimpleName(), objectField, GET_UUID_METHOD_NAME, CREATE_EXCEPTION_MESSAGE_METHOD_NAME, objectField, propertyNameField, exceptionField)); tabs--; } println(sb, tabs, "}"); tabs--; } firstIf = false; } if (!firstIf) { println(sb, tabs, "} else {"); tabs++; } } if (SPObject.class.isAssignableFrom(visitedClass.getSuperclass())) { // super.commitProperty(o, <property>, newValue, dataType, converter); println(sb, tabs, String.format("super.%s(%s, %s, %s, %s, %s);", COMMIT_PROPERTY_METHOD_NAME, genericObjectField, propertyNameField, newValueField, dataTypeField, converterField)); } else { // Throw an SPPersistenceException if the property is not persistable or unrecognized. // throw new SPPersistenceException( // castedObject.getUUID(), // createSPPersistenceExceptionMessage( // castedObject, // propertyName)); println(sb, tabs, String.format("throw new %s(%s.%s(), %s(%s, %s));", SPPersistenceException.class.getSimpleName(), objectField, GET_UUID_METHOD_NAME, CREATE_EXCEPTION_MESSAGE_METHOD_NAME, objectField, propertyNameField)); } if (!firstIf) { tabs--; println(sb, tabs, "}"); } tabs--; println(sb, tabs, "}"); return sb.toString(); }
From source file:org.apache.openjpa.kernel.BrokerImpl.java
public Object newObjectId(Class<?> cls, Object val) { if (val == null) return null; beginOperation(false);//from w w w . jav a 2s. com try { ClassMetaData meta = _repo.getMetaData(cls, _loader, true); switch (meta.getIdentityType()) { case ClassMetaData.ID_DATASTORE: // delegate to store manager for datastore ids if (val instanceof String && ((String) val).startsWith(StateManagerId.STRING_PREFIX)) return new StateManagerId((String) val); return _store.newDataStoreId(val, meta); case ClassMetaData.ID_APPLICATION: if (ImplHelper.isAssignable(meta.getObjectIdType(), val.getClass())) { if (!meta.isOpenJPAIdentity() && meta.isObjectIdTypeShared()) return new ObjectId(cls, val); return val; } // stringified app id? if (val instanceof String && !_conf.getCompatibilityInstance().getStrictIdentityValues() && !Modifier.isAbstract(cls.getModifiers())) return PCRegistry.newObjectId(cls, (String) val); Object[] arr = (val instanceof Object[]) ? (Object[]) val : new Object[] { val }; return ApplicationIds.fromPKValues(arr, meta); default: throw new UserException(_loc.get("meta-unknownid", cls)); } } catch (IllegalArgumentException iae) { // OPENJPA-365 throw new UserException(_loc.get("bad-id-value", val, val.getClass().getName(), cls)).setCause(iae); } catch (OpenJPAException ke) { throw ke; } catch (ClassCastException cce) { throw new UserException(_loc.get("bad-id-value", val, val.getClass().getName(), cls)).setCause(cce); } catch (RuntimeException re) { throw new GeneralException(re); } finally { endOperation(); } }
From source file:ca.oson.json.Oson.java
private boolean ignoreModifiers(int modifiers, Set<MODIFIER> includeFieldsWithModifiers) { //Set<MODIFIER> includeFieldsWithModifiers = getIncludeFieldsWithModifiers(); if (includeFieldsWithModifiers == null || includeFieldsWithModifiers.size() == 0) { // by default, transient and volatile are ignored // unless you specify otherwise, by using MODIFIER.Transient enum, or all if (Modifier.isTransient(modifiers)) { return true; }//w w w. j a va 2 s . c om if (Modifier.isVolatile(modifiers)) { return true; } return false; } if (includeFieldsWithModifiers.contains(MODIFIER.All)) { return false; } for (MODIFIER modifier : includeFieldsWithModifiers) { switch (modifier) { case Abstract: if (Modifier.isAbstract(modifiers)) { return false; } break; case Final: if (Modifier.isFinal(modifiers)) { return false; } break; case Interface: if (Modifier.isInterface(modifiers)) { return false; } break; case Native: if (Modifier.isNative(modifiers)) { return false; } break; case Private: if (Modifier.isPrivate(modifiers)) { return false; } break; case Protected: if (Modifier.isProtected(modifiers)) { return false; } break; case Public: if (Modifier.isPublic(modifiers)) { return false; } break; case Package: if (ObjectUtil.isPackage(modifiers)) { return false; } break; case Static: if (Modifier.isStatic(modifiers)) { return false; } break; case Strict: if (Modifier.isStrict(modifiers)) { return false; } break; case Synchronized: if (Modifier.isSynchronized(modifiers)) { return false; } break; case Transient: if (Modifier.isTransient(modifiers)) { return false; } break; case Volatile: if (Modifier.isVolatile(modifiers)) { return false; } break; } } return true; }
From source file:com.github.wshackle.java4cpp.J4CppMain.java
public static void main(String[] args) throws IOException, ClassNotFoundException { main_completed = false;//from w w w . j a va2 s . c om Options options = new Options(); options.addOption(Option.builder("?").desc("Print this message").longOpt("help").build()); options.addOption(Option.builder("n").hasArg().desc("C++ namespace for newly generated classes.") .longOpt("namespace").build()); options.addOption( Option.builder("c").hasArgs().desc("Single Java class to extract.").longOpt("classes").build()); options.addOption( Option.builder("p").hasArgs().desc("Java Package prefix to extract").longOpt("packages").build()); options.addOption(Option.builder("o").hasArg().desc("Output C++ source file.").longOpt("output").build()); options.addOption(Option.builder("j").hasArg().desc("Input jar file").longOpt("jar").build()); options.addOption(Option.builder("h").hasArg().desc("Output C++ header file.").longOpt("header").build()); options.addOption(Option.builder("l").hasArg() .desc("Maximum limit on classes to extract from jars.[default=200]").longOpt("limit").build()); options.addOption(Option.builder("v").desc("enable verbose output").longOpt("verbose").build()); options.addOption(Option.builder().hasArg().desc("Classes per output file.[default=10]") .longOpt(CLASSESPEROUTPUT).build()); options.addOption(Option.builder().hasArgs().desc( "Comma seperated list of nativeclass=javaclass native where nativeclass will be generated as an extension/implementation of the java class.") .longOpt("natives").build()); options.addOption(Option.builder().hasArg() .desc("library name for System.loadLibrary(...) for native extension classes") .longOpt("loadlibname").build()); String output = null; String header = null; String jar = null; Set<String> classnamesToFind = null; Set<String> packageprefixes = null; String loadlibname = null; Map<String, String> nativesNameMap = null; Map<String, Class> nativesClassMap = null; int limit = DEFAULT_LIMIT; int classes_per_file = 10; List<Class> classes = new ArrayList<>(); String limitstring = Integer.toString(limit); try { // parse the command line arguments System.out.println("args = " + Arrays.toString(args)); CommandLine line = new DefaultParser().parse(options, args); loadlibname = line.getOptionValue("loadlibname"); verbose = line.hasOption("verbose"); if (line.hasOption(CLASSESPEROUTPUT)) { String cpoStr = line.getOptionValue(CLASSESPEROUTPUT); try { int cpoI = Integer.valueOf(cpoStr); classes_per_file = cpoI; } catch (Exception e) { System.err.println("Option for " + CLASSESPEROUTPUT + "=\"" + cpoStr + "\""); printHelpAndExit(options, args); } } if (line.hasOption("natives")) { String natives[] = line.getOptionValues("natives"); if (verbose) { System.out.println("natives = " + Arrays.toString(natives)); } nativesNameMap = new HashMap<>(); nativesClassMap = new HashMap<>(); for (int i = 0; i < natives.length; i++) { int eq_index = natives[i].indexOf('='); String nativeClassName = natives[i].substring(0, eq_index).trim(); String javaClassName = natives[i].substring(eq_index + 1).trim(); Class javaClass = null; try { javaClass = Class.forName(javaClassName); } catch (ClassNotFoundException e) { //e.printStackTrace(); System.err.println("Class for " + javaClassName + " not found. (It may be found later in jar if specified.)"); } nativesNameMap.put(javaClassName, nativeClassName); if (javaClass != null) { nativesClassMap.put(nativeClassName, javaClass); if (!classes.contains(javaClass)) { classes.add(javaClass); } } } } // // validate that block-size has been set // if (line.hasOption("block-size")) { // // print the value of block-size // if(verbose) System.out.println(line.getOptionValue("block-size")); // } jar = line.getOptionValue("jar", jar); if (verbose) { System.out.println("jar = " + jar); } if (null != jar) { if (jar.startsWith("~/")) { jar = new File(new File(getHomeDir()), jar.substring(2)).getCanonicalPath(); } if (jar.startsWith("./")) { jar = new File(new File(getCurrentDir()), jar.substring(2)).getCanonicalPath(); } if (jar.startsWith("../")) { jar = new File(new File(getCurrentDir()).getParentFile(), jar.substring(3)).getCanonicalPath(); } } if (line.hasOption("classes")) { classnamesToFind = new HashSet<String>(); String classStrings[] = line.getOptionValues("classes"); if (verbose) { System.out.println("classStrings = " + Arrays.toString(classStrings)); } classnamesToFind.addAll(Arrays.asList(classStrings)); if (verbose) { System.out.println("classnamesToFind = " + classnamesToFind); } } // if (!line.hasOption("namespace")) { // if (classname != null && classname.length() > 0) { // namespace = classname.toLowerCase().replace(".", "_"); // } else if (jar != null && jar.length() > 0) { // int lastSep = jar.lastIndexOf(File.separator); // int start = Math.max(0, lastSep + 1); // int period = jar.indexOf('.', start + 1); // int end = Math.max(start + 1, period); // namespace = jar.substring(start, end).toLowerCase(); // namespace = namespace.replace(" ", "_"); // if (namespace.indexOf("-") > 0) { // namespace = namespace.substring(0, namespace.indexOf("-")); // } // } // } namespace = line.getOptionValue("namespace", namespace); if (verbose) { System.out.println("namespace = " + namespace); } if (null != namespace) { output = namespace + ".cpp"; } output = line.getOptionValue("output", output); if (verbose) { System.out.println("output = " + output); } if (null != output) { if (output.startsWith("~/")) { output = System.getProperty("user.home") + output.substring(1); } header = output.substring(0, output.lastIndexOf('.')) + ".h"; } else { output = "out.cpp"; } header = line.getOptionValue("header", header); if (verbose) { System.out.println("header = " + header); } if (null != header) { if (header.startsWith("~/")) { header = System.getProperty("user.home") + header.substring(1); } } else { header = "out.h"; } if (line.hasOption("packages")) { packageprefixes = new HashSet<String>(); packageprefixes.addAll(Arrays.asList(line.getOptionValues("packages"))); } if (line.hasOption("limit")) { limitstring = line.getOptionValue("limit", Integer.toString(DEFAULT_LIMIT)); limit = Integer.valueOf(limitstring); } if (line.hasOption("help")) { printHelpAndExit(options, args); } } catch (ParseException exp) { if (verbose) { System.out.println("Unexpected exception:" + exp.getMessage()); } printHelpAndExit(options, args); } Set<Class> excludedClasses = new HashSet<>(); Set<String> foundClassNames = new HashSet<>(); excludedClasses.add(Object.class); excludedClasses.add(String.class); excludedClasses.add(void.class); excludedClasses.add(Void.class); excludedClasses.add(Class.class); excludedClasses.add(Enum.class); Set<String> packagesSet = new TreeSet<>(); List<URL> urlsList = new ArrayList<>(); String cp = System.getProperty("java.class.path"); if (verbose) { System.out.println("System.getProperty(\"java.class.path\") = " + cp); } if (null != cp) { for (String cpe : cp.split(File.pathSeparator)) { if (verbose) { System.out.println("class path element = " + cpe); } File f = new File(cpe); if (f.isDirectory()) { urlsList.add(new URL("file:" + f.getCanonicalPath() + File.separator)); } else if (cpe.endsWith(".jar")) { urlsList.add(new URL("jar:file:" + f.getCanonicalPath() + "!/")); } } } cp = System.getenv("CLASSPATH"); if (verbose) { System.out.println("System.getenv(\"CLASSPATH\") = " + cp); } if (null != cp) { for (String cpe : cp.split(File.pathSeparator)) { if (verbose) { System.out.println("class path element = " + cpe); } File f = new File(cpe); if (f.isDirectory()) { urlsList.add(new URL("file:" + f.getCanonicalPath() + File.separator)); } else if (cpe.endsWith(".jar")) { urlsList.add(new URL("jar:file:" + f.getCanonicalPath() + "!/")); } } } if (verbose) { System.out.println("urlsList = " + urlsList); } if (null != jar && jar.length() > 0) { Path jarPath = FileSystems.getDefault().getPath(jar); ZipInputStream zip = new ZipInputStream(Files.newInputStream(jarPath, StandardOpenOption.READ)); URL jarUrl = new URL("jar:file:" + jarPath.toFile().getCanonicalPath() + "!/"); urlsList.add(jarUrl); URL[] urls = urlsList.toArray(new URL[urlsList.size()]); if (verbose) { System.out.println("urls = " + Arrays.toString(urls)); } URLClassLoader cl = URLClassLoader.newInstance(urls); for (ZipEntry entry = zip.getNextEntry(); entry != null; entry = zip.getNextEntry()) { // This ZipEntry represents a class. Now, what class does it represent? String entryName = entry.getName(); if (verbose) { System.out.println("entryName = " + entryName); } if (!entry.isDirectory() && entryName.endsWith(".class")) { if (entryName.indexOf('$') >= 0) { continue; } String classFileName = entry.getName().replace('/', '.'); String className = classFileName.substring(0, classFileName.length() - ".class".length()); if (classnamesToFind != null && classnamesToFind.size() > 0 && !classnamesToFind.contains(className)) { if (verbose) { System.out.println("skipping className=" + className + " because it does not found in=" + classnamesToFind); } continue; } try { Class clss = cl.loadClass(className); if (null != nativesClassMap && null != nativesNameMap && nativesNameMap.containsKey(className)) { nativesClassMap.put(nativesNameMap.get(className), clss); if (!classes.contains(clss)) { classes.add(clss); } } if (packageprefixes != null && packageprefixes.size() > 0) { if (null == clss.getPackage()) { continue; } final String pkgName = clss.getPackage().getName(); boolean matchFound = false; for (String prefix : packageprefixes) { if (pkgName.startsWith(prefix)) { matchFound = true; break; } } if (!matchFound) { continue; } } Package p = clss.getPackage(); if (null != p) { packagesSet.add(clss.getPackage().getName()); } if (!classes.contains(clss) && isAddableClass(clss, excludedClasses)) { if (null != classnamesToFind && classnamesToFind.contains(className) && !foundClassNames.contains(className)) { foundClassNames.add(className); if (verbose) { System.out.println("foundClassNames = " + foundClassNames); } } // if(verbose) System.out.println("clss = " + clss); classes.add(clss); // Class superClass = clss.getSuperclass(); // while (null != superClass // && !classes.contains(superClass) // && isAddableClass(superClass, excludedClasses)) { // classes.add(superClass); // superClass = superClass.getSuperclass(); // } } } catch (ClassNotFoundException | NoClassDefFoundError ex) { System.err.println( "Caught " + ex.getClass().getName() + ":" + ex.getMessage() + " for className=" + className + ", entryName=" + entryName + ", jarPath=" + jarPath); } } } } if (null != classnamesToFind) { if (verbose) { System.out.println("Checking classnames arguments"); } for (String classname : classnamesToFind) { if (verbose) { System.out.println("classname = " + classname); } if (foundClassNames.contains(classname)) { if (verbose) { System.out.println("foundClassNames.contains(" + classname + ")"); } continue; } try { if (classes.contains(Class.forName(classname))) { if (verbose) { System.out.println("Classes list already contains: " + classname); } continue; } } catch (Exception e) { } if (null != classname && classname.length() > 0) { urlsList.add(new URL("file://" + System.getProperty("user.dir") + "/")); URL[] urls = urlsList.toArray(new URL[urlsList.size()]); if (verbose) { System.out.println("urls = " + Arrays.toString(urls)); } URLClassLoader cl = URLClassLoader.newInstance(urls); Class c = null; try { c = cl.loadClass(classname); } catch (ClassNotFoundException e) { System.err.println("Class " + classname + " not found "); } if (verbose) { System.out.println("c = " + c); } if (null == c) { try { c = ClassLoader.getSystemClassLoader().loadClass(classname); } catch (ClassNotFoundException e) { if (verbose) { System.out.println("System ClassLoader failed to find " + classname); } } } if (null != c) { classes.add(c); } else { System.err.println("Class " + classname + " not found"); } } } if (verbose) { System.out.println("Finished checking classnames arguments"); } } if (classes == null || classes.size() < 1) { if (null == nativesClassMap || nativesClassMap.keySet().size() < 1) { System.err.println("No Classes specified or found."); System.exit(1); } } if (verbose) { System.out.println("Classes found = " + classes.size()); } if (classes.size() > limit) { System.err.println("limit=" + limit); System.err.println( "Too many classes please use -c or -p options to limit classes or -l to increase limit."); if (verbose) { System.out.println("packagesSet = " + packagesSet); } System.exit(1); } List<Class> newClasses = new ArrayList<Class>(); for (Class clss : classes) { Class superClass = clss.getSuperclass(); while (null != superClass && !classes.contains(superClass) && !newClasses.contains(superClass) && isAddableClass(superClass, excludedClasses)) { newClasses.add(superClass); superClass = superClass.getSuperclass(); } try { Field fa[] = clss.getDeclaredFields(); for (Field f : fa) { if (Modifier.isPublic(f.getModifiers())) { Class fClass = f.getType(); if (!classes.contains(fClass) && !newClasses.contains(fClass) && isAddableClass(fClass, excludedClasses)) { newClasses.add(fClass); } } } } catch (NoClassDefFoundError e) { e.printStackTrace(); } for (Method m : clss.getDeclaredMethods()) { if (m.isSynthetic()) { continue; } if (!Modifier.isPublic(m.getModifiers()) || Modifier.isAbstract(m.getModifiers())) { continue; } Class retType = m.getReturnType(); if (verbose) { System.out.println("Checking dependancies for Method = " + m); } if (!classes.contains(retType) && !newClasses.contains(retType) && isAddableClass(retType, excludedClasses)) { newClasses.add(retType); superClass = retType.getSuperclass(); while (null != superClass && !classes.contains(superClass) && !newClasses.contains(superClass) && isAddableClass(superClass, excludedClasses)) { newClasses.add(superClass); superClass = superClass.getSuperclass(); } } for (Class paramType : m.getParameterTypes()) { if (!classes.contains(paramType) && !newClasses.contains(paramType) && isAddableClass(paramType, excludedClasses)) { newClasses.add(paramType); superClass = paramType.getSuperclass(); while (null != superClass && !classes.contains(superClass) && !newClasses.contains(superClass) && !excludedClasses.contains(superClass)) { newClasses.add(superClass); superClass = superClass.getSuperclass(); } } } } } if (null != nativesClassMap) { for (Class clss : nativesClassMap.values()) { if (null != clss) { Class superClass = clss.getSuperclass(); while (null != superClass && !classes.contains(superClass) && !newClasses.contains(superClass) && !excludedClasses.contains(superClass)) { newClasses.add(superClass); superClass = superClass.getSuperclass(); } } } } if (verbose) { System.out.println("Dependency classes needed = " + newClasses.size()); } classes.addAll(newClasses); List<Class> newOrderClasses = new ArrayList<>(); for (Class clss : classes) { if (newOrderClasses.contains(clss)) { continue; } Class superClass = clss.getSuperclass(); Stack<Class> stack = new Stack<>(); while (null != superClass && !newOrderClasses.contains(superClass) && !superClass.equals(java.lang.Object.class)) { stack.push(superClass); superClass = superClass.getSuperclass(); } while (!stack.empty()) { newOrderClasses.add(stack.pop()); } newOrderClasses.add(clss); } classes = newOrderClasses; if (verbose) { System.out.println("Total number of classes = " + classes.size()); System.out.println("classes = " + classes); } String forward_header = header.substring(0, header.lastIndexOf('.')) + "_fwd.h"; Map<String, String> map = new HashMap<>(); map.put(JAR, jar != null ? jar : ""); map.put("%CLASSPATH_PREFIX%", getCurrentDir() + ((jar != null) ? (File.pathSeparator + ((new File(jar).getCanonicalPath()).replace("\\", "\\\\"))) : "")); map.put("%FORWARD_HEADER%", forward_header); map.put("%HEADER%", header); map.put("%PATH_SEPERATOR%", File.pathSeparator); String tabs = ""; String headerDefine = forward_header.substring(Math.max(0, forward_header.indexOf(File.separator))) .replace(".", "_"); map.put(HEADER_DEFINE, headerDefine); map.put(NAMESPACE, namespace); if (null != nativesClassMap) { for (Entry<String, Class> e : nativesClassMap.entrySet()) { final Class javaClass = e.getValue(); final String nativeClassName = e.getKey(); try (PrintWriter pw = new PrintWriter(new FileWriter(nativeClassName + ".java"))) { if (javaClass.isInterface()) { pw.println("public class " + nativeClassName + " implements " + javaClass.getCanonicalName() + ", AutoCloseable{"); } else { pw.println("public class " + nativeClassName + " extends " + javaClass.getCanonicalName() + " implements AutoCloseable{"); } if (null != loadlibname && loadlibname.length() > 0) { pw.println(TAB_STRING + "static {"); pw.println(TAB_STRING + TAB_STRING + "System.loadLibrary(\"" + loadlibname + "\");"); pw.println(TAB_STRING + "}"); pw.println(); } pw.println(TAB_STRING + "public " + nativeClassName + "() {"); pw.println(TAB_STRING + "}"); pw.println(); pw.println(TAB_STRING + "private long nativeAddress=0;"); pw.println(TAB_STRING + "private boolean nativeDeleteOnClose=false;"); pw.println(); pw.println(TAB_STRING + "protected " + nativeClassName + "(final long nativeAddress) {"); pw.println(TAB_STRING + TAB_STRING + "this.nativeAddress = nativeAddress;"); pw.println(TAB_STRING + "}"); pw.println(TAB_STRING + "private native void nativeDelete();"); pw.println(); pw.println(TAB_STRING + "@Override"); pw.println(TAB_STRING + "public synchronized void close() {"); // pw.println(TAB_STRING + TAB_STRING + "if(nativeAddress != 0 && nativeDeleteOnClose) {"); pw.println(TAB_STRING + TAB_STRING + "nativeDelete();"); // pw.println(TAB_STRING + TAB_STRING + "}"); // pw.println(TAB_STRING + TAB_STRING + "nativeAddress=0;"); // pw.println(TAB_STRING + TAB_STRING + "nativeDeleteOnClose=false;"); pw.println(TAB_STRING + "}"); pw.println(); pw.println(TAB_STRING + "protected void finalizer() {"); pw.println(TAB_STRING + TAB_STRING + "close();"); pw.println(TAB_STRING + "}"); pw.println(); Method ma[] = javaClass.getDeclaredMethods(); for (Method m : ma) { int modifiers = m.getModifiers(); if (Modifier.isAbstract(modifiers) && Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) // && !m.isDefault() && !m.isSynthetic()) { pw.println(); pw.println(TAB_STRING + "@Override"); String params = ""; for (int i = 0; i < m.getParameterTypes().length; i++) { params += m.getParameterTypes()[i].getCanonicalName() + " param" + i; if (i < m.getParameterTypes().length - 1) { params += ","; } } pw.println(TAB_STRING + "native public " + m.getReturnType().getCanonicalName() + " " + m.getName() + "(" + params + ");"); // + IntStream.range(0, m.getParameterTypes().length) // .mapToObj(i -> m.getParameterTypes()[i].getCanonicalName() + " param" + i) // .collect(Collectors.joining(",")) + ");"); } } pw.println("}"); } } } try (PrintWriter pw = new PrintWriter(new FileWriter(forward_header))) { tabs = ""; processTemplate(pw, map, "header_fwd_template_start.h", tabs); Class lastClass = null; for (int class_index = 0; class_index < classes.size(); class_index++) { Class clss = classes.get(class_index); String clssOnlyName = getCppClassName(clss); tabs = openClassNamespace(clss, pw, tabs, lastClass); tabs += TAB_STRING; pw.println(tabs + "class " + clssOnlyName + ";"); tabs = tabs.substring(0, tabs.length() - 1); Class nextClass = (class_index < (classes.size() - 1)) ? classes.get(class_index + 1) : null; tabs = closeClassNamespace(clss, pw, tabs, nextClass); lastClass = clss; } processTemplate(pw, map, "header_fwd_template_end.h", tabs); } headerDefine = header.substring(Math.max(0, header.indexOf(File.separator))).replace(".", "_"); map.put(HEADER_DEFINE, headerDefine); map.put(NAMESPACE, namespace); if (classes_per_file < 1) { classes_per_file = classes.size(); } final int num_class_segments = (classes.size() > 1) ? ((classes.size() + classes_per_file - 1) / classes_per_file) : 1; String fmt = "%d"; if (num_class_segments > 10) { fmt = "%02d"; } if (num_class_segments > 100) { fmt = "%03d"; } String header_file_base = header; if (header_file_base.endsWith(".h")) { header_file_base = header_file_base.substring(0, header_file_base.length() - 2); } else if (header_file_base.endsWith(".hh")) { header_file_base = header_file_base.substring(0, header_file_base.length() - 3); } else if (header_file_base.endsWith(".hpp")) { header_file_base = header_file_base.substring(0, header_file_base.length() - 4); } try (PrintWriter pw = new PrintWriter(new FileWriter(header))) { tabs = ""; processTemplate(pw, map, HEADER_TEMPLATE_STARTH, tabs); for (int segment_index = 0; segment_index < num_class_segments; segment_index++) { String header_segment_file = header_file_base + String.format(fmt, segment_index) + ".h"; pw.println("#include \"" + header_segment_file + "\""); } if (null != nativesClassMap) { tabs = TAB_STRING; for (Entry<String, Class> e : nativesClassMap.entrySet()) { final Class javaClass = e.getValue(); final String nativeClassName = e.getKey(); pw.println(); pw.println(tabs + "class " + nativeClassName + "Context;"); pw.println(); map.put(CLASS_NAME, nativeClassName); map.put("%BASE_CLASS_FULL_NAME%", "::" + namespace + "::" + getModifiedClassName(javaClass).replace(".", "::")); map.put(OBJECT_CLASS_FULL_NAME, "::" + namespace + "::java::lang::Object"); processTemplate(pw, map, HEADER_CLASS_STARTH, tabs); tabs += TAB_STRING; pw.println(tabs + nativeClassName + "Context *context;"); pw.println(tabs + nativeClassName + "();"); pw.println(tabs + "~" + nativeClassName + "();"); Method methods[] = javaClass.getDeclaredMethods(); for (int j = 0; j < methods.length; j++) { Method method = methods[j]; int modifiers = method.getModifiers(); if (!Modifier.isPublic(modifiers)) { continue; } if (Modifier.isAbstract(modifiers) && Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) // && !method.isDefault() && !method.isSynthetic()) { pw.println(tabs + getNativeMethodCppDeclaration(method, javaClass)); } } pw.println(tabs + "void initContext(" + nativeClassName + "Context *ctx,bool isref);"); pw.println(tabs + "void deleteContext();"); tabs = tabs.substring(TAB_STRING.length()); pw.println(tabs + "}; // end class " + nativeClassName); } } tabs = ""; processTemplate(pw, map, HEADER_TEMPLATE_ENDH, tabs); } for (int segment_index = 0; segment_index < num_class_segments; segment_index++) { String header_segment_file = header_file_base + String.format(fmt, segment_index) + ".h"; try (PrintWriter pw = new PrintWriter(new FileWriter(header_segment_file))) { tabs = ""; //processTemplate(pw, map, HEADER_TEMPLATE_STARTH, tabs); pw.println("// Never include this file (" + header_segment_file + ") directly. include " + header + " instead."); pw.println(); Class lastClass = null; final int start_segment_index = segment_index * classes_per_file; final int end_segment_index = Math.min(segment_index * classes_per_file + classes_per_file, classes.size()); List<Class> classesSegList = classes.subList(start_segment_index, end_segment_index); pw.println(); pw.println(tabs + "// start_segment_index = " + start_segment_index); pw.println(tabs + "// start_segment_index = " + end_segment_index); pw.println(tabs + "// segment_index = " + segment_index); pw.println(tabs + "// classesSegList=" + classesSegList); pw.println(); for (int class_index = 0; class_index < classesSegList.size(); class_index++) { Class clss = classesSegList.get(class_index); pw.println(); pw.println(tabs + "// class_index = " + class_index + " clss=" + clss); pw.println(); String clssName = clss.getCanonicalName(); tabs = openClassNamespace(clss, pw, tabs, lastClass); String clssOnlyName = getCppClassName(clss); map.put(CLASS_NAME, clssOnlyName); map.put("%BASE_CLASS_FULL_NAME%", classToCppBase(clss)); map.put(OBJECT_CLASS_FULL_NAME, getCppRelativeName(Object.class, clss)); tabs += TAB_STRING; processTemplate(pw, map, HEADER_CLASS_STARTH, tabs); tabs += TAB_STRING; Constructor constructors[] = clss.getDeclaredConstructors(); if (!hasNoArgConstructor(constructors)) { if (Modifier.isAbstract(clss.getModifiers()) || clss.isInterface()) { pw.println(tabs + "protected:"); pw.println(tabs + clssOnlyName + "() {};"); pw.println(tabs + "public:"); } else { if (constructors.length > 0) { pw.println(tabs + "protected:"); } pw.println(tabs + clssOnlyName + "();"); if (constructors.length > 0) { pw.println(tabs + "public:"); } } } for (Constructor c : constructors) { if (c.getParameterTypes().length == 0 && Modifier.isProtected(c.getModifiers())) { pw.println(tabs + "protected:"); pw.println(tabs + clssOnlyName + "();"); pw.println(tabs + "public:"); } if (checkConstructor(c, clss, classes)) { continue; } if (c.getParameterTypes().length == 1 && clss.isAssignableFrom(c.getParameterTypes()[0])) { continue; } if (!Modifier.isPublic(c.getModifiers())) { continue; } if (c.getParameterTypes().length == 1) { if (c.getParameterTypes()[0].getName().equals(clss.getName())) { // if(verbose) System.out.println("skipping constructor."); continue; } } if (!checkParameters(c.getParameterTypes(), classes)) { continue; } pw.println( tabs + clssOnlyName + getCppParamDeclarations(c.getParameterTypes(), clss) + ";"); if (isConstructorToMakeEasy(c, clss)) { pw.println(tabs + clssOnlyName + getEasyCallCppParamDeclarations(c.getParameterTypes(), clss) + ";"); } } pw.println(tabs + "~" + clssOnlyName + "();"); Field fa[] = clss.getDeclaredFields(); for (int findex = 0; findex < fa.length; findex++) { Field field = fa[findex]; if (addGetterMethod(field, clss, classes)) { pw.println(tabs + getCppFieldGetterDeclaration(field, clss)); } if (addSetterMethod(field, clss, classes)) { pw.println(tabs + getCppFieldSetterDeclaration(field, clss)); } } Method methods[] = clss.getDeclaredMethods(); for (int j = 0; j < methods.length; j++) { Method method = methods[j]; if (!checkMethod(method, classes)) { continue; } if ((method.getModifiers() & Modifier.PUBLIC) == Modifier.PUBLIC) { pw.println(tabs + getCppDeclaration(method, clss)); } if (isArrayStringMethod(method)) { pw.println(tabs + getCppModifiers(method.getModifiers()) + getCppType(method.getReturnType(), clss) + " " + fixMethodName(method) + "(int argc,const char **argv);"); } if (isMethodToMakeEasy(method)) { pw.println(tabs + getEasyCallCppDeclaration(method, clss)); } } tabs = tabs.substring(TAB_STRING.length()); pw.println(tabs + "}; // end class " + clssOnlyName); tabs = tabs.substring(0, tabs.length() - 1); Class nextClass = (class_index < (classesSegList.size() - 1)) ? classesSegList.get(class_index + 1) : null; tabs = closeClassNamespace(clss, pw, tabs, nextClass); pw.println(); lastClass = clss; } //processTemplate(pw, map, HEADER_TEMPLATE_ENDH, tabs); } } for (int segment_index = 0; segment_index < num_class_segments; segment_index++) { String output_segment_file = output; if (output_segment_file.endsWith(".cpp")) { output_segment_file = output_segment_file.substring(0, output_segment_file.length() - 4); } else if (output_segment_file.endsWith(".cc")) { output_segment_file = output_segment_file.substring(0, output_segment_file.length() - 3); } output_segment_file += "" + String.format(fmt, segment_index) + ".cpp"; try (PrintWriter pw = new PrintWriter(new FileWriter(output_segment_file))) { tabs = ""; if (segment_index < 1) { processTemplate(pw, map, "cpp_template_start_first.cpp", tabs); } else { processTemplate(pw, map, CPP_TEMPLATE_STARTCPP, tabs); } final int start_segment_index = segment_index * classes_per_file; final int end_segment_index = Math.min(segment_index * classes_per_file + classes_per_file, classes.size()); List<Class> classesSegList = classes.subList(start_segment_index, end_segment_index); pw.println(); pw.println(tabs + "// start_segment_index = " + start_segment_index); pw.println(tabs + "// start_segment_index = " + end_segment_index); pw.println(tabs + "// segment_index = " + segment_index); pw.println(tabs + "// classesSegList=" + classesSegList); pw.println(); Class lastClass = null; for (int class_index = 0; class_index < classesSegList.size(); class_index++) { Class clss = classesSegList.get(class_index); pw.println(); pw.println(tabs + "// class_index = " + class_index + " clss=" + clss); pw.println(); String clssName = clss.getCanonicalName(); tabs = openClassNamespace(clss, pw, tabs, lastClass); String clssOnlyName = getCppClassName(clss); map.put(CLASS_NAME, clssOnlyName); map.put("%BASE_CLASS_FULL_NAME%", classToCppBase(clss)); map.put(FULL_CLASS_NAME, clssName); String fcjs = classToJNISignature(clss); fcjs = fcjs.substring(1, fcjs.length() - 1); map.put(FULL_CLASS_JNI_SIGNATURE, fcjs); if (verbose) { System.out.println("fcjs = " + fcjs); } map.put(OBJECT_CLASS_FULL_NAME, getCppRelativeName(Object.class, clss)); map.put("%INITIALIZE_CONTEXT%", ""); map.put("%INITIALIZE_CONTEXT_REF%", ""); processTemplate(pw, map, CPP_START_CLASSCPP, tabs); Constructor constructors[] = clss.getDeclaredConstructors(); if (!hasNoArgConstructor(constructors)) { if (!Modifier.isAbstract(clss.getModifiers()) && !clss.isInterface()) { pw.println(tabs + clssOnlyName + "::" + clssOnlyName + "() : " + classToCppBase(clss) + "((jobject)NULL,false) {"); map.put(JNI_SIGNATURE, "()V"); map.put(CONSTRUCTOR_ARGS, ""); processTemplate(pw, map, CPP_NEWCPP, tabs); pw.println(tabs + "}"); pw.println(); } } for (Constructor c : constructors) { if (checkConstructor(c, clss, classes)) { continue; } Class[] paramClasses = c.getParameterTypes(); pw.println(tabs + clssOnlyName + "::" + clssOnlyName + getCppParamDeclarations(paramClasses, clss) + " : " + classToCppBase(clss) + "((jobject)NULL,false) {"); tabs = tabs + TAB_STRING; map.put(JNI_SIGNATURE, "(" + getJNIParamSignature(paramClasses) + ")V"); map.put(CONSTRUCTOR_ARGS, (paramClasses.length > 0 ? "," : "") + getCppParamNames(paramClasses)); processTemplate(pw, map, CPP_NEWCPP, tabs); tabs = tabs.substring(0, tabs.length() - 1); pw.println(tabs + "}"); pw.println(); if (isConstructorToMakeEasy(c, clss)) { pw.println(tabs + clssOnlyName + "::" + clssOnlyName + getEasyCallCppParamDeclarations(c.getParameterTypes(), clss) + " : " + classToCppBase(clss) + "((jobject)NULL,false) {"); processTemplate(pw, map, "cpp_start_easy_constructor.cpp", tabs); for (int paramIndex = 0; paramIndex < paramClasses.length; paramIndex++) { Class paramClasse = paramClasses[paramIndex]; String parmName = getParamNameIn(paramClasse, paramIndex); if (isString(paramClasse)) { pw.println(tabs + "jstring " + parmName + " = env->NewStringUTF(easyArg_" + paramIndex + ");"); } else if (isPrimitiveArray(paramClasse)) { String callString = getMethodCallString(paramClasse.getComponentType()); pw.println(tabs + getCppArrayType(paramClasse.getComponentType()) + " " + classToParamNameDecl(paramClasse, paramIndex) + "= env->New" + callString + "Array(easyArg_" + paramIndex + "_length);"); pw.println(tabs + "env->Set" + callString + "ArrayRegion(" + classToParamNameDecl(paramClasse, paramIndex) + ",0,easyArg_" + paramIndex + "_length,easyArg_" + paramIndex + ");"); } else { pw.println(tabs + getCppType(paramClasse, clss) + " " + classToParamNameDecl(paramClasse, paramIndex) + "= easyArg_" + paramIndex + ";"); } } processTemplate(pw, map, "cpp_new_easy_internals.cpp", tabs); for (int paramIndex = 0; paramIndex < paramClasses.length; paramIndex++) { Class paramClasse = paramClasses[paramIndex]; String parmName = getParamNameIn(paramClasse, paramIndex); if (isString(paramClasse)) { pw.println(tabs + "jobjectRefType ref_" + paramIndex + " = env->GetObjectRefType(" + parmName + ");"); pw.println(tabs + "if(ref_" + paramIndex + " == JNIGlobalRefType) {"); pw.println(tabs + TAB_STRING + "env->DeleteGlobalRef(" + parmName + ");"); pw.println(tabs + "}"); } else if (isPrimitiveArray(paramClasse)) { String callString = getMethodCallString(paramClasse.getComponentType()); pw.println(tabs + "env->Get" + callString + "ArrayRegion(" + classToParamNameDecl(paramClasse, paramIndex) + ",0,easyArg_" + paramIndex + "_length,easyArg_" + paramIndex + ");"); pw.println(tabs + "jobjectRefType ref_" + paramIndex + " = env->GetObjectRefType(" + parmName + ");"); pw.println(tabs + "if(ref_" + paramIndex + " == JNIGlobalRefType) {"); pw.println(tabs + TAB_STRING + "env->DeleteGlobalRef(" + parmName + ");"); pw.println(tabs + "}"); } else { } } processTemplate(pw, map, "cpp_end_easy_constructor.cpp", tabs); pw.println(tabs + "}"); } } pw.println(); pw.println(tabs + "// Destructor for " + clssName); pw.println(tabs + clssOnlyName + "::~" + clssOnlyName + "() {"); pw.println(tabs + "\t// Place-holder for later extensibility."); pw.println(tabs + "}"); pw.println(); Field fa[] = clss.getDeclaredFields(); for (int findex = 0; findex < fa.length; findex++) { Field field = fa[findex]; if (addGetterMethod(field, clss, classes)) { pw.println(); pw.println(tabs + "// Field getter for " + field.getName()); pw.println(getCppFieldGetterDefinitionStart(tabs, clssOnlyName, field, clss)); map.put("%FIELD_NAME%", field.getName()); map.put(JNI_SIGNATURE, classToJNISignature(field.getType())); Class returnClass = field.getType(); map.put(METHOD_ONFAIL, getOnFailString(returnClass, clss)); map.put(METHOD_ARGS, ""); map.put("%METHOD_RETURN%", isVoid(returnClass) ? "" : "return"); map.put("%METHOD_CALL_TYPE%", getMethodCallString(returnClass)); map.put("%METHOD_RETURN_TYPE%", getCppType(returnClass, clss)); map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclare(returnClass)); String retStore = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnVarType(returnClass) + ") "; map.put("%METHOD_RETURN_STORE%", retStore); map.put("%METHOD_RETURN_GET%", getMethodReturnGet(tabs, returnClass, clss)); if (Modifier.isStatic(field.getModifiers())) { processTemplate(pw, map, "cpp_static_getfield.cpp", tabs); } else { processTemplate(pw, map, "cpp_getfield.cpp", tabs); } pw.println(tabs + "}"); } if (addSetterMethod(field, clss, classes)) { pw.println(); pw.println(tabs + "// Field setter for " + field.getName()); pw.println(getCppFieldSetterDefinitionStart(tabs, clssOnlyName, field, clss)); map.put("%FIELD_NAME%", field.getName()); map.put(JNI_SIGNATURE, classToJNISignature(field.getType())); Class returnClass = void.class; map.put(METHOD_ONFAIL, getOnFailString(returnClass, clss)); Class[] paramClasses = new Class[] { field.getType() }; String methodArgs = getCppParamNames(paramClasses); map.put(METHOD_ARGS, (paramClasses.length > 0 ? "," : "") + methodArgs); map.put("%METHOD_RETURN%", isVoid(returnClass) ? "" : "return"); map.put("%METHOD_CALL_TYPE%", getMethodCallString(field.getType())); map.put("%METHOD_RETURN_TYPE%", getCppType(returnClass, clss)); map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclare(returnClass)); String retStore = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnVarType(returnClass) + ") "; map.put("%METHOD_RETURN_STORE%", retStore); map.put("%METHOD_RETURN_GET%", getMethodReturnGet(tabs, returnClass, clss)); if (Modifier.isStatic(field.getModifiers())) { processTemplate(pw, map, "cpp_static_setfield.cpp", tabs); } else { processTemplate(pw, map, "cpp_setfield.cpp", tabs); } pw.println(tabs + "}"); } } Method methods[] = clss.getDeclaredMethods(); for (int j = 0; j < methods.length; j++) { Method method = methods[j]; if (checkMethod(method, classes)) { pw.println(); pw.println(getCppMethodDefinitionStart(tabs, clssOnlyName, method, clss)); map.put(METHOD_NAME, method.getName()); if (fixMethodName(method).contains("equals2")) { if (verbose) { System.out.println("debug me"); } } map.put("%JAVA_METHOD_NAME%", method.getName()); Class[] paramClasses = method.getParameterTypes(); String methodArgs = getCppParamNames(paramClasses); map.put(METHOD_ARGS, (paramClasses.length > 0 ? "," : "") + methodArgs); Class returnClass = method.getReturnType(); map.put(JNI_SIGNATURE, "(" + getJNIParamSignature(paramClasses) + ")" + classToJNISignature(returnClass)); map.put(METHOD_ONFAIL, getOnFailString(returnClass, clss)); map.put("%METHOD_RETURN%", isVoid(returnClass) ? "" : "return"); map.put("%METHOD_CALL_TYPE%", getMethodCallString(returnClass)); map.put("%METHOD_RETURN_TYPE%", getCppType(returnClass, clss)); map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclare(returnClass)); String retStore = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnVarType(returnClass) + ") "; map.put("%METHOD_RETURN_STORE%", retStore); map.put("%METHOD_RETURN_GET%", getMethodReturnGet(tabs, returnClass, clss)); tabs += TAB_STRING; if (!Modifier.isStatic(method.getModifiers())) { processTemplate(pw, map, CPP_METHODCPP, tabs); } else { processTemplate(pw, map, CPP_STATIC_METHODCPP, tabs); } tabs = tabs.substring(0, tabs.length() - TAB_STRING.length()); pw.println(tabs + "}"); if (isArrayStringMethod(method)) { map.put(METHOD_RETURN_STORE, isVoid(returnClass) ? "" : getCppType(returnClass, clss) + " returnVal="); map.put(METHOD_RETURN_GET, isVoid(returnClass) ? "return ;" : "return returnVal;"); processTemplate(pw, map, CPP_EASY_STRING_ARRAY_METHODCPP, tabs); } else if (isMethodToMakeEasy(method)) { pw.println(); pw.println(tabs + "// Easy call alternative for " + method.getName()); pw.println(getEasyCallCppMethodDefinitionStart(tabs, clssOnlyName, method, clss)); tabs += TAB_STRING; map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclareOut(returnClass, clss)); processTemplate(pw, map, "cpp_start_easy_method.cpp", tabs); for (int paramIndex = 0; paramIndex < paramClasses.length; paramIndex++) { Class paramClasse = paramClasses[paramIndex]; String parmName = getParamNameIn(paramClasse, paramIndex); if (isString(paramClasse)) { pw.println(tabs + "jstring " + parmName + " = env->NewStringUTF(easyArg_" + paramIndex + ");"); } else if (isPrimitiveArray(paramClasse)) { String callString = getMethodCallString(paramClasse.getComponentType()); pw.println(tabs + getCppArrayType(paramClasse.getComponentType()) + " " + classToParamNameDecl(paramClasse, paramIndex) + "= env->New" + callString + "Array(easyArg_" + paramIndex + "_length);"); pw.println(tabs + "env->Set" + callString + "ArrayRegion(" + classToParamNameDecl(paramClasse, paramIndex) + ",0,easyArg_" + paramIndex + "_length,easyArg_" + paramIndex + ");"); } else { pw.println(tabs + getCppType(paramClasse, clss) + " " + classToParamNameDecl(paramClasse, paramIndex) + "= easyArg_" + paramIndex + ";"); } } String methodArgsIn = getCppParamNamesIn(paramClasses); String retStoreOut = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnOutVarType(returnClass, clss) + ") "; pw.println(tabs + retStoreOut + fixMethodName(method) + "(" + methodArgsIn + ");"); for (int paramIndex = 0; paramIndex < paramClasses.length; paramIndex++) { Class paramClasse = paramClasses[paramIndex]; String parmName = getParamNameIn(paramClasse, paramIndex); if (isString(paramClasse)) { pw.println(tabs + "jobjectRefType ref_" + paramIndex + " = env->GetObjectRefType(" + parmName + ");"); pw.println(tabs + "if(ref_" + paramIndex + " == JNIGlobalRefType) {"); pw.println(tabs + TAB_STRING + "env->DeleteGlobalRef(" + parmName + ");"); pw.println(tabs + "}"); } else if (isPrimitiveArray(paramClasse)) { String callString = getMethodCallString(paramClasse.getComponentType()); pw.println(tabs + "env->Get" + callString + "ArrayRegion(" + classToParamNameDecl(paramClasse, paramIndex) + ",0,easyArg_" + paramIndex + "_length,easyArg_" + paramIndex + ");"); pw.println(tabs + "jobjectRefType ref_" + paramIndex + " = env->GetObjectRefType(" + parmName + ");"); pw.println(tabs + "if(ref_" + paramIndex + " == JNIGlobalRefType) {"); pw.println(tabs + TAB_STRING + "env->DeleteGlobalRef(" + parmName + ");"); pw.println(tabs + "}"); } else { } } processTemplate(pw, map, "cpp_end_easy_method.cpp", tabs); if (!isVoid(returnClass)) { pw.println(tabs + "return retVal;"); } tabs = tabs.substring(TAB_STRING.length()); pw.println(tabs + "}"); pw.println(); } } } processTemplate(pw, map, CPP_END_CLASSCPP, tabs); tabs = tabs.substring(0, tabs.length() - 1); Class nextClass = (class_index < (classesSegList.size() - 1)) ? classesSegList.get(class_index + 1) : null; tabs = closeClassNamespace(clss, pw, tabs, nextClass); lastClass = clss; } if (segment_index < 1) { if (null != nativesClassMap) { for (Entry<String, Class> e : nativesClassMap.entrySet()) { final Class javaClass = e.getValue(); final String nativeClassName = e.getKey(); map.put(CLASS_NAME, nativeClassName); map.put(FULL_CLASS_NAME, nativeClassName); map.put(FULL_CLASS_JNI_SIGNATURE, nativeClassName); map.put("%BASE_CLASS_FULL_NAME%", "::" + namespace + "::" + getModifiedClassName(javaClass).replace(".", "::")); map.put(OBJECT_CLASS_FULL_NAME, "::" + namespace + "::java::lang::Object"); map.put("%INITIALIZE_CONTEXT%", "context=NULL; initContext(NULL,false);"); map.put("%INITIALIZE_CONTEXT_REF%", "context=NULL; initContext(objref.context,true);"); tabs += TAB_STRING; processTemplate(pw, map, CPP_START_CLASSCPP, tabs); pw.println(); pw.println(tabs + nativeClassName + "::" + nativeClassName + "() : " + getModifiedClassName(javaClass).replace(".", "::") + "((jobject)NULL,false) {"); tabs += TAB_STRING; pw.println(tabs + "context=NULL;"); pw.println(tabs + "initContext(NULL,false);"); map.put(JNI_SIGNATURE, "()V"); map.put(CONSTRUCTOR_ARGS, ""); processTemplate(pw, map, "cpp_new_native.cpp", tabs); tabs = tabs.substring(TAB_STRING.length()); pw.println(tabs + "}"); pw.println(); pw.println(tabs + "// Destructor for " + nativeClassName); pw.println(tabs + nativeClassName + "::~" + nativeClassName + "() {"); pw.println(tabs + TAB_STRING + "if(NULL != context) {"); pw.println(tabs + TAB_STRING + TAB_STRING + "deleteContext();"); pw.println(tabs + TAB_STRING + "}"); pw.println(tabs + TAB_STRING + "context=NULL;"); pw.println(tabs + "}"); pw.println(); // pw.println(tabs + "public:"); // pw.println(tabs + nativeClassName + "();"); // pw.println(tabs + "~" + nativeClassName + "();"); tabs = tabs.substring(TAB_STRING.length()); // Method methods[] = javaClass.getDeclaredMethods(); // for (int j = 0; j < methods.length; j++) { // Method method = methods[j]; // int modifiers = method.getModifiers(); // if (!Modifier.isPublic(modifiers)) { // continue; // } // pw.println(tabs + getCppDeclaration(method, javaClass)); // } // pw.println(tabs + "}; // end class " + nativeClassName); processTemplate(pw, map, CPP_END_CLASSCPP, tabs); } } processTemplate(pw, map, "cpp_template_end_first.cpp", tabs); tabs = ""; if (null != nativesClassMap) { pw.println("using namespace " + namespace + ";"); pw.println("#ifdef __cplusplus"); pw.println("extern \"C\" {"); pw.println("#endif"); int max_method_count = 0; tabs = ""; for (Entry<String, Class> e : nativesClassMap.entrySet()) { final Class javaClass = e.getValue(); final String nativeClassName = e.getKey(); map.put(CLASS_NAME, nativeClassName); map.put(FULL_CLASS_NAME, nativeClassName); map.put("%BASE_CLASS_FULL_NAME%", "::" + namespace + "::" + getModifiedClassName(javaClass).replace(".", "::")); map.put(OBJECT_CLASS_FULL_NAME, "::" + namespace + "::java::lang::Object"); map.put(FULL_CLASS_JNI_SIGNATURE, nativeClassName); map.put(METHOD_ONFAIL, "return;"); Method methods[] = javaClass.getDeclaredMethods(); if (max_method_count < methods.length) { max_method_count = methods.length; } for (int j = 0; j < methods.length; j++) { Method method = methods[j]; int modifiers = method.getModifiers(); if (!Modifier.isPublic(modifiers)) { continue; } if (Modifier.isAbstract(modifiers) && Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) // && !method.isDefault() && !method.isSynthetic()) { Class[] paramClasses = method.getParameterTypes(); String methodArgs = getCppParamNames(paramClasses); map.put(METHOD_ARGS, methodArgs); map.put(METHOD_NAME, method.getName()); Class returnClass = method.getReturnType(); String retStore = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnVarType(returnClass) + ") "; map.put(METHOD_ONFAIL, getOnFailString(returnClass, javaClass)); map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclare(returnClass)); map.put("%METHOD_RETURN_STORE%", retStore); map.put("%METHOD_RETURN_GET%", getMethodReturnGet(tabs, returnClass, javaClass)); pw.println(); String paramDecls = getCppParamDeclarations(paramClasses, javaClass); String argsToAdd = method.getParameterTypes().length > 0 ? "," + paramDecls.substring(1, paramDecls.length() - 1) : ""; pw.println("JNIEXPORT " + getCppType(returnClass, javaClass) + " JNICALL Java_" + nativeClassName + "_" + method.getName() + "(JNIEnv *env, jobject jthis" + argsToAdd + ") {"); tabs = TAB_STRING; processTemplate(pw, map, "cpp_native_wrap.cpp", tabs); tabs = tabs.substring(TAB_STRING.length()); pw.println("}"); pw.println(); } } pw.println("JNIEXPORT void JNICALL Java_" + nativeClassName + "_nativeDelete(JNIEnv *env, jobject jthis) {"); tabs += TAB_STRING; map.put(METHOD_ONFAIL, getOnFailString(void.class, javaClass)); processTemplate(pw, map, "cpp_native_delete.cpp", tabs); tabs = tabs.substring(TAB_STRING.length()); pw.println(tabs + "}"); pw.println(); } pw.println("#ifdef __cplusplus"); pw.println("} // end extern \"C\""); pw.println("#endif"); map.put("%MAX_METHOD_COUNT%", Integer.toString(max_method_count + 1)); processTemplate(pw, map, "cpp_start_register_native.cpp", tabs); for (Entry<String, Class> e : nativesClassMap.entrySet()) { final Class javaClass = e.getValue(); final String nativeClassName = e.getKey(); map.put(CLASS_NAME, nativeClassName); map.put(FULL_CLASS_NAME, nativeClassName); map.put("%BASE_CLASS_FULL_NAME%", "::" + namespace + "::" + getModifiedClassName(javaClass).replace(".", "::")); map.put(OBJECT_CLASS_FULL_NAME, "::" + namespace + "::java::lang::Object"); processTemplate(pw, map, "cpp_start_register_native_class.cpp", tabs); tabs += TAB_STRING; Method methods[] = javaClass.getDeclaredMethods(); int method_number = 0; for (int j = 0; j < methods.length; j++) { Method method = methods[j]; int modifiers = method.getModifiers(); if (!Modifier.isPublic(modifiers)) { continue; } if (Modifier.isAbstract(modifiers) && Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) // && !method.isDefault() && !method.isSynthetic()) { map.put("%METHOD_NUMBER%", Integer.toString(method_number)); map.put(METHOD_NAME, method.getName()); map.put(JNI_SIGNATURE, "(" + getJNIParamSignature(method.getParameterTypes()) + ")" + classToJNISignature(method.getReturnType())); processTemplate(pw, map, "cpp_register_native_item.cpp", tabs); method_number++; } } map.put("%METHOD_NUMBER%", Integer.toString(method_number)); map.put(METHOD_NAME, "nativeDelete"); map.put(JNI_SIGNATURE, "()V"); processTemplate(pw, map, "cpp_register_native_item.cpp", tabs); map.put("%NUM_NATIVE_METHODS%", Integer.toString(method_number)); processTemplate(pw, map, "cpp_end_register_native_class.cpp", tabs); tabs = tabs.substring(TAB_STRING.length()); } processTemplate(pw, map, "cpp_end_register_native.cpp", tabs); } else { pw.println("// No Native classes : registerNativMethods not needed."); pw.println("static void registerNativeMethods(JNIEnv *env) {}"); } } else { processTemplate(pw, map, CPP_TEMPLATE_ENDCPP, tabs); } } if (null != nativesClassMap) { tabs = ""; for (Entry<String, Class> e : nativesClassMap.entrySet()) { String nativeClassName = e.getKey(); File nativeClassHeaderFile = new File( namespace.toLowerCase() + "_" + nativeClassName.toLowerCase() + ".h"); map.put("%NATIVE_CLASS_HEADER%", nativeClassHeaderFile.getName()); map.put(CLASS_NAME, nativeClassName); if (nativeClassHeaderFile.exists()) { if (verbose) { System.out.println("skipping " + nativeClassHeaderFile.getCanonicalPath() + " since it already exists."); } } else { try (PrintWriter pw = new PrintWriter(new FileWriter(nativeClassHeaderFile))) { processTemplate(pw, map, "header_native_imp.h", tabs); } } File nativeClassCppFile = new File( namespace.toLowerCase() + "_" + nativeClassName.toLowerCase() + ".cpp"); if (nativeClassCppFile.exists()) { if (verbose) { System.out.println("skipping " + nativeClassCppFile.getCanonicalPath() + " since it already exists."); } } else { try (PrintWriter pw = new PrintWriter(new FileWriter(nativeClassCppFile))) { processTemplate(pw, map, "cpp_native_imp_start.cpp", tabs); Class javaClass = e.getValue(); Method methods[] = javaClass.getDeclaredMethods(); int method_number = 0; for (int j = 0; j < methods.length; j++) { Method method = methods[j]; int modifiers = method.getModifiers(); if (!Modifier.isPublic(modifiers)) { continue; } if (Modifier.isAbstract(modifiers) && Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) // && !method.isDefault() && !method.isSynthetic()) { Class[] paramClasses = method.getParameterTypes(); // String methodArgs = getCppParamNames(paramClasses); String paramDecls = getCppParamDeclarations(paramClasses, javaClass); String methodArgs = method.getParameterTypes().length > 0 ? paramDecls.substring(1, paramDecls.length() - 1) : ""; map.put(METHOD_ARGS, methodArgs); map.put(METHOD_NAME, method.getName()); Class returnClass = method.getReturnType(); String retStore = isVoid(returnClass) ? "" : "retVal= (" + getMethodReturnVarType(returnClass) + ") "; map.put(METHOD_ONFAIL, getOnFailString(returnClass, javaClass)); map.put("%RETURN_TYPE%", getCppType(returnClass, javaClass)); map.put("%RETURN_VAR_DECLARE%", getMethodReturnVarDeclare(returnClass)); map.put("%METHOD_RETURN_STORE%", retStore); map.put("%METHOD_RETURN_GET%", getMethodReturnGet(tabs, returnClass, javaClass)); processTemplate(pw, map, "cpp_native_imp_stub.cpp", tabs); } } processTemplate(pw, map, "cpp_native_imp_end.cpp", tabs); } } } } } main_completed = true; }
From source file:org.evosuite.setup.TestClusterGenerator.java
public static Set<Class<?>> getConcreteClasses(Class<?> clazz, InheritanceTree inheritanceTree) { // Some special cases if (clazz.equals(java.util.Map.class)) return getConcreteClassesMap(); else if (clazz.equals(java.util.List.class)) return getConcreteClassesList(); else if (clazz.equals(java.util.Set.class)) return getConcreteClassesSet(); else if (clazz.equals(java.util.Collection.class)) return getConcreteClassesList(); else if (clazz.equals(java.util.Iterator.class)) // We don't want to explicitly create iterators // This would only pull in java.util.Scanner, the only // concrete subclass return new LinkedHashSet<Class<?>>(); else if (clazz.equals(java.util.ListIterator.class)) // We don't want to explicitly create iterators return new LinkedHashSet<Class<?>>(); else if (clazz.equals(java.io.Serializable.class)) return new LinkedHashSet<Class<?>>(); else if (clazz.equals(java.lang.Comparable.class)) return getConcreteClassesComparable(); else if (clazz.equals(java.util.Comparator.class)) return new LinkedHashSet<Class<?>>(); Set<Class<?>> actualClasses = new LinkedHashSet<Class<?>>(); if (Modifier.isAbstract(clazz.getModifiers()) || Modifier.isInterface(clazz.getModifiers()) || clazz.equals(Enum.class)) { Set<String> subClasses = inheritanceTree.getSubclasses(clazz.getName()); logger.debug("Subclasses of {}: {}", clazz.getName(), subClasses); Map<String, Integer> classDistance = new HashMap<String, Integer>(); int maxDistance = -1; String name = clazz.getName(); if (clazz.equals(Enum.class)) { name = Properties.TARGET_CLASS; }//from w w w.ja v a 2 s .c om for (String subClass : subClasses) { int distance = getPackageDistance(subClass, name); classDistance.put(subClass, distance); maxDistance = Math.max(distance, maxDistance); } int distance = 0; while (actualClasses.isEmpty() && distance <= maxDistance) { logger.debug(" Current distance: {}", distance); for (String subClass : subClasses) { if (classDistance.get(subClass) == distance) { try { Class<?> subClazz = Class.forName(subClass, false, TestGenerationContext.getInstance().getClassLoaderForSUT()); if (!canUse(subClazz)) continue; if (subClazz.isInterface()) continue; if (Modifier.isAbstract(subClazz.getModifiers())) { if (!hasStaticGenerator(subClazz)) continue; } Class<?> mock = MockList.getMockClass(subClazz.getCanonicalName()); if (mock != null) { /* * If we are mocking this class, then such class should not be used * in the generated JUnit test cases, but rather its mock. */ logger.debug("Adding mock {} instead of {}", mock, clazz); subClazz = mock; } else { if (!checkIfCanUse(subClazz.getCanonicalName())) { continue; } } actualClasses.add(subClazz); } catch (ClassNotFoundException e) { logger.error("Problem for {}. Class not found: {}", Properties.TARGET_CLASS, subClass, e); logger.error("Removing class from inheritance tree"); inheritanceTree.removeClass(subClass); } } } distance++; } if (hasStaticGenerator(clazz)) { actualClasses.add(clazz); } if (actualClasses.isEmpty()) { logger.info("Don't know how to instantiate abstract class {}", clazz.getName()); } } else { actualClasses.add(clazz); } logger.debug("Subclasses of {}: {}", clazz.getName(), actualClasses); return actualClasses; }
From source file:ca.sqlpower.object.annotation.SPAnnotationProcessor.java
/** * Generates and returns source code for an * {@link SPPersisterHelper#findProperty(SPObject, String, SessionPersisterSuperConverter)} * method based on getter methods annotated with {@link Accessor} used in a * given {@link SPObject} class. The purpose of this findProperty method is * to allow a session {@link SPPersister} to get the value of a given * property in an {@link SPObject} and compare it with the expected value. * This helper method will be called by the session * {@link SPPersister#persistProperty(String, String, ca.sqlpower.dao.SPPersister.DataType, Object, Object)} * method.//w w w. j a va 2 s .c om * * @param visitedClass * The {@link SPObject} class that is being visited by the * annotation processor. * @param getters * The {@link Map} of accessor method names to their property * types, where each property can be persisted by an * {@link SPPersister} into an {@link SPSession}. * @param accessorAdditionalInfo * The {@link Multimap} of getter methods mapped to additional * properties a session {@link SPPersister} requires to convert * the getter's returned value from a complex to basic * persistable type. * @param tabs * The number of tab characters to use to indent this generated * method block. * @return The source code for the generated findProperty method. * @see SPPersisterHelper#findProperty(SPObject, String, * SessionPersisterSuperConverter) * @see SPPersister#persistProperty(String, String, * ca.sqlpower.dao.SPPersister.DataType, Object, Object) */ private String generateFindPropertyMethod(Class<? extends SPObject> visitedClass, Map<String, Class<?>> getters, Multimap<String, String> accessorAdditionalInfo, int tabs) { StringBuilder sb = new StringBuilder(); final String genericObjectField = "o"; final String objectField = "castedObject"; final String propertyNameField = "propertyName"; final String converterField = "converter"; boolean firstIf = true; // findProperty method header. // public Object findProperty( // SPObject o, // String propertyName, // SessionPersisterSuperConverter converter) // throws SPPersistenceException { println(sb, tabs, String.format("public %s %s(%s %s, %s %s, %s %s) throws %s {", Object.class.getSimpleName(), FIND_PROPERTY_METHOD_NAME, SPObject.class.getSimpleName(), genericObjectField, String.class.getSimpleName(), propertyNameField, SessionPersisterSuperConverter.class.getSimpleName(), converterField, SPPersistenceException.class.getSimpleName())); tabs++; if (!getters.isEmpty()) { // If the SPObject class this persister helper handles is abstract, // use the type generic defined in the class header. // Otherwise, use the SPObject class directly. if (Modifier.isAbstract(visitedClass.getModifiers())) { // T castedObject = (T) o; println(sb, tabs, String.format("%s %s = (%s) %s;", TYPE_GENERIC_PARAMETER, objectField, TYPE_GENERIC_PARAMETER, genericObjectField)); } else { // <visitedClass> castedObject = (<visitedClass>) o; println(sb, tabs, String.format("%s %s = (%s) %s;", visitedClass.getSimpleName(), objectField, visitedClass.getSimpleName(), genericObjectField)); } // Search for the matching property name and return the value. for (Entry<String, Class<?>> e : getters.entrySet()) { String methodName = e.getKey(); print(sb, tabs, ""); if (!firstIf) { niprint(sb, "} else "); } // if (propertyName.equals("<method to property name>") { niprintln(sb, String.format("if (%s.equals(\"%s\")) {", propertyNameField, SPAnnotationProcessorUtils.convertMethodToProperty(methodName))); tabs++; // return converter.convertToBasicType(castedObject.<getter>()); print(sb, tabs, String.format("return %s.%s(%s.%s()", converterField, CONVERT_TO_BASIC_TYPE_METHOD_NAME, objectField, methodName)); for (String additionalProperty : accessorAdditionalInfo.get(methodName)) { niprint(sb, String.format(", %s.%s()", objectField, SPAnnotationProcessorUtils .convertPropertyToAccessor(additionalProperty, visitedClass))); } niprintln(sb, ");"); tabs--; firstIf = false; } if (!firstIf) { println(sb, tabs, "} else {"); tabs++; } } if (SPObject.class.isAssignableFrom(visitedClass.getSuperclass())) { Class<?> superclass = visitedClass.getSuperclass(); // return super.findProperty(o, propertyName, converter); println(sb, tabs, String.format("return super.%s(%s, %s, %s);", FIND_PROPERTY_METHOD_NAME, genericObjectField, propertyNameField, converterField)); } else { // Throw an SPPersistenceException if the property is not persistable or unrecognized. // throw new SPPersistenceException( // castedObject.getUUID(), // createSPPersistenceExceptionMessage( // castedObject, // propertyName)); println(sb, tabs, String.format("throw new %s(%s.%s(), %s(%s, %s));", SPPersistenceException.class.getSimpleName(), objectField, GET_UUID_METHOD_NAME, CREATE_EXCEPTION_MESSAGE_METHOD_NAME, objectField, propertyNameField)); } if (!firstIf) { tabs--; println(sb, tabs, "}"); } tabs--; println(sb, tabs, "}"); return sb.toString(); }
From source file:org.codehaus.groovy.grails.orm.hibernate.cfg.AbstractGrailsDomainBinder.java
/** * Binds a root class (one with no super classes) to the runtime meta model * based on the supplied Grails domain class * * @param domainClass The Grails domain class * @param mappings The Hibernate Mappings object * @param sessionFactoryBeanName the session factory bean name */// ww w .j ava 2s .c o m public void bindRoot(GrailsDomainClass domainClass, Mappings mappings, String sessionFactoryBeanName) { if (mappings.getClass(domainClass.getFullName()) != null) { LOG.info("[GrailsDomainBinder] Class [" + domainClass.getFullName() + "] is already mapped, skipping.. "); return; } RootClass root = new RootClass(); root.setAbstract(Modifier.isAbstract(domainClass.getClazz().getModifiers())); if (!domainClass.hasSubClasses()) { root.setPolymorphic(false); } bindClass(domainClass, root, mappings); Mapping m = getMapping(domainClass); bindRootPersistentClassCommonValues(domainClass, root, mappings, sessionFactoryBeanName); if (!domainClass.getSubClasses().isEmpty()) { boolean tablePerSubclass = m != null && !m.getTablePerHierarchy(); if (!tablePerSubclass) { // if the root class has children create a discriminator property bindDiscriminatorProperty(root.getTable(), root, mappings); } // bind the sub classes bindSubClasses(domainClass, root, mappings, sessionFactoryBeanName); } if (root.getEntityPersisterClass() == null) { root.setEntityPersisterClass(getGroovyAwareSingleTableEntityPersisterClass()); } mappings.addClass(root); }
From source file:org.apache.openjpa.meta.ClassMetaData.java
/** * Resolve metadata.// w w w. jav a 2 s. c o m */ protected void resolveMeta(boolean runtime) { boolean embed = _owner != null && _owner.getDeclaredType() == _type; Log log = _repos.getLog(); if (log.isTraceEnabled()) log.trace(_loc.get((embed) ? "resolve-embed-meta" : "resolve-meta", this + "@" + System.identityHashCode(this))); if (runtime && !_type.isInterface() && !ImplHelper.isManagedType(getRepository().getConfiguration(), _type)) throw new MetaDataException(_loc.get("not-enhanced", _type)); // are we the target of an embedded value? if (embed) { if (recursiveEmbed(_owner)) { throw new MetaDataException(_loc.get("recurse-embed", _owner)); } // copy info from the "real" metadata for this type ClassMetaData meta = _repos.getMetaData(_type, _loader, true); meta.resolve(MODE_META); copy(this, meta); _embedded = Boolean.FALSE; // embedded instance isn't embedded-only } // make sure superclass is resolved ClassMetaData sup = getPCSuperclassMetaData(); if (sup != null) { sup.resolve(MODE_META); if (embed) { // embedded instance always redefine all superclass fields FieldMetaData[] sups = sup.getFields(); for (int i = 0; i < sups.length; i++) { if (_supFieldMap == null || !_supFieldMap.containsKey(sups[i].getName())) { addDefinedSuperclassField(sups[i].getName(), sups[i].getDeclaredType(), sups[i].getDeclaringType()); } } } } // resolve fields and remove invalids FieldMetaData fmd; for (Iterator<FieldMetaData> itr = _fieldMap.values().iterator(); itr.hasNext();) { // only pass on metadata resolve mode so that metadata is always // resolved before any other resolve modes our subclasses pass along fmd = itr.next(); fmd.resolve(MODE_META); if (!fmd.isExplicit() && (fmd.getDeclaredTypeCode() == JavaTypes.OBJECT || fmd.getDeclaredTypeCode() == JavaTypes.PC_UNTYPED || (fmd.getDeclaredTypeCode() == JavaTypes.ARRAY && fmd.getElement().getDeclaredTypeCode() == JavaTypes.OBJECT))) { _repos.getLog().warn(_loc.get("rm-field", fmd)); if (fmd.getListingIndex() != -1) fmd.setManagement(FieldMetaData.MANAGE_NONE); else itr.remove(); clearFieldCache(); } } // embedded instances must embed all superclass fields too if (embed) { clearAllFieldCache(); resolveDefinedSuperclassFields(); } // this ensures that all field indexes get set when fields are cached cacheFields(); // resolve lifecycle metadata now to prevent lazy threading problems _lifeMeta.resolve(); // record implements in the repository if (_interfaces != null) { for (Class<?> iface : _interfaces) _repos.addDeclaredInterfaceImpl(this, iface); } // resolve fetch groups if (_fgMap != null) for (FetchGroup fg : _fgMap.values()) fg.resolve(); if (!embed && _type.isInterface()) { if (_interface != Boolean.TRUE) throw new MetaDataException(_loc.get("interface", _type)); if (runtime) { _impl = _repos.getImplGenerator().createImpl(this); _repos.setInterfaceImpl(this, _impl); } } // if this is runtime, create a pc instance and scan it for comparators if (runtime && !Modifier.isAbstract(_type.getModifiers())) { ProxySetupStateManager sm = new ProxySetupStateManager(); sm.setProxyData(PCRegistry.newInstance(_type, sm, false), this); } }
From source file:org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainBinder.java
/** * Binds a root class (one with no super classes) to the runtime meta model * based on the supplied Grails domain class * * @param domainClass The Grails domain class * @param mappings The Hibernate Mappings object * @param sessionFactoryBeanName the session factory bean name *///from ww w .j a va2 s.c o m public static void bindRoot(GrailsDomainClass domainClass, Mappings mappings, String sessionFactoryBeanName) { if (mappings.getClass(domainClass.getFullName()) != null) { LOG.info("[GrailsDomainBinder] Class [" + domainClass.getFullName() + "] is already mapped, skipping.. "); return; } RootClass root = new RootClass(); root.setAbstract(Modifier.isAbstract(domainClass.getClazz().getModifiers())); if (!domainClass.hasSubClasses()) { root.setPolymorphic(false); } bindClass(domainClass, root, mappings); Mapping m = getMapping(domainClass); bindRootPersistentClassCommonValues(domainClass, root, mappings, sessionFactoryBeanName); if (!domainClass.getSubClasses().isEmpty()) { boolean tablePerSubclass = m != null && !m.getTablePerHierarchy(); if (!tablePerSubclass) { // if the root class has children create a discriminator property bindDiscriminatorProperty(root.getTable(), root, mappings); } // bind the sub classes bindSubClasses(domainClass, root, mappings, sessionFactoryBeanName); } if (root.getEntityPersisterClass() == null) { root.setEntityPersisterClass(GroovyAwareSingleTableEntityPersister.class); } mappings.addClass(root); }
From source file:ca.sqlpower.object.annotation.SPAnnotationProcessor.java
/** * Generates and returns source code for a persistObject method based on the * constructor annotated with {@link Constructor} with its constructor * parameters annotated with {@link ConstructorParameter}, as well as the * persistable properties with their getters/setters annotated with * {@link Accessor} and {@link Mutator}. This generated method should * persist the entire state of an {@link SPObject} to an {@link SPPersister} * and should be called from a workspace persister {@link SPListener}. This * means that the union of the constructor parameter properties and * persistable properties must be persisted. * // w ww . j a v a2 s . co m * @param visitedClass * The {@link SPObject} class that is being visited by the * annotation processor. * @param constructorParameters * The {@link Map} of property names to constructor parameters, * where values passed into the constructor will set those * respective properties. The order of this map must absolutely * be guaranteed to follow the order of the constructor * parameters. These properties may or may not be persistable, so * it is entirely possible that not all of the properties in this * map exists in the given {@link Set} of persistable properties. * @param accessors * The {@link Map} of accessor method names to their property * types which should be persisted into an {@link SPPersister} by * a workspace persister {@link SPListener}. * @param propertiesToPersistOnlyIfNonNull * The {@link Set} of persistable properties that can only be * persisted if its value is not null. * @param tabs * The number of tab characters to use to indent this generated * method block. * @return The source code for the generated persistObject method. */ private String generatePersistObjectMethod(Class<? extends SPObject> visitedClass, List<ConstructorParameterObject> constructorParameters, Map<String, Class<?>> accessors, Set<String> propertiesToPersistOnlyIfNonNull, int tabs) { StringBuilder sb = new StringBuilder(); final String genericObjectField = "o"; final String objectField = "castedObject"; final String indexField = "index"; final String persisterField = "persister"; final String converterField = "converter"; final String uuidField = "uuid"; final String parentUUIDField = "parentUUID"; final String exceptionField = "e"; //Properties already processed by the constructor, to be skipped //by the helper persisters that are parent classes to this object class. final String preProcessedProps = "preProcessedProperties"; // persistObject method header. // public void persistObject(SPObject o, int index, SPPersister persister, SessionPersisterSuperConverter converter) throws SPPersistenceException { println(sb, tabs, String.format("public void %s(%s %s, int %s, %s %s, %s %s) throws %s {", PERSIST_OBJECT_METHOD_NAME, SPObject.class.getSimpleName(), genericObjectField, indexField, SPPersister.class.getSimpleName(), persisterField, SessionPersisterSuperConverter.class.getSimpleName(), converterField, SPPersistenceException.class.getSimpleName())); tabs++; // If the SPObject class this persister helper handles is abstract, // use the type generic defined in the class header. // Otherwise, use the SPObject class directly. if (Modifier.isAbstract(visitedClass.getModifiers())) { // T castedObject = (T) o; println(sb, tabs, String.format("%s %s = (%s) %s;", TYPE_GENERIC_PARAMETER, objectField, TYPE_GENERIC_PARAMETER, genericObjectField)); } else { // <visitedClass> castedObject = (<visitedClass>) o; println(sb, tabs, String.format("%s %s = (%s) %s;", visitedClass.getSimpleName(), objectField, visitedClass.getSimpleName(), genericObjectField)); } // final String uuid = castedObject.getUUID(); println(sb, tabs, String.format("final %s %s = %s.%s();", String.class.getSimpleName(), uuidField, objectField, GET_UUID_METHOD_NAME)); // String parentUUID = null; println(sb, tabs, String.format("%s %s = null;", String.class.getSimpleName(), parentUUIDField)); // if (castedObject.getParent() != null) { println(sb, tabs, String.format("if (%s.%s() != null) {", objectField, GET_PARENT_METHOD_NAME)); tabs++; // parentUUID = castedObject.getParent().getUUID(); println(sb, tabs, String.format("%s = %s.%s().%s();", parentUUIDField, objectField, GET_PARENT_METHOD_NAME, GET_UUID_METHOD_NAME)); tabs--; println(sb, tabs, "}\n"); // Persist the object. // persister.persistObject(parentUUID, "<visitedClass name>", uuid, index);" println(sb, tabs, String.format("%s.%s(%s, \"%s\", %s, %s);", persisterField, PERSIST_OBJECT_METHOD_NAME, parentUUIDField, visitedClass.getName(), uuidField, indexField)); //TODO pass in the actual exception types on any accessors //then replace this blanket try/catch with specifics for any accessor //that throws an exception. // List<String> preProcessedProperties = new ArrayList<String>(); println(sb, tabs, String.format("%s<%s> %s = new %s<%s>();", List.class.getSimpleName(), String.class.getSimpleName(), preProcessedProps, ArrayList.class.getSimpleName(), String.class.getSimpleName())); importedClassNames.add(ArrayList.class.getName()); println(sb, tabs, "try {"); tabs++; if (constructorParameters.isEmpty()) { println(sb, tabs, "// No constructor arguments"); } else { println(sb, tabs, "// Constructor arguments"); final String dataTypeField = "dataType"; // DataType dataType; println(sb, tabs, String.format("%s %s;", DataType.class.getSimpleName(), dataTypeField)); // Persist all of its constructor argument properties. for (ConstructorParameterObject cpo : constructorParameters) { //XXX Should this only be properties? if (ParameterType.PROPERTY.equals(cpo.getProperty()) || ParameterType.CHILD.equals(cpo.getProperty())) { String getPersistedProperty = objectField + "." + SPAnnotationProcessorUtils.convertPropertyToAccessor(cpo.getName(), visitedClass) + "()"; if (cpo.getType() == Object.class) { // if (castedObject.<getter>() == null) { println(sb, tabs, String.format("if (%s == null) {", getPersistedProperty)); tabs++; // dataType = PersisterUtils.getDataType(null); println(sb, tabs, String.format("%s = %s.getDataType(null);", dataTypeField, PersisterUtils.class.getSimpleName())); tabs--; println(sb, tabs, "} else {"); tabs++; // dataType = PersisterUtils.getDataType(castedObject.<getter>().getClass()); println(sb, tabs, String.format("%s = %s.getDataType(%s.getClass());", dataTypeField, PersisterUtils.class.getSimpleName(), getPersistedProperty)); tabs--; println(sb, tabs, "}"); importedClassNames.add(PersisterUtils.class.getName()); } else { // dataType = DataType.<type>; println(sb, tabs, String.format("%s = %s.%s;", dataTypeField, DataType.class.getSimpleName(), PersisterUtils.getDataType(cpo.getType()).name())); } // persister.persistProperty(uuid, "<property>", dataType, converter, convertToBasicType(castedObject.<getter>())); println(sb, tabs, String.format("%s.%s(%s, \"%s\", %s, %s.%s(%s.%s()));", persisterField, PERSIST_PROPERTY_METHOD_NAME, uuidField, cpo.getName(), //XXX we should convert this name as the constructor parameter name may be different than the property name defined by the accessor. dataTypeField, converterField, CONVERT_TO_BASIC_TYPE_METHOD_NAME, objectField, SPAnnotationProcessorUtils.convertPropertyToAccessor(cpo.getName(), visitedClass))); // preProcessedProperties.add("<propertyName>"); println(sb, tabs, String.format("%s.add(\"%s\");", preProcessedProps, cpo.getName())); importedClassNames.add(DataType.class.getName()); } } } niprintln(sb, ""); // persistObjectProperties(o, persister, converter, preProcessedProperties); println(sb, tabs, String.format("%s(%s, %s, %s, %s);", PERSIST_OBJECT_PROPERTIES_METHOD_NAME, genericObjectField, persisterField, converterField, preProcessedProps)); tabs--; // } catch (Exception e) { println(sb, tabs, String.format("} catch (%s %s) {", Exception.class.getSimpleName(), exceptionField)); tabs++; // throw new SPPersistenceException(uuid, e); println(sb, tabs, String.format("throw new %s(%s, %s);", SPPersistenceException.class.getSimpleName(), uuidField, exceptionField)); tabs--; println(sb, tabs, "}"); tabs--; println(sb, tabs, "}"); return sb.toString(); }