private void addDefaultValues(Map attributes, Map mappings) {
if (mappings == null) return;
Iterator i = mappings.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
TagMap.AttributeMapping m = (TagMap.AttributeMapping) e.getValue();
if (null != m && null != m.getDefaultValue() && null == attributes.get(m.getPropertyName()))
attributes.put(m.getPropertyName(), m.getDefaultValue());
}
}
private void checkForRequiredAttributes(String tagName, Map attributes, Map mappings)
throws ParserException {
if (mappings == null) return;
Iterator i = mappings.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
TagMap.AttributeMapping m = (TagMap.AttributeMapping) e.getValue();
if (null != m && m.getRequired())
if (null == mappings || null == attributes.get(m.getPropertyName()))
throw new ParserException(
"An attribute that maps to property name: "
+ m.getPropertyName()
+ " is required and was not specified for tag:"
+ tagName
+ "!");
}
}
private void processTxt(Node operation) {
List<Node> targets = getChildNodes(operation, "target");
List<Node> optionNodes = getChildNodes(operation, "opt");
List<Node> separatorNode = getChildNodes(operation, "separator");
if (targets.isEmpty() || optionNodes.isEmpty()) {
return;
}
String defaultSeparator = "=";
String globalSeparator = defaultSeparator;
if (!separatorNode.isEmpty()) {
globalSeparator = separatorNode.get(0).getTextContent();
if (globalSeparator.length() != 1) {
globalSeparator = defaultSeparator;
}
}
Map<String, String> options = new HashMap<String, String>();
Map<String, String> processedOptions = new HashMap<String, String>();
for (int i = 0; i < optionNodes.size(); i++) {
Node option = optionNodes.get(i);
String name = option.getAttributes().getNamedItem("name").getNodeValue();
String value = option.getTextContent();
if (options.containsKey(name)) {
options.remove(name);
}
options.put(name, value);
}
for (int t = 0; t < targets.size(); t++) {
File target = new File(absolutePath(targets.get(t).getTextContent()));
File tmpFile = new File(Utils.timestamp());
BufferedWriter bw = null;
BufferedReader br = null;
try {
Node separatorAttr = targets.get(t).getAttributes().getNamedItem("separator");
String separator = (separatorAttr == null) ? globalSeparator : separatorAttr.getNodeValue();
if (separator.length() != 1) {
separator = globalSeparator;
}
bw = new BufferedWriter(new FileWriter(tmpFile));
if (target.exists()) {
br = new BufferedReader(new FileReader(target));
for (String line; (line = br.readLine()) != null; ) {
String[] parts = line.split(separator);
if (parts.length < 2) {
bw.write(line);
bw.newLine();
continue;
}
String optName = parts[0].trim();
if (options.containsKey(optName)) {
String optValue = options.get(optName);
bw.write(optName + " " + separator + " " + optValue);
bw.newLine();
processedOptions.put(optName, optValue);
options.remove(optName);
} else if (processedOptions.containsKey(optName)) {
bw.write(optName + " " + separator + " " + processedOptions.get(optName));
bw.newLine();
} else {
bw.write(line);
bw.newLine();
}
}
br.close();
}
for (Map.Entry<String, String> entry : options.entrySet()) {
bw.write(entry.getKey() + " " + separator + " " + entry.getValue());
bw.newLine();
}
bw.close();
FileUtils.copyFile(tmpFile, target);
FileUtils.forceDelete(tmpFile);
} catch (IOException ex) {
Utils.onError(new Error.WriteTxtConfig(target.getPath()));
}
}
}
public void buildTypeGraph() {
Map<String, JarFile> openJarFiles = new HashMap<String, JarFile>();
Map<String, File> openClassFiles = new HashMap<String, File>();
// use global cache to load resource in/out of the same jar as the classes
Set<String> resourceCacheSet = new HashSet<>();
try {
for (String path : pathsToScan) {
File f = null;
try {
f = new File(path);
if (!f.exists()
|| f.isDirectory()
|| (!f.getName().endsWith("jar") && !f.getName().endsWith("class"))) {
continue;
}
if (GENERATED_CLASSES_JAR.equals(f.getName())) {
continue;
}
if (f.getName().endsWith("class")) {
typeGraph.addNode(f);
openClassFiles.put(path, f);
} else {
JarFile jar = new JarFile(path);
openJarFiles.put(path, jar);
java.util.Enumeration<JarEntry> entriesEnum = jar.entries();
while (entriesEnum.hasMoreElements()) {
final java.util.jar.JarEntry jarEntry = entriesEnum.nextElement();
String entryName = jarEntry.getName();
if (jarEntry.isDirectory()) {
continue;
}
if (entryName.endsWith("-javadoc.xml")) {
try {
processJavadocXml(jar.getInputStream(jarEntry));
// break;
} catch (Exception ex) {
LOG.warn("Cannot process javadoc {} : ", entryName, ex);
}
} else if (entryName.endsWith(".class")) {
TypeGraph.TypeGraphVertex newNode = typeGraph.addNode(jarEntry, jar);
// check if any visited resources belong to this type
for (Iterator<String> iter = resourceCacheSet.iterator(); iter.hasNext(); ) {
String entry = iter.next();
if (entry.startsWith(entryName.substring(0, entryName.length() - 6))) {
newNode.setHasResource(true);
iter.remove();
}
}
} else {
String className = entryName;
boolean foundClass = false;
// check if this resource belongs to any visited type
while (className.contains("/")) {
className = className.substring(0, className.lastIndexOf('/'));
TypeGraph.TypeGraphVertex tgv = typeGraph.getNode(className.replace('/', '.'));
if (tgv != null) {
tgv.setHasResource(true);
foundClass = true;
break;
}
}
if (!foundClass) {
resourceCacheSet.add(entryName);
}
}
}
}
} catch (IOException ex) {
LOG.warn("Cannot process file {}", f, ex);
}
}
typeGraph.trim();
typeGraph.updatePortTypeInfoInTypeGraph(openJarFiles, openClassFiles);
} finally {
for (Entry<String, JarFile> entry : openJarFiles.entrySet()) {
try {
entry.getValue().close();
} catch (IOException e) {
DTThrowable.wrapIfChecked(e);
}
}
}
}