/** Lookup the artifacts generated for this package in the previous build. */ private Map<String, File> fetchPrevArtifacts(String pkg) { Package p = prev.packages().get(pkg); if (p != null) { return p.artifacts(); } return new HashMap<>(); }
/** Add Karaf core features URL in the default repositories set */ private void appendKarafCoreFeaturesDescriptors() { if (repositories == null) { repositories = new ArrayList<String>(); } if (karafVersion == null) { Package p = Package.getPackage("org.apache.karaf.tooling.features"); karafVersion = p.getImplementationVersion(); } String karafCoreStandardFeaturesUrl = String.format(KARAF_CORE_STANDARD_FEATURE_URL, karafVersion); String karafCoreEnterpriseFeaturesUrl = String.format(KARAF_CORE_ENTERPRISE_FEATURE_URL, karafVersion); try { resolve(karafCoreStandardFeaturesUrl); repositories.add(karafCoreStandardFeaturesUrl); } catch (Exception e) { warn("Can't add " + karafCoreStandardFeaturesUrl + " in the default repositories set"); } try { resolve(karafCoreEnterpriseFeaturesUrl); repositories.add(karafCoreEnterpriseFeaturesUrl); } catch (Exception e) { warn("Can't add " + karafCoreStandardFeaturesUrl + " in the default repositories set"); } }
/** * Returns the correct implementation instance for the interface <code>type</code>. For convention * the implentation is named <code>InterfaceName + Impl</code>. * * @param type The interface type * @return The correct ModelProxy subclass (if exists), a ModelProxy instance otherwise * @throws MalformedModelException is the interface or the implementation are not well formed * (they don't respect the conventions). * @throws ModelRuntimeException is any error occurs during the instantiation */ protected ModelProxy createInstance(Class type) { Class backClass; if (implementations.containsKey(type)) backClass = implementations.get(type); else { /* type never seen */ try { Package pkg = type.getPackage(); String pkgN = pkg == null ? "" : pkg.getName(); backClass = Class.forName(pkgN + tableName(type) + CommonStatic.getImplementationSuffix()); } catch (Exception e) { backClass = ModelProxy.class; } Validator.validateModel(type, backClass); initFieldsTypes(type); implementations.put(type, backClass); } ModelProxy impl = null; try { impl = (ModelProxy) backClass.newInstance(); } catch (Exception e) { throw new ModelRuntimeException(e.getMessage()); } return impl; }
private List<String> dependenciesOf(Package source) { List<String> result = new ArrayList<>(); if (source.isAnnotationPresent(DependsUpon.class)) for (Class<?> target : source.getAnnotation(DependsUpon.class).packagesOf()) result.add(target.getPackage().getName()); return result; }
/** * Scan all output dirs for artifacts and remove those files (artifacts?) that are not recognized * as such, in the javac_state file. */ public void removeUnidentifiedArtifacts() { Set<File> allKnownArtifacts = new HashSet<>(); for (Package pkg : prev.packages().values()) { for (File f : pkg.artifacts().values()) { allKnownArtifacts.add(f); } } // Do not forget about javac_state.... allKnownArtifacts.add(javacState); for (File f : binArtifacts) { if (!allKnownArtifacts.contains(f)) { Log.debug("Removing " + f.getPath() + " since it is unknown to the javac_state."); f.delete(); } } for (File f : headerArtifacts) { if (!allKnownArtifacts.contains(f)) { Log.debug("Removing " + f.getPath() + " since it is unknown to the javac_state."); f.delete(); } } for (File f : gensrcArtifacts) { if (!allKnownArtifacts.contains(f)) { Log.debug("Removing " + f.getPath() + " since it is unknown to the javac_state."); f.delete(); } } }
// Serialize the bean using the specified namespace prefix & uri public String serialize(Object bean) throws IntrospectionException, IllegalAccessException { // Use the class name as the name of the root element String className = bean.getClass().getName(); String rootElementName = null; if (bean.getClass().isAnnotationPresent(ObjectXmlAlias.class)) { AnnotatedElement annotatedElement = bean.getClass(); ObjectXmlAlias aliasAnnotation = annotatedElement.getAnnotation(ObjectXmlAlias.class); rootElementName = aliasAnnotation.value(); } // Use the package name as the namespace URI Package pkg = bean.getClass().getPackage(); nsURI = pkg.getName(); // Remove a trailing semi-colon (;) if present (i.e. if the bean is an array) className = StringUtils.deleteTrailingChar(className, ';'); StringBuffer sb = new StringBuffer(className); String objectName = sb.delete(0, sb.lastIndexOf(".") + 1).toString(); domDocument = createDomDocument(objectName); document = domDocument.getDocument(); Element root = document.getDocumentElement(); // Parse the bean elements getBeanElements(root, rootElementName, className, bean); StringBuffer xml = new StringBuffer(); if (prettyPrint) xml.append(domDocument.serialize(lineSeperator, indentChars, includeXmlProlog)); else xml.append(domDocument.serialize(includeXmlProlog)); if (!includeTypeInfo) { int index = xml.indexOf(root.getNodeName()); xml.delete(index - 1, index + root.getNodeName().length() + 2); xml.delete(xml.length() - root.getNodeName().length() - 4, xml.length()); } return xml.toString(); }
/** * Check whether a given application version is compatible with the version of JHotDraw currently * loaded in the Java VM. A version number is available if there is a corresponding version entry * in the JHotDraw jar file for the framework package. */ public static boolean isCompatibleVersion(String compareVersionString) { // Package pack = VersionManagement.class.getPackage(); Package pack = packages[4]; if (compareVersionString == null) { return pack.getSpecificationVersion() == null; } else { return pack.isCompatibleWith(compareVersionString); } }
/** * Propagate recompilation through the dependency chains. Avoid re-tainting packages that have * already been compiled. */ public void taintPackagesDependingOnChangedPackages( Set<String> pkgs, Set<String> recentlyCompiled) { for (Package pkg : prev.packages().values()) { for (String dep : pkg.dependencies()) { if (pkgs.contains(dep) && !recentlyCompiled.contains(pkg.name())) { taintPackage(pkg.name(), " its depending on " + dep); } } } }
/** If artifacts have gone missing, force a recompile of the packages they belong to. */ public void taintPackagesThatMissArtifacts() { for (Package pkg : prev.packages().values()) { for (File f : pkg.artifacts().values()) { if (!f.exists()) { // Hmm, the artifact on disk does not exist! Someone has removed it.... // Lets rebuild the package. taintPackage(pkg.name(), "" + f + " is missing."); } } } }
/** adds a found scan to a seleceted lost package */ private void buttonSetFoundActionPerformed(ActionEvent event) { int index = jListPackages.getSelectedIndex(); if (index >= 0) { Package p = this.packages.get(index); if (p.lastScan().event == ScanEvents.lost) { p.scan(ScanEvents.found, this.user); this.packages.remove(p); this.jListPackages.setListData(new Vector(this.packages)); jListScans.setListData(new Vector()); } } }
protected static Object wrap(Object object) { try { if (object == null) { return NULL; } if (object instanceof JSONObject || object instanceof JSONArray || NULL.equals(object) || object instanceof Byte || object instanceof Character || object instanceof Short || object instanceof Integer || object instanceof Long || object instanceof Boolean || object instanceof Float || object instanceof Double || object instanceof String || object instanceof BigInteger || object instanceof BigDecimal) { return object; } if (object instanceof Collection) { Collection<?> coll = (Collection<?>) object; return new JSONArray(coll); } if (object.getClass().isArray()) { return new JSONArray(object); } if (object instanceof Map) { Map<?, ?> map = (Map<?, ?>) object; return new JSONObject(map); } if (object.getClass().isEnum()) { return ((Enum<?>) object).name(); } Package objectPackage = object.getClass().getPackage(); String objectPackageName = objectPackage != null ? objectPackage.getName() : ""; if (objectPackageName.startsWith("java.") || objectPackageName.startsWith("javax.") || object.getClass().getClassLoader() == null) { return object.toString(); } return new JSONObject(object); } catch (Exception e) { throw new JSONException(e); } }
/** Mark a java package as tainted, ie it needs recompilation. */ public void taintPackage(String name, String because) { if (!taintedPackages.contains(name)) { if (because != null) Log.debug("Tainting " + Util.justPackageName(name) + " because " + because); // It has not been tainted before. taintedPackages.add(name); needsSaving(); Package nowp = now.packages().get(name); if (nowp != null) { for (String d : nowp.dependents()) { taintPackage(d, because); } } } }
private void ensureDroolsRuntimeMatches( String expectedRuntimeVersion, VersionCheckStrategy versionCheckStrategy) { final Package droolsCorePackage = KnowledgePackageImp.class.getPackage(); final String implementationTitle = droolsCorePackage.getImplementationTitle(); final String implementationVersion = droolsCorePackage.getImplementationVersion(); switch (versionCheckStrategy) { case VERSIONS_MUST_MATCH: ensureVersionsMatch(expectedRuntimeVersion, implementationTitle, implementationVersion); break; case IGNORE_UNKNOWN_RUNTIME_VERSION: ensureVersionsMatchIgnoringUnknown( expectedRuntimeVersion, implementationTitle, implementationVersion); break; } }
public static String getPackageVersion(final Package lookupPackage) { if (lookupPackage == null) { return null; } String specVersion = lookupPackage.getSpecificationVersion(); if (specVersion != null) { return specVersion; } else { // search in parent package String normalizedPackageName = normalizePackageName(lookupPackage.getName()); String nextPackageName = getNextPackage(normalizedPackageName); return getPackageVersion(Package.getPackage(nextPackageName)); } }
public static File getClassDirectory(Package pakage) { Set<Class<?>> classes = new LinkedHashSet<Class<?>>(); boolean flag = true; // 是否循环迭代 String packName = pakage.getName(); // String packName = "org.jdom"; String packDir = packName.replace(".", "/"); Enumeration<URL> dir; String filePath = null; try { dir = Thread.currentThread().getContextClassLoader().getResources(packDir); while (dir.hasMoreElements()) { URL url = dir.nextElement(); // System.out.println("url:***" + url); String protocol = url.getProtocol(); // 获得协议号 if ("file".equals(protocol)) { // System.err.println("file类型的扫描"); filePath = URLDecoder.decode(url.getFile(), "UTF-8"); } } } catch (IOException e) { e.printStackTrace(); } File file = new File(filePath); if (file.exists()) { return file; } else { return null; } }
/** * Wrap an object, if necessary. If the object is null, return the NULL object. If it is an array * or collection, wrap it in a JSONArray. If it is a map, wrap it in a JSONObject. If it is a * standard property (Double, String, et al) then it is already wrapped. Otherwise, if it comes * from one of the java packages, turn it into a string. And if it doesn't, try to wrap it in a * JSONObject. If the wrapping fails, then null is returned. * * @param object The object to wrap * @return The wrapped value */ public static Object wrap(Object object) { try { if (object == null) { return JSONObject.NULL; } if ((object instanceof JSONObject) || (object instanceof JSONArray) || JSONObject.NULL.equals(object) || (object instanceof JSONString) || (object instanceof Byte) || (object instanceof Character) || (object instanceof Short) || (object instanceof Integer) || (object instanceof Long) || (object instanceof Boolean) || (object instanceof Float) || (object instanceof Double) || (object instanceof String)) { return object; } if (object instanceof Collection) { return new JSONArray((Collection) object); } if (object.getClass().isArray()) { return new JSONArray(object); } if (object instanceof Map) { return new JSONObject((Map) object); } final Package objectPackage = object.getClass().getPackage(); final String objectPackageName = (objectPackage != null ? objectPackage.getName() : ""); if (objectPackageName.startsWith("java.") || objectPackageName.startsWith("javax.") || (object.getClass().getClassLoader() == null)) { return object.toString(); } return new JSONObject(object); } catch (final Exception exception) { return null; } }
public static Set<Class<?>> getclass(Package pakage) { Set<Class<?>> classes = new LinkedHashSet<Class<?>>(); boolean flag = true; // 是否循环迭代 String packName = pakage.getName(); // String packName = "org.jdom"; String packDir = packName.replace(".", "/"); Enumeration<URL> dir; try { dir = Thread.currentThread().getContextClassLoader().getResources(packDir); while (dir.hasMoreElements()) { URL url = dir.nextElement(); // System.out.println("url:***" + url); String protocol = url.getProtocol(); // 获得协议号 if ("file".equals(protocol)) { // System.err.println("file类型的扫描"); String filePath = URLDecoder.decode(url.getFile(), "UTF-8"); // System.out.println("filePath :" + filePath); findAndAddClassesInPackageByFile(packName, filePath, flag, classes); } else if ("jar".equals(protocol)) { // System.err.println("jar类型扫描"); JarURLConnection urlConnection = (JarURLConnection) url.openConnection(); JarFile jar = urlConnection.getJarFile(); Enumeration<JarEntry> entries = jar.entries(); while (entries.hasMoreElements()) { JarEntry entry = entries.nextElement(); String name = entry.getName(); // System.out.println(">>>>:" + name); // ...... } } } } catch (IOException e) { e.printStackTrace(); } // System.out.println(classes.size()); return classes; }
@Override public void onApplicationStart() { // must check and configure JPA for each DBConfig for (DBConfig dbConfig : DB.getDBConfigs()) { // check and enable JPA on this config // is JPA already configured? String configName = dbConfig.getDBConfigName(); if (JPA.getJPAConfig(configName, true) == null) { // must configure it // resolve prefix for hibernate config.. // should be nothing for default, and db_<name> for others String propPrefix = ""; if (!DBConfig.defaultDbConfigName.equalsIgnoreCase(configName)) { propPrefix = "db_" + configName + "."; } List<Class> classes = findEntityClassesForThisConfig(configName, propPrefix); if (classes == null) continue; // we're ready to configure this instance of JPA final String hibernateDataSource = Play.configuration.getProperty(propPrefix + "hibernate.connection.datasource"); if (StringUtils.isEmpty(hibernateDataSource) && dbConfig == null) { throw new JPAException( "Cannot start a JPA manager without a properly configured database" + getConfigInfoString(configName), new NullPointerException("No datasource configured")); } Ejb3Configuration cfg = new Ejb3Configuration(); if (dbConfig.getDatasource() != null) { cfg.setDataSource(dbConfig.getDatasource()); } if (!Play.configuration .getProperty(propPrefix + "jpa.ddl", Play.mode.isDev() ? "update" : "none") .equals("none")) { cfg.setProperty( "hibernate.hbm2ddl.auto", Play.configuration.getProperty(propPrefix + "jpa.ddl", "update")); } String driver = null; if (StringUtils.isEmpty(propPrefix)) { driver = Play.configuration.getProperty("db.driver"); } else { driver = Play.configuration.getProperty(propPrefix + "driver"); } cfg.setProperty("hibernate.dialect", getDefaultDialect(propPrefix, driver)); cfg.setProperty("javax.persistence.transaction", "RESOURCE_LOCAL"); cfg.setInterceptor(new PlayInterceptor()); // This setting is global for all JPAs - only configure if configuring default JPA if (StringUtils.isEmpty(propPrefix)) { if (Play.configuration.getProperty(propPrefix + "jpa.debugSQL", "false").equals("true")) { org.apache.log4j.Logger.getLogger("org.hibernate.SQL").setLevel(Level.ALL); } else { org.apache.log4j.Logger.getLogger("org.hibernate.SQL").setLevel(Level.OFF); } } // inject additional hibernate.* settings declared in Play! configuration Properties additionalProperties = (Properties) Utils.Maps.filterMap(Play.configuration, "^" + propPrefix + "hibernate\\..*"); // We must remove prefix from names Properties transformedAdditionalProperties = new Properties(); for (Map.Entry<Object, Object> entry : additionalProperties.entrySet()) { Object key = entry.getKey(); if (!StringUtils.isEmpty(propPrefix)) { key = ((String) key).substring(propPrefix.length()); // chop off the prefix } transformedAdditionalProperties.put(key, entry.getValue()); } cfg.addProperties(transformedAdditionalProperties); try { // nice hacking :) I like it.. Field field = cfg.getClass().getDeclaredField("overridenClassLoader"); field.setAccessible(true); field.set(cfg, Play.classloader); } catch (Exception e) { Logger.error( e, "Error trying to override the hibernate classLoader (new hibernate version ???)"); } for (Class<?> clazz : classes) { cfg.addAnnotatedClass(clazz); if (Logger.isTraceEnabled()) { Logger.trace("JPA Model : %s", clazz); } } String[] moreEntities = Play.configuration.getProperty(propPrefix + "jpa.entities", "").split(", "); for (String entity : moreEntities) { if (entity.trim().equals("")) { continue; } try { cfg.addAnnotatedClass(Play.classloader.loadClass(entity)); } catch (Exception e) { Logger.warn("JPA -> Entity not found: %s", entity); } } for (ApplicationClass applicationClass : Play.classes.all()) { if (applicationClass.isClass() || applicationClass.javaPackage == null) { continue; } Package p = applicationClass.javaPackage; Logger.info("JPA -> Adding package: %s", p.getName()); cfg.addPackage(p.getName()); } String mappingFile = Play.configuration.getProperty(propPrefix + "jpa.mapping-file", ""); if (mappingFile != null && mappingFile.length() > 0) { cfg.addResource(mappingFile); } if (Logger.isTraceEnabled()) { Logger.trace("Initializing JPA" + getConfigInfoString(configName) + " ..."); } try { JPA.addConfiguration(configName, cfg); } catch (PersistenceException e) { throw new JPAException( e.getMessage() + getConfigInfoString(configName), e.getCause() != null ? e.getCause() : e); } } } // must look for Entity-objects referring to none-existing JPAConfig List<Class> allEntityClasses = Play.classloader.getAnnotatedClasses(Entity.class); for (Class clazz : allEntityClasses) { String configName = Entity2JPAConfigResolver.getJPAConfigNameForEntityClass(clazz); if (JPA.getJPAConfig(configName, true) == null) { throw new JPAException( "Found Entity-class (" + clazz.getName() + ") referring to none-existing JPAConfig" + getConfigInfoString(configName) + ". " + "Is JPA properly configured?"); } } }
public void generate(String inputFileName) throws Exception { List<MetaClass> metaClasses = new ArrayList<>(); List<LifeLine> lifeLines = new ArrayList<>(); List<MethodInvocation> rootMessages = new ArrayList<>(); MethodInvocation parentMessage = new MethodInvocation(); GsonBuilder builder = new GsonBuilder(); List<MethodInvocation> methodInvocations = new ArrayList<>(); Package mainPackage = new Package(); List<Guard> listOfGuards = new ArrayList<>(); Map<Guard, Instruction> guardToCFMap = new HashMap<>(); List<Instruction> combinedFragments = new ArrayList<Instruction>(); List<Operation> operationsList = new ArrayList<>(); builder.registerTypeAdapter(RefObject.class, new RefObjectJsonDeSerializer()); Gson gson = builder.create(); Element myTypes = gson.fromJson(new FileReader(inputFileName), Element.class); if (myTypes._type.equals("Project")) { List<Element> umlElements = myTypes .ownedElements .stream() .filter(f -> f._type.equals("UMLModel")) .collect(Collectors.toList()); if (umlElements.size() > 0) { // There has be to atleast one UMLModel package Element element = umlElements.get(0); // package that the classes are supposed to be in mainPackage.setName(element.name); List<Element> umlPackages = element .ownedElements .stream() .filter(g -> g._type.equals("UMLPackage")) .collect(Collectors.toList()); if (umlPackages.size() > 1) { // There has to be two packages- one for class one for behaviour Element classes = umlPackages.get(0); Element behaviour = umlPackages.get(1); // *--------------------------CLASSES-------------------------------*// // in the first pass, get all classes that are defined in the diagram // get details that can be directly inferred from the json like, fields and operations, // which do not refer to other classes for (Element umlClass : classes.getOwnedElements()) { MetaClass metaClass = new MetaClass(umlClass.name, umlClass._id); // check if class is interface or not because there is no distinction in json if (umlClass._type.equals("UMLClass")) { metaClass.setInterface(false); } else { metaClass.setInterface(true); } if (umlClass.operations != null) { metaClass.setOperations(umlClass.operations); operationsList.addAll(metaClass.operations); } if (umlClass.attributes != null) { metaClass.setFields(umlClass.attributes); } metaClasses.add(metaClass); } // in second pass, define associations and generalizations for these classes for (Element umlClass : classes.getOwnedElements()) { if (umlClass.ownedElements != null) { // find corresponding metaclass, then populate the secondary inferences List<MetaClass> correspondingMetaClassList = metaClasses .stream() .filter(f -> f._id.equals(umlClass._id)) .collect(Collectors.toList()); MetaClass correspondingMetaClass = correspondingMetaClassList.get(0); List<Element> umlAssociations = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLAssociation")) .collect(Collectors.toList()); if (umlAssociations.size() > 0) { correspondingMetaClass.setAssociations(metaClasses, umlAssociations); } List<Element> umlGeneralization = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLGeneralization")) .collect(Collectors.toList()); if (umlGeneralization.size() > 0) { correspondingMetaClass.setGeneralizations(metaClasses, umlGeneralization); } List<Element> umlRealization = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLInterfaceRealization")) .collect(Collectors.toList()); if (umlRealization.size() > 0) { correspondingMetaClass.setInterfaceRealization(metaClasses, umlRealization); } } } // *--------------------------CLASSES-------------------------------*// // *----------------------- BEHAVIOUR---------------------------------*// for (Element umlCollaboration : behaviour.getOwnedElements()) { // Role to Class mapping ArrayList<Element> attributes = umlCollaboration.attributes; HashMap<String, MetaClass> roleToClassMap = new HashMap<>(); if (attributes != null) { for (Element attribute : attributes) { List<MetaClass> roleClass = metaClasses .stream() .filter(f -> f._id.equals(attribute.type.$ref)) .collect(Collectors.toList()); roleToClassMap.put(attribute._id, roleClass.get(0)); } } for (Element umlInteraction : umlCollaboration.ownedElements) { // mapping lifelines to the classes they correspond ArrayList<Element> participants = umlInteraction.participants; if (participants != null && participants.size() > 0) { for (Element participant : participants) { MetaClass participantClass = roleToClassMap.get(participant.represent.$ref); LifeLine lifeLine = new LifeLine(); lifeLine.setName(participant.name); lifeLine.setId(participant._id); lifeLine.setMetaClass(participantClass); lifeLines.add(lifeLine); } } // first parse all the combined fragments and get ready if (umlInteraction.fragments != null) { for (Element fragment : umlInteraction.fragments) { // depending on the fragment set the class Instruction instruction = null; if (fragment.interactionOperator.equals("loop")) { Loop loop = new Loop(); loop.setId(fragment._id); loop.setWeight(0); Guard guard = new Guard(fragment.operands.get(0)._id); // loop can have only one condition--- one condition-- condition is made up of // AND or OR's guard.setCondition(fragment.operands.get(0).guard); loop.setGuard(guard); instruction = loop; combinedFragments.add(loop); listOfGuards.add(guard); guardToCFMap.put(guard, loop); } if (fragment.interactionOperator.equals("alt")) { Conditional c = new Conditional(); c.setId(fragment._id); c.setWeight(0); instruction = c; combinedFragments.add(c); Guard consequence = new Guard(fragment.operands.get(0)._id); consequence.setCondition(fragment.operands.get(0).guard); c.setCons(consequence); listOfGuards.add(consequence); guardToCFMap.put(consequence, c); consequence.setConsequence(true); if (fragment.operands.size() > 1) { Guard alternate = new Guard(fragment.operands.get(1)._id); alternate.setCondition(fragment.operands.get(1).guard); c.setAlt(alternate); listOfGuards.add(alternate); guardToCFMap.put(alternate, c); alternate.setAlternative(true); } } if (fragment.tags != null) { for (Element tag : fragment.tags) { if (tag.name.equals("parent")) { List<Instruction> instructionList = combinedFragments .stream() .filter(e -> e.getId().equals(tag.reference.$ref)) .collect(Collectors.toList()); if (instructionList.size() > 0) { instructionList.get(0).getBlock().add(instruction); instruction.setParent(instructionList.get(0)); } } } } } } // parsing the messages and make nodes out them to later build a tree from the // lifelines ArrayList<Element> messages = umlInteraction.messages; Element startMessage = messages.get(0); String sourceRef = startMessage.source.$ref; String targetRef = startMessage.target.$ref; Element endMessage = null; LifeLine sourceLifeLine = getLifeLine(lifeLines, sourceRef); LifeLine targetLifeLine = getLifeLine(lifeLines, targetRef); // First message processing parentMessage = new MethodInvocation(); parentMessage.setAssignmentTarget(startMessage.assignmentTarget); parentMessage.setMessageSort(startMessage.messageSort); parentMessage.setSource(sourceLifeLine.getMetaClass()); parentMessage.setTarget(targetLifeLine.getMetaClass()); parentMessage.setName(startMessage.name); parentMessage.setId(startMessage._id); if (sourceLifeLine.getId().equals(targetLifeLine.getId())) { parentMessage.setCallerObject("this"); } else { parentMessage.setCallerObject(targetLifeLine.getName()); } int weight = 0; parentMessage.setWeight(weight++); if (startMessage.signature != null) { parentMessage.setSignature(startMessage.signature.$ref); } if (startMessage.tags != null) { for (Element tag : startMessage.tags) { // if (tag.name.equals("CF")) { // parentMessage.setInCF(true); // // parentMessage.setCfID(tag.reference.$ref); // } if (tag.name.equals("operand")) { parentMessage.setOperandId(tag.reference.$ref); } } } MethodInvocation rootMessage = parentMessage; methodInvocations.add(rootMessage); rootMessages.add(rootMessage); Iterator<Element> iter = messages.iterator(); while (iter.hasNext()) { if (iter.next() == endMessage) { continue; } iter.remove(); List<Element> childMessages = getChildMessages(messages, targetRef); for (Element child : childMessages) { LifeLine childSource = getLifeLine(lifeLines, child.source.$ref); LifeLine childTarget = getLifeLine(lifeLines, child.target.$ref); MethodInvocation childMessage = new MethodInvocation(); childMessage.setMessageSort(child.messageSort); childMessage.setSource(childSource.getMetaClass()); childMessage.setTarget(childTarget.getMetaClass()); childMessage.setAssignmentTarget(child.assignmentTarget); childMessage.setName(child.name); childMessage.setId(child._id); childMessage.setWeight(weight++); childMessage.setArguments(child.arguments); if (childSource.getId().equals(childTarget.getId())) { childMessage.setCallerObject("this"); } else { childMessage.setCallerObject(childTarget.getName()); } if (child.signature != null) { childMessage.setSignature(child.signature.$ref); } if (child.tags != null) { for (Element tag : child.tags) { // if (tag.name.equals("CF")) { // childMessage.setInCF(true); // // childMessage.setCfID(tag.reference.$ref); // } if (tag.name.equals("operand")) { childMessage.setOperandId(tag.reference.$ref); } } } parentMessage.childNodes.add(childMessage); methodInvocations.add(childMessage); } if (childMessages.size() > 0) { List<MethodInvocation> nextMessage = parentMessage .childNodes .stream() .filter(f -> !f.source.equals(f.target)) .collect(Collectors.toList()); List<Element> startMessageNext = childMessages .stream() .filter(f -> !f.source.$ref.equals(f.target.$ref)) .collect(Collectors.toList()); startMessage = startMessageNext.get(0); targetRef = startMessage.target.$ref; sourceRef = startMessage.source.$ref; parentMessage = nextMessage.get(0); if (childMessages.size() > 1) { endMessage = childMessages.get(childMessages.size() - 1); } } } } for (MethodInvocation methodInvocation : methodInvocations) { List<Operation> matchingOperation = operationsList .stream() .filter(f -> f._id.equals(methodInvocation.getSignature())) .collect(Collectors.toList()); if (matchingOperation.size() > 0) { operationMap.put(methodInvocation, matchingOperation.get(0)._id); methodInvocation.setOperation(matchingOperation.get(0)); } } Stack stack = new Stack(); for (MethodInvocation root : methodInvocations) { stack.push(root); while (!stack.empty()) { MethodInvocation methodInvocation = (MethodInvocation) stack.pop(); Operation currentOperation = methodInvocation.getOperation(); if (currentOperation != null) { // all child nodes of this node make up its body List<MethodInvocation> childNodes = methodInvocation.childNodes; for (MethodInvocation child : childNodes) { stack.push(child); } for (MethodInvocation childNode : childNodes) { if (childNode.getOperandId() != null) { List<Instruction> combinedFragmentsList = combinedFragments .stream() .filter(f -> f.getId().equals(childNode.getCfID())) .collect(Collectors.toList()); List<Guard> guardList = listOfGuards .stream() .filter(f -> f.id.equals(childNode.getOperandId())) .collect(Collectors.toList()); if (guardList.size() > 0) { Guard currentGuard = guardList.get(0); Instruction instruction = guardToCFMap.get(guardList.get(0)); // get the topmost CF if it is in a tree Instruction parent = instruction.getParent(); while (instruction.getParent() != null) { instruction = instruction.getParent(); } if (currentGuard.isConsequence) { Conditional conditional = (Conditional) instruction; if (!conditional.getConsequence().contains(childNode)) { conditional.getConsequence().add(childNode); } } if (currentGuard.isAlternative) { Conditional conditional = (Conditional) instruction; if (!conditional.getAlternative().contains(childNode)) { conditional.getAlternative().add(childNode); } } if (!currentGuard.isAlternative && !currentGuard.isConsequence) { Loop loop = (Loop) instruction; loop.getBlock().add(childNode); } else { if (!currentOperation.getBlock().contains(instruction)) { currentOperation.getBlock().add(instruction); } } } } else { if (!currentOperation.getBlock().contains(childNode)) { currentOperation.getBlock().add(childNode); } } } } } } } } } } // //// printAllData(metaClasses); // while (parentMessage.childNodes != null || parentMessage.childNodes.size() > 0) { // System.out.println("parent " + parentMessage.name); // for (com.cbpro.main.MethodInvocation child : parentMessage.childNodes) { // System.out.println("child " + child.name); // } // if (parentMessage.childNodes.size() > 0) { // parentMessage = parentMessage.childNodes.get(0); // } else { // break; // } // } mainPackage.print(); File dir = new File("/home/ramyashenoy/Desktop/DemoFolder/" + mainPackage.getName()); boolean successful = dir.mkdir(); if (successful) { System.out.println("directory was created successfully"); for (MetaClass metaClass : metaClasses) { if (metaClass.name.equals("Main")) { continue; } else { String data = metaClass.print(); BufferedWriter out = null; try { FileWriter fstream = new FileWriter( dir.getPath() + "/" + metaClass.name + ".java", true); // true tells to append data. out = new BufferedWriter(fstream); out.write(data); } catch (IOException e) { System.err.println("Error: " + e.getMessage()); } finally { if (out != null) { out.close(); } } } } } else { // creating the directory failed System.out.println("failed trying to create the directory"); } mainPackage.setClasses(metaClasses); }
/** * For all packages, find all sources belonging to the package, group the sources based on their * transformers and apply the transformers on each source code group. */ private boolean perform(File outputDir, Map<String, Transformer> suffixRules) { boolean rc = true; // Group sources based on transforms. A source file can only belong to a single transform. Map<Transformer, Map<String, Set<URI>>> groupedSources = new HashMap<>(); for (Source src : now.sources().values()) { Transformer t = suffixRules.get(src.suffix()); if (t != null) { if (taintedPackages.contains(src.pkg().name()) && !src.isLinkedOnly()) { addFileToTransform(groupedSources, t, src); } } } // Go through the transforms and transform them. for (Map.Entry<Transformer, Map<String, Set<URI>>> e : groupedSources.entrySet()) { Transformer t = e.getKey(); Map<String, Set<URI>> srcs = e.getValue(); // These maps need to be synchronized since multiple threads will be writing results into // them. Map<String, Set<URI>> packageArtifacts = Collections.synchronizedMap(new HashMap<String, Set<URI>>()); Map<String, Set<String>> packageDependencies = Collections.synchronizedMap(new HashMap<String, Set<String>>()); Map<String, String> packagePublicApis = Collections.synchronizedMap(new HashMap<String, String>()); boolean r = t.transform( srcs, visibleSrcs, visibleClasses, prev.dependents(), outputDir.toURI(), packageArtifacts, packageDependencies, packagePublicApis, 0, isIncremental(), numCores, out, err); if (!r) rc = false; for (String p : srcs.keySet()) { recompiledPackages.add(p); } // The transform is done! Extract all the artifacts and store the info into the Package // objects. for (Map.Entry<String, Set<URI>> a : packageArtifacts.entrySet()) { Module mnow = now.findModuleFromPackageName(a.getKey()); mnow.addArtifacts(a.getKey(), a.getValue()); } // Extract all the dependencies and store the info into the Package objects. for (Map.Entry<String, Set<String>> a : packageDependencies.entrySet()) { Set<String> deps = a.getValue(); Module mnow = now.findModuleFromPackageName(a.getKey()); mnow.setDependencies(a.getKey(), deps); } // Extract all the pubapis and store the info into the Package objects. for (Map.Entry<String, String> a : packagePublicApis.entrySet()) { Module mprev = prev.findModuleFromPackageName(a.getKey()); List<String> pubapi = Package.pubapiToList(a.getValue()); Module mnow = now.findModuleFromPackageName(a.getKey()); mnow.setPubapi(a.getKey(), pubapi); if (mprev.hasPubapiChanged(a.getKey(), pubapi)) { // Aha! The pubapi of this package has changed! // It can also be a new compile from scratch. if (mprev.lookupPackage(a.getKey()).existsInJavacState()) { // This is an incremental compile! The pubapi // did change. Trigger recompilation of dependents. packagesWithChangedPublicApis.add(a.getKey()); Log.info("The pubapi of " + Util.justPackageName(a.getKey()) + " has changed!"); } } } } return rc; }
private void unpackSegment(InputStream in, JarOutputStream out) throws IOException { _props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "0"); // Process the output directory or jar output. new PackageReader(pkg, in).read(); if (_props.getBoolean("unpack.strip.debug")) pkg.stripAttributeKind("Debug"); if (_props.getBoolean("unpack.strip.compile")) pkg.stripAttributeKind("Compile"); _props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "50"); pkg.ensureAllClassFiles(); // Now write out the files. HashSet classesToWrite = new HashSet(pkg.getClasses()); for (Iterator i = pkg.getFiles().iterator(); i.hasNext(); ) { Package.File file = (Package.File) i.next(); String name = file.nameString; JarEntry je = new JarEntry(Utils.getJarEntryName(name)); boolean deflate; deflate = (keepDeflateHint) ? (((file.options & Constants.FO_DEFLATE_HINT) != 0) || ((pkg.default_options & Constants.AO_DEFLATE_HINT) != 0)) : deflateHint; boolean needCRC = !deflate; // STORE mode requires CRC if (needCRC) crc.reset(); bufOut.reset(); if (file.isClassStub()) { Package.Class cls = file.getStubClass(); assert (cls != null); new ClassWriter(cls, needCRC ? crcOut : bufOut).write(); classesToWrite.remove(cls); // for an error check } else { // collect data & maybe CRC file.writeTo(needCRC ? crcOut : bufOut); } je.setMethod(deflate ? JarEntry.DEFLATED : JarEntry.STORED); if (needCRC) { if (verbose > 0) Utils.log.info("stored size=" + bufOut.size() + " and crc=" + crc.getValue()); je.setMethod(JarEntry.STORED); je.setSize(bufOut.size()); je.setCrc(crc.getValue()); } if (keepModtime) { je.setTime(file.modtime); // Convert back to milliseconds je.setTime((long) file.modtime * 1000); } else { je.setTime((long) modtime * 1000); } out.putNextEntry(je); bufOut.writeTo(out); out.closeEntry(); if (verbose > 0) Utils.log.info("Writing " + Utils.zeString((ZipEntry) je)); } assert (classesToWrite.isEmpty()); _props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "100"); pkg.reset(); // reset for the next segment, if any }
public String getPublicPropertiesForClasses(String classNames[]) { StringBuilder result = new StringBuilder(); String className = null; ArrayList publicFields = new ArrayList(); result.append("<classDefinitions>"); if (classNames != null && classNames.length > 0) { for (int i = 0; i < classNames.length; i++) { className = classNames[i]; if (className != null) { result.append("<classDefinition>"); try { Class c = Class.forName(className); Field fields[] = c.getFields(); Field field = null; if (fields != null) { for (int k = 0; k < fields.length; k++) { field = fields[k]; if (field != null) publicFields.add( (new StringBuilder(String.valueOf(field.getName()))) .append(",") .append(field.getType().getName()) .toString()); } } try { BeanInfo b = Introspector.getBeanInfo(c); result.append( (new StringBuilder("<classSimpleName>")) .append(c.getSimpleName()) .append("</classSimpleName>") .toString()); result.append( (new StringBuilder("<classFullName>")) .append(c.getName()) .append("</classFullName>") .toString()); Package pack = c.getPackage(); String packStr = ""; if (pack != null) packStr = pack.getName(); result.append( (new StringBuilder("<packageName>")) .append(packStr) .append("</packageName>") .toString()); PropertyDescriptor pds[] = b.getPropertyDescriptors(); if (pds != null) { for (int propCount = 0; propCount < pds.length; propCount++) { PropertyDescriptor pd = pds[propCount]; String propertyName = pd.getName(); Method readMethod = pd.getReadMethod(); Method writeMethod = pd.getWriteMethod(); if (readMethod != null && isPublicAccessor(readMethod.getModifiers()) && writeMethod != null && isPublicAccessor(writeMethod.getModifiers())) publicFields.add( (new StringBuilder(String.valueOf(propertyName))) .append(",") .append(pd.getPropertyType().getName()) .toString()); } } } catch (Exception e) { e.printStackTrace(); } if (publicFields != null && publicFields.size() > 0) { String temp = null; result.append("<publicFields>"); for (int counter = 0; counter < publicFields.size(); counter++) { temp = (String) publicFields.get(counter); if (temp != null) { String pubTemp[] = temp.split(","); if (pubTemp.length == 2) { result.append("<publicField>"); result.append( (new StringBuilder("<publicFieldName>")) .append(pubTemp[0]) .append("</publicFieldName>") .toString()); result.append( (new StringBuilder("<publicFieldType>")) .append(pubTemp[1]) .append("</publicFieldType>") .toString()); result.append("</publicField>"); } } } result.append("</publicFields>"); } } catch (ClassNotFoundException e) { result.append( (new StringBuilder("<classFullName>")) .append(className) .append("</classFullName>") .toString()); result.append( (new StringBuilder("<error>Problem retrieving ")) .append(className) .append(" information</error>") .toString()); System.out.println(e.getMessage()); } result.append("</classDefinition>"); } } } result.append("</classDefinitions>"); return result.toString(); }
public String getPublicMethodsForClasses(String classNames[]) { StringBuilder result = new StringBuilder(); String className = null; result.append("<classDefinitions>"); if (classNames != null && classNames.length > 0) { for (int i = 0; i < classNames.length; i++) { className = classNames[i]; if (className != null) { result.append("<classDefinition>"); try { Class c = Class.forName(className); result.append( (new StringBuilder("<classSimpleName>")) .append(c.getSimpleName()) .append("</classSimpleName>") .toString()); result.append( (new StringBuilder("<classFullName>")) .append(c.getName()) .append("</classFullName>") .toString()); Package pack = c.getPackage(); String packStr = ""; if (pack != null) packStr = pack.getName(); result.append( (new StringBuilder("<packageName>")) .append(packStr) .append("</packageName>") .toString()); Method methods[] = c.getMethods(); Method method = null; result.append("<methods>"); if (methods != null) { for (int j = 0; j < methods.length; j++) { method = methods[j]; if (method != null && !methodsExclude.contains(method.getName())) { result.append("<method>"); result.append( (new StringBuilder("<methodSignature>")) .append(method.toString()) .append("</methodSignature>") .toString()); result.append( (new StringBuilder("<methodName>")) .append(method.getName()) .append("</methodName>") .toString()); result.append( (new StringBuilder("<returnType>")) .append(method.getReturnType().getName()) .append("</returnType>") .toString()); Class paramClasses[] = method.getParameterTypes(); result.append("<params>"); if (paramClasses != null) { for (int l = 0; l < paramClasses.length; l++) if (paramClasses[l] != null) result.append( (new StringBuilder("<param>")) .append(paramClasses[l].getName()) .append("</param>") .toString()); } result.append("</params>"); result.append("</method>"); } } } result.append("</methods>"); } catch (ClassNotFoundException e) { result.append( (new StringBuilder("<classFullName>")) .append(className) .append("</classFullName>") .toString()); result.append( (new StringBuilder("<error>Problem retrieving ")) .append(className) .append(" information</error>") .toString()); System.out.println(e.getMessage()); } result.append("</classDefinition>"); } } } result.append("</classDefinitions>"); return result.toString(); }
/** Load a javac_state file. */ public static JavacState load( String[] args, File binDir, File gensrcDir, File headerDir, boolean permitUnidentifiedArtifacts, PrintStream out, PrintStream err) { JavacState db = new JavacState( args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, false, out, err); Module lastModule = null; Package lastPackage = null; Source lastSource = null; boolean noFileFound = false; boolean foundCorrectVerNr = false; boolean newCommandLine = false; boolean syntaxError = false; try (BufferedReader in = new BufferedReader(new FileReader(db.javacStateFilename))) { for (; ; ) { String l = in.readLine(); if (l == null) break; if (l.length() >= 3 && l.charAt(1) == ' ') { char c = l.charAt(0); if (c == 'M') { lastModule = db.prev.loadModule(l); } else if (c == 'P') { if (lastModule == null) { syntaxError = true; break; } lastPackage = db.prev.loadPackage(lastModule, l); } else if (c == 'D') { if (lastModule == null || lastPackage == null) { syntaxError = true; break; } lastPackage.loadDependency(l); } else if (c == 'I') { if (lastModule == null || lastPackage == null) { syntaxError = true; break; } lastPackage.loadPubapi(l); } else if (c == 'A') { if (lastModule == null || lastPackage == null) { syntaxError = true; break; } lastPackage.loadArtifact(l); } else if (c == 'S') { if (lastModule == null || lastPackage == null) { syntaxError = true; break; } lastSource = db.prev.loadSource(lastPackage, l, false); } else if (c == 'G') { if (lastModule == null || lastPackage == null) { syntaxError = true; break; } lastSource = db.prev.loadSource(lastPackage, l, true); } else if (c == 'R') { String ncmdl = "R " + db.theArgs; if (!l.equals(ncmdl)) { newCommandLine = true; } } else if (c == '#') { if (l.startsWith("# javac_state ver ")) { int sp = l.indexOf(" ", 18); if (sp != -1) { String ver = l.substring(18, sp); if (!ver.equals("0.3")) { break; } foundCorrectVerNr = true; } } } } } } catch (FileNotFoundException e) { // Silently create a new javac_state file. noFileFound = true; } catch (IOException e) { Log.info("Dropping old javac_state because of errors when reading it."); db = new JavacState( args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err); foundCorrectVerNr = true; newCommandLine = false; syntaxError = false; } if (foundCorrectVerNr == false && !noFileFound) { Log.info("Dropping old javac_state since it is of an old version."); db = new JavacState( args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err); } else if (newCommandLine == true && !noFileFound) { Log.info("Dropping old javac_state since a new command line is used!"); db = new JavacState( args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err); } else if (syntaxError == true) { Log.info("Dropping old javac_state since it contains syntax errors."); db = new JavacState( args, binDir, gensrcDir, headerDir, permitUnidentifiedArtifacts, true, out, err); } db.prev.calculateDependents(); return db; }
/** * Return the version of the main package of the framework. A version number is available if there * is a corresponding version entry in the JHotDraw jar file for the framework package. */ public static String getJHotDrawVersion() { // look for the framework main package Package pack = packages[4]; return pack.getSpecificationVersion(); }
/** * ** Returns an I18N instance based on the specified package name and Locale ** @param pkg The * resource package ** @param loc The Locale resource from with the localized text is loaded */ public static I18N getI18N(Package pkg, Locale loc) { return I18N.getI18N(pkg.getName(), loc); }
/** * Collection of utility methods that are useful for dealing with version information retrieved from * reading jar files or package loaded by the class manager. Some methods also help comparing * version information. The method getJHotDrawVersion() can be used to retrieve the current version * of JHotDraw as loaded by the class manager. * * @author Wolfram Kaiser * @version <$CURRENT_VERSION$> */ public class VersionManagement { public static String JHOTDRAW_COMPONENT = "CH.ifa.draw/"; public static String JHOTDRAW_JAR = "jhotdraw.jar"; public static Package[] packages = { Package.getPackage("CH.ifa.draw.applet"), Package.getPackage("CH.ifa.draw.application"), Package.getPackage("CH.ifa.draw.contrib"), Package.getPackage("CH.ifa.draw.figures"), Package.getPackage("CH.ifa.draw.framework"), Package.getPackage("CH.ifa.draw.standard"), Package.getPackage("CH.ifa.draw.util") }; /** * Return the version of the main package of the framework. A version number is available if there * is a corresponding version entry in the JHotDraw jar file for the framework package. */ public static String getJHotDrawVersion() { // look for the framework main package Package pack = packages[4]; return pack.getSpecificationVersion(); } /** */ public static String getPackageVersion(final Package lookupPackage) { if (lookupPackage == null) { return null; } String specVersion = lookupPackage.getSpecificationVersion(); if (specVersion != null) { return specVersion; } else { // search in parent package String normalizedPackageName = normalizePackageName(lookupPackage.getName()); String nextPackageName = getNextPackage(normalizedPackageName); return getPackageVersion(Package.getPackage(nextPackageName)); } } /** * Check whether a given application version is compatible with the version of JHotDraw currently * loaded in the Java VM. A version number is available if there is a corresponding version entry * in the JHotDraw jar file for the framework package. */ public static boolean isCompatibleVersion(String compareVersionString) { // Package pack = VersionManagement.class.getPackage(); Package pack = packages[4]; if (compareVersionString == null) { return pack.getSpecificationVersion() == null; } else { return pack.isCompatibleWith(compareVersionString); } } /** * Read the version information from a file with a given file name. The file must be a jar * manifest file and all its entries are searched for package names and their specification * version information. All information is collected in a map for later lookup of package names * and their versions. * * @param versionFileName name of the jar file containing version information */ public static String readVersionFromFile(String applicationName, String versionFileName) { try { FileInputStream fileInput = new FileInputStream(versionFileName); Manifest manifest = new Manifest(); manifest.read(fileInput); Map entries = manifest.getEntries(); // Now write out the pre-entry attributes Iterator entryIterator = entries.entrySet().iterator(); while (entryIterator.hasNext()) { Map.Entry currentEntry = (Map.Entry) entryIterator.next(); String packageName = currentEntry.getKey().toString(); packageName = normalizePackageName(packageName); Attributes attributes = (Attributes) currentEntry.getValue(); String packageSpecVersion = attributes.getValue(Attributes.Name.SPECIFICATION_VERSION); packageSpecVersion = extractVersionInfo(packageSpecVersion); return packageSpecVersion; } } catch (IOException exception) { exception.printStackTrace(); } // no version found return null; } /** * Get the super package of a package specifier. The super package is the package specifier * without the latest package name, e.g. the next package for "org.jhotdraw.tools" would be * "org.jhotdraw". * * @param searchPackage package specifier * @return next package if one is available, null otherwise */ public static String getNextPackage(String searchPackage) { if (searchPackage == null) { return null; } int foundNextPackage = searchPackage.lastIndexOf('.'); if (foundNextPackage > 0) { return searchPackage.substring(0, foundNextPackage); } else { return null; } } /** * A package name is normalized by replacing all path delimiters by "." to retrieve a valid * standardized package specifier used in package declarations in Java source files. * * @param toBeNormalized package name to be normalized * @return normalized package name */ public static String normalizePackageName(String toBeNormalized) { // first, replace the standard package delimiter used in jars String replaced = toBeNormalized.replace('/', '.'); // then, replace the default path separator in case this one was used as well replaced = replaced.replace(File.pathSeparatorChar, '.'); if (replaced.endsWith(".")) { int lastSeparator = replaced.lastIndexOf('.'); return replaced.substring(0, lastSeparator); } else { return replaced; } } /** * Get the version information specified in a jar manifest file without any leading or trailing * "\"". * * @param versionString a version string with possibly leading or trailing "\"" * @return stripped version information */ public static String extractVersionInfo(String versionString) { // guarding conditions if (versionString == null) { return null; } if (versionString.length() == 0) { return ""; } int startIndex = versionString.indexOf("\""); if (startIndex < 0) { startIndex = 0; } else { // start from next character startIndex++; } int endIndex = versionString.lastIndexOf("\""); if (endIndex < 0) { endIndex = versionString.length(); } return versionString.substring(startIndex, endIndex); } }