/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.oodt.cas.pushpull.filerestrictions.parsers;
//OODT imports
import org.apache.oodt.cas.metadata.util.PathUtils;
import org.apache.oodt.cas.pushpull.filerestrictions.Parser;
import org.apache.oodt.cas.pushpull.filerestrictions.VirtualFile;
import org.apache.oodt.cas.pushpull.filerestrictions.VirtualFileStructure;
import org.apache.oodt.cas.pushpull.exceptions.ParserException;
import org.apache.oodt.cas.pushpull.expressions.GlobalVariables;
import org.apache.oodt.cas.pushpull.expressions.Method;
import org.apache.oodt.cas.pushpull.expressions.Variable;
//JDK imports
import java.io.FileInputStream;
import java.util.HashMap;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.DOMException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
/**
*
* @author bfoster
* @version $Revision$
*
* <p>
* Describe your class here
* </p>.
*/
public class DirStructXmlParser implements Parser {
private static final Logger LOG = Logger.getLogger(DirStructXmlParser.class
.getName());
private static final HashMap<String, Method> methodRepo = new HashMap<String, Method>();
public DirStructXmlParser() {}
public VirtualFileStructure parse(FileInputStream xmlFile)
throws ParserException {
try {
String initialCdDir = "/";
VirtualFile root = null;
NodeList list = (DocumentBuilderFactory.newInstance()
.newDocumentBuilder().parse(new InputSource(xmlFile)))
.getDocumentElement().getChildNodes();
VirtualFile currentFile = null;
for (int i = 0; i < list.getLength(); i++) {
Node node = list.item(i);
if (node.getNodeName().equals("dirstruct")) {
// parse out starting path
String startingPath = ((Element) node)
.getAttribute("starting_path");
if (startingPath != null) {
root = (currentFile = new VirtualFile(
initialCdDir = startingPath, true))
.getRootDir();
VirtualFile temp = currentFile.getParentFile();
while (temp != null) {
temp.setNoDirs(true);
temp.setNoFiles(true);
temp = temp.getParentFile();
}
} else {
currentFile = root = VirtualFile.createRootDir();
}
// parse the directory structure
parseDirstructXML(node.getChildNodes(), currentFile);
} else if (node.getNodeName().equals("variables")) {
parseVariablesXML(node.getChildNodes());
} else if (node.getNodeName().equals("methods")) {
parseMethodsXML(node.getChildNodes());
}
}
return new VirtualFileStructure(initialCdDir, root);
} catch (Exception e) {
e.printStackTrace();
throw new ParserException("Failed to parse XML file : "
+ e.getMessage());
}
}
private void parseDirstructXML(NodeList list, VirtualFile currentLoadFile) {
for (int i = 0; i < list.getLength(); i++) {
Node dir = list.item(i);
if (dir.getNodeName().equals("dir")) {
String dirName = replaceVariablesAndMethods(((Element) dir)
.getAttribute("name"));
currentLoadFile.addChild(new VirtualFile(dirName, true));
NodeList children;
if ((children = dir.getChildNodes()).getLength() > 0) {
parseDirstructXML(children, currentLoadFile.getChild(
dirName, true));
}
} else if (dir.getNodeName().equals("nodirs")) {
currentLoadFile.setNoDirs(true);
} else if (dir.getNodeName().equals("nofiles")) {
currentLoadFile.setNoFiles(true);
} else if (dir.getNodeName().equals("file")) {
VirtualFile vf = new VirtualFile(
replaceVariablesAndMethods(((Element) dir)
.getAttribute("name")), false);
vf.setNoDirs(true);
currentLoadFile.addChild(vf);
}
}
}
private String replaceVariablesAndMethods(String input) {
for (int i = 0; i < input.length(); i++) {
char c = input.substring(i, i + 1).charAt(0);
switch (c) {
case '$':
try {
if (input.substring(i + 1, i + 2).charAt(0) == '{') {
StringBuffer variable = new StringBuffer("");
for (int j = i + 1; j < input.length(); j++) {
char ch = input.substring(j, j + 1).charAt(0);
if ((ch <= 'Z' && ch >= 'A')
|| (ch <= '9' && ch >= '0') || ch == '_')
variable.append(ch);
else
break;
}
Variable v = GlobalVariables.hashMap.get(variable
.toString());
input = input.replaceFirst("${" + variable + "}", v
.toString());
i = i + v.toString().length();
}
} catch (Exception e) {
}
break;
case '%':
try {
StringBuffer method = new StringBuffer("");
int j = i + 1;
for (; j < input.length(); j++) {
char ch = input.substring(j, j + 1).charAt(0);
if ((ch <= 'Z' && ch >= 'A')
|| (ch <= 'z' && ch >= 'a')
|| (ch <= '9' && ch >= '0') || ch == '_')
method.append(ch);
else
break;
}
if (input.substring(j, j + 1).charAt(0) == '(') {
Method m = methodRepo.get(method.toString());
StringTokenizer st = new StringTokenizer(input
.substring(j, input.substring(j).indexOf(")")
+ j), "#\", ()");
while (st.hasMoreTokens()) {
String arg = st.nextToken();
m.addArg(null, arg);
}
String returnValue = m.execute().toString();
input = input.substring(0, i)
+ returnValue
+ input.substring(input.substring(i).indexOf(
")")
+ 1 + i);
i = i + returnValue.length();
} else {
LOG.log(Level.SEVERE, "Invalid method signature in "
+ input + " near " + method);
break;
}
} catch (Exception e) {
}
break;
}
}
return input;
}
private void parseVariablesXML(NodeList list) throws DOMException, Exception {
// loop through all variable elements
for (int i = 0; i < list.getLength(); i++) {
Node node = list.item(i);
// parse variable element
if (node.getNodeName().equals("variable")) {
NodeList children = node.getChildNodes();
// create Variable Object
String variableName = ((Element) node).getAttribute("name");
Variable variable = new Variable(variableName);
// loop through to fill Variable
String type = null, value = null;
for (int j = 0; j < children.getLength(); j++) {
Node child = children.item(j);
// get the Variable's name
if (child.getNodeName().equals("type")) {
type = child.getTextContent().toLowerCase();
// get the Variable's value
} else if (child.getNodeName().equals("value")) {
value = PathUtils.doDynamicReplacement(child
.getTextContent());
// get the Variable's value's precision infomation
} else if (child.getNodeName().equals("precision")) {
NodeList grandChildren = child.getChildNodes();
for (int k = 0; k < grandChildren.getLength(); k++) {
Node grandChild = grandChildren.item(k);
// get the precision
if (grandChild.getNodeName().equals("locations")) {
variable.setPrecision(Integer
.parseInt(grandChild.getTextContent()));
// get the fill character to meet the precision
// [optional]
} else if (grandChild.getNodeName().equals("fill")) {
variable.setFillString(grandChild
.getTextContent());
// get the side for which the fill character
// will be applied [optional]
} else if (grandChild.getNodeName().equals("side")) {
variable.setFillSide((grandChild
.getTextContent().toLowerCase()
.equals("front")) ? variable.FILL_FRONT
: variable.FILL_BACK);
}
}
}
}
// determine if variable is an Integer or a String
if (type.equals("int")) {
variable.setValue(new Integer(value));
} else
variable.setValue(value);
// store Variable in list of Variables
GlobalVariables.hashMap.put(variable.getName(), variable);
}
}
}
private void parseMethodsXML(NodeList list) {
// loop though all method elements
for (int i = 0; i < list.getLength(); i++) {
Node node = list.item(i);
// parse method element
if (node.getNodeName().equals("method")) {
NodeList children = node.getChildNodes();
// create Method Object
String methodName = ((Element) node).getAttribute("name");
Method method = new Method(methodName);
// loop through to fill Method Object
for (int j = 0; j < children.getLength(); j++) {
Node child = children.item(j);
// get the Method's behavoir
if (child.getNodeName().equals("action")) {
method.setBehavoir(child.getTextContent());
// get the Method's arguments
} else if (child.getNodeName().equals("args")) {
String name, argType = null;
NodeList grandChildren = child.getChildNodes();
// loop for every arg element
for (int k = 0; k < grandChildren.getLength(); k++) {
Node grandChild = grandChildren.item(k);
// parse arg element
if (grandChild.getNodeName().equals("arg")) {
name = ((Element) grandChild)
.getAttribute("name");
// get arg element properties
NodeList greatGrandChildren = grandChild
.getChildNodes();
for (int l = 0; l < greatGrandChildren
.getLength(); l++) {
Node greatGrandChild = greatGrandChildren
.item(l);
if (greatGrandChild.getNodeName().equals(
"type")) {
argType = greatGrandChild
.getTextContent();
}
}
// create argument signature in Method
method
.addArgSignature(
name,
((argType.toLowerCase()
.equals("int")) ? method.INT
: method.STRING));
}
}
}
}
// store Method in list of Methods
methodRepo.put(method.getName(), method);
}
}
}
}