@Override
public boolean isEqualTo(Node o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return true;
}
/**
* Gets a node in this result that is an instance of the specified class. The node returned is the
* last node in the list (ordered parent to child) of nodes in this pick result that is an
* instance of the specified class. If no such node exists, this method returns null.
*
* @return the node; null, if none.
*/
public Node getNode(Class<?> nodeClass) {
for (int i = _nodes.length - 1; i >= 0; --i) {
Node node = _nodes[i];
if (nodeClass.isAssignableFrom(node.getClass())) return node;
}
return null;
}
public void process(int depth, Node node) {
if (depth == 0) {
references.traverse(node);
}
Processor processor = processors().get(node.getClass());
if (processor == null) {
log.warn("No processor defined for type {}", node.getClass());
processor = processorDefault;
}
treeNavigation.push(node);
dumpProcessor(depth, node, processor);
processor.process(depth, node, this);
treeNavigation.pop();
}
/**
* Allocate a new node
*
* @return
*/
@SuppressWarnings({"unchecked"})
protected Node newNode() {
try {
Node u = (Node) sampleNode.getClass().newInstance();
u.parent = u.child[0] = u.child[1] = null;
return u;
} catch (Exception e) {
return null;
}
}
public void testBasicNode() {
Node node;
node = new Node("n");
assertEquals("node-", node.getClass().getSimpleName().compareTo("Node"), 0);
assertEquals("name_", node.name_, "n");
assertEquals("nextNode_", node.nextNode_, null);
node.nextNode_ = node;
assertEquals("nextNode_ (after setting)", node.nextNode_, node);
}
public static boolean isValueNode(Node node) {
Class nodeClass = node.getClass();
return nodeClass == Node.class
|| nodeClass == ApplicationNode.class
|| nodeClass == ArrayNode.class
|| node instanceof PrimitiveNode
|| nodeClass == XMLNode.class
|| nodeClass == XMLListNode.class
|| nodeClass == ModelNode.class
|| nodeClass == InlineComponentNode.class;
}
/**
* Determines if the object is a Literal or Resource and returns an iTQL representation.
*
* <p>Throws an Exception if the ObjectNode is a BlankNode
*
* @param node ObjectNode
* @return String
*/
protected String asString(Node node) {
if (node == null) {
throw new IllegalArgumentException("Node is null");
}
// determine type and convert to String
if (node instanceof URIReference) {
return " <" + ((URIReference) node).getURI() + ">";
} else if (node instanceof Literal) {
return " '" + escape(((Literal) node).getLexicalForm()) + "'";
} else {
// probably a BlankNode
throw new IllegalArgumentException("Unsupported Node type: " + node.getClass().getName());
}
}
@Override
public String toString() {
if (problemNode == null && getMessage() == null) return "ResolutionException (unknown cause)";
if (problemNode == null) return "AstException: " + getMessage();
String nodeDescription =
problemNode == null ? "(null)" : (problemNode.getClass().getName() + "(toString failed)");
try {
nodeDescription = problemNode.toString();
} catch (Throwable ignore) {
// throwing exceptions in toString() is bad.
}
if (getMessage() == null) return "ResolutionException at " + nodeDescription;
return String.format("ResolutionException: %s (at %s)", getMessage(), nodeDescription);
}
@Override
public boolean jjtCompareTo(Node node) {
boolean result;
ASTObjectList simpleNode = null;
if (this.getClass() == node.getClass()) {
simpleNode = (ASTObjectList) node;
if (this.jjtGetNumChildren() == simpleNode.jjtGetNumChildren()) {
if (this.jjtGetNumChildren() != 0) {
for (int i = 0; i < this.jjtGetNumChildren(); i++) {
result = this.jjtGetChild(i).jjtCompareTo(simpleNode.jjtGetChild(i));
if (result) {
continue;
} else return false;
}
return true;
} else return true;
} else return false;
} else return false;
}
private Node replaceNormalNode(
Node normalNode, GKInstance diseaseEntity, Boolean needDashedBorder) {
Node diseaseNode = normalToDiseaseNode.get(normalNode);
if (diseaseNode != null) return diseaseNode;
try {
// If a node exists already, it should use
for (Renderable r : diseaseComps) {
if (diseaseEntity.getDBID().equals(r.getReactomeId()) && r instanceof Node) {
// This is rather arbitrary: if two nodes are very close,
// use the existing one.
int dx = Math.abs(r.getPosition().x - normalNode.getPosition().x);
int dy = Math.abs(r.getPosition().y - normalNode.getPosition().y);
if (dx < 10 && dy < 10) {
// We don't need to create a new Node if it exists already
normalToDiseaseNode.put(normalNode, (Node) r);
overlaidObjects.add(r); // Add it to overlaid object to cover edges
return (Node) r;
}
}
}
diseaseNode = normalNode.getClass().newInstance();
RenderUtility.copyRenderInfo(normalNode, diseaseNode);
// The following should NOT be called since NodeAttachment is
// related to disease entity only.
// TODO: Need to support this. Currently it is not supported!!! See example
// in PI3/AKT cancer pathway.
// diseaseNode.setNodeAttachmentsLocally(node.getNodeAttachments());
diseaseNode.setDisplayName(diseaseEntity.getDisplayName());
diseaseNode.setReactomeId(diseaseEntity.getDBID());
diseaseNode.invalidateBounds();
diseaseNode.setRenderer(normalNode.getRenderer());
diseaseNode.setLineColor(DefaultRenderConstants.DEFAULT_DISEASE_BACKGROUND);
diseaseNode.setNeedDashedBorder(needDashedBorder);
RenderUtility.hideCompartmentInNodeName(diseaseNode);
overlaidObjects.add(diseaseNode);
displayedObject.addComponent(diseaseNode);
normalToDiseaseNode.put(normalNode, diseaseNode);
return diseaseNode;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public void invoke(Node node) {
Class nodeClass = node.getClass();
if (nodeClass == Node.class || nodeClass == ApplicationNode.class) {
componentNode(node);
} else if (nodeClass == ArrayNode.class) {
arrayNode((ArrayNode) node);
} else if (node instanceof PrimitiveNode) {
primitiveNode((PrimitiveNode) node);
} else if (nodeClass == XMLNode.class) {
xmlNode((XMLNode) node);
} else if (nodeClass == XMLListNode.class) {
xmlListNode((XMLListNode) node);
} else if (nodeClass == ModelNode.class) {
modelNode((ModelNode) node);
} else if (nodeClass == InlineComponentNode.class) {
inlineComponentNode((InlineComponentNode) node);
} else {
assert !isValueNode(node) : "value node class not handled by invoke()";
unknown(node);
}
}
/**
* Resolve a constraint against an RDF/XML document.
*
* <p>Resolution is by filtration of a URL stream, and thus very slow.
*/
public Resolution resolve(Constraint constraint) throws QueryException {
if (logger.isDebugEnabled()) {
logger.debug("Resolve " + constraint);
}
// Validate "constraint" parameter
if (constraint == null) {
throw new IllegalArgumentException("Null \"constraint\" parameter");
}
if (!(constraint.getModel() instanceof LocalNode)) {
if (logger.isDebugEnabled()) logger.debug("Ignoring solutions for " + constraint);
return new EmptyResolution(constraint, false);
}
if (!(constraint.getElement(1) instanceof LocalNode)
|| !(constraint.getElement(2) instanceof LocalNode)) {
throw new QueryException(
"Prefix resolver can only be used for fixed prefixes: " + constraint);
}
try {
long property = ((LocalNode) constraint.getElement(1)).getValue();
LocalNode object = (LocalNode) constraint.getElement(2);
Node prefixNode = resolverSession.globalize(object.getValue());
// check the constraint for consistency
if ((property != mulgaraPrefix && property != mulgaraStringPrefix)
|| !(prefixNode instanceof Literal || prefixNode instanceof URIReference)) {
logger.debug("property = " + property + ", mulgaraPrefix = " + mulgaraPrefix);
logger.debug("element(2): " + prefixNode + " [" + prefixNode.getClass().getName() + "]");
throw new QueryException(
"Prefix resolver can only be used for prefix constraints: " + constraint);
}
if (logger.isDebugEnabled()) {
logger.debug(
"Evaluating " + constraint.getElement(0) + " has prefix " + constraint.getElement(2));
}
ConstraintElement node = constraint.getElement(0);
assert node != null;
Tuples tuples;
if (node instanceof Variable) {
// convert the prefix into a string pool object
SPObjectFactory spoFact = SPObjectFactoryImpl.getInstance();
SPObject startPrefixObj = getStartObject(spoFact, prefixNode, property);
SPObject endPrefixObj = getEndObject(spoFact, prefixNode, property);
// get the extents of the prefix from the string pool
tuples = resolverSession.findStringPoolRange(startPrefixObj, true, endPrefixObj, false);
assert tuples != null;
// rename variables away from subject, predicate and object
tuples.renameVariables(constraint);
long resultSize;
try {
// Get the size of the final result.
resultSize = tuples.getRowCount();
} catch (TuplesException e) {
throw new QueryException("Unable to build result", e);
}
if (logger.isDebugEnabled()) {
try {
logger.debug(
"tuples size = " + tuples.getRowCount() + " (should be " + resultSize + ")");
} catch (TuplesException e) {
logger.debug("Error getting the length of the tuples object");
}
}
return new TuplesWrapperResolution(tuples, constraint);
} else { // if (node instanceof Variable)
// node must therefore be an instanceof LocalNode
// we can shortcut the process here
assert node instanceof LocalNode;
LocalNode n = (LocalNode) node;
// get the node out of the string pool
SPObject spo = resolverSession.findStringPoolObject(n.getValue());
// check that the node exists
if (spo == null) {
tuples = TuplesOperations.empty();
} else {
// see if the node starts with the required prefix
String prefix;
// extract the string from the literal
if (prefixNode instanceof Literal) {
prefix = ((Literal) prefixNode).getLexicalForm();
} else {
prefix = ((URIReference) prefixNode).getURI().toString();
}
if (spo.getLexicalForm().startsWith(prefix)) {
tuples = TuplesOperations.unconstrained();
} else {
tuples = TuplesOperations.empty();
}
}
}
// convert the tuples to a resolution
return new TuplesWrapperResolution(tuples, constraint);
} catch (GlobalizeException ge) {
throw new QueryException("Couldn't convert internal data into a string", ge);
} catch (StringPoolException e) {
throw new QueryException("Couldn't query constraint", e);
}
}
/**
* Read Node config from file config.nodeConfigFileName, including available nodes and their
* possible connections
*/
public NodeFactory(Config config, ProblemData problemData) {
this.config = config;
this.problemData = problemData;
try {
FileInputStream in = new FileInputStream(config.nodeConfigFileName);
Properties props = new Properties();
props.load(in);
in.close();
String separator = "\\s*,\\s*";
String tmp = props.getProperty("sets");
String[] sets = tmp.split(separator);
nodeSets = new NodeSet[sets.length];
int i, j, k;
for (i = 0; i < sets.length; i++) {
nodeSets[i] = new NodeSet(sets[i]);
String[] nodes;
tmp = props.getProperty(sets[i] + "Functions");
if (tmp == null)
Logger.log(
"Warning: when reading "
+ config.nodeConfigFileName
+ ", no functions found for set "
+ sets[i]);
else {
nodes = tmp.split(separator);
for (j = 0; j < nodes.length; j++) {
Class cl = Class.forName("gpalta.nodes." + nodes[j]);
java.lang.reflect.Constructor co = cl.getConstructor();
nodeSets[i].addFunction((Node) co.newInstance());
}
}
tmp = props.getProperty(sets[i] + "Terminals");
if (tmp == null)
Logger.log(
"Warning: when reading "
+ config.nodeConfigFileName
+ ", no terminals found for set "
+ sets[i]);
else {
nodes = tmp.split(separator);
for (j = 0; j < nodes.length; j++) {
Class cl = Class.forName("gpalta.nodes." + nodes[j]);
if (nodes[j].contains("Var")) {
for (k = 0; k < problemData.nVars; k++) {
java.lang.reflect.Constructor[] co = cl.getConstructors();
nodeSets[i].addTerminal((Node) co[0].newInstance(k + 1));
}
} else if (nodes[j].contains("Angle")) {
for (k = 0; k < problemData.nVars - 1; k++) {
java.lang.reflect.Constructor[] co = cl.getConstructors();
nodeSets[i].addTerminal((Node) co[0].newInstance(k + 1));
}
} else {
java.lang.reflect.Constructor co = cl.getConstructor();
nodeSets[i].addTerminal((Node) co.newInstance());
}
}
}
}
for (i = 0; i < nodeSets.length; i++) {
for (Node n : nodeSets[i].getAll()) {
n.setType(nodeSets[i]);
}
}
for (i = 0; i < nodeSets.length; i++) {
for (Node n : nodeSets[i].getAll()) {
tmp = props.getProperty("kids" + n.getClass().getSimpleName());
if (tmp != null) {
String[] kids = tmp.split(separator);
if (kids.length != n.nKids()) {
Logger.log(
"Error reading "
+ config.nodeConfigFileName
+ ": must specify "
+ n.nKids()
+ " kids for "
+ n.getClass().getSimpleName());
}
for (j = 0; j < n.nKids(); j++) {
for (k = 0; k < nodeSets.length; k++) {
if (nodeSets[k].getName().equals(kids[j])) {
n.setTypeOfKids(j, nodeSets[k]);
break;
}
}
if (k == nodeSets.length)
Logger.log(
"Error reading "
+ config.nodeConfigFileName
+ ": Setting kids for "
+ n.getClass().getSimpleName()
+ ", "
+ kids[j]
+ " doesn't match any set name");
}
} else for (j = 0; j < n.nKids(); j++) n.setTypeOfKids(j, nodeSets[i]);
}
}
tmp = props.getProperty("treeRoot");
if (tmp == null) {
Logger.log(
"Error reading " + config.nodeConfigFileName + ": property \"treeRoot\" not present");
}
for (i = 0; i < nodeSets.length; i++) {
if (nodeSets[i].getName().equals(tmp)) {
treeRoot = nodeSets[i];
break;
}
}
if (i == nodeSets.length)
Logger.log(
"Error reading "
+ config.nodeConfigFileName
+ ": Setting treeRoot, "
+ tmp
+ " doesn't match any set name");
} catch (IOException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
} catch (ClassNotFoundException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
} catch (NoSuchMethodException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
} catch (InstantiationException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
} catch (IllegalAccessException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
} catch (InvocationTargetException e) {
Logger.log("Error reading " + config.nodeConfigFileName + ":");
Logger.log(e);
}
}
public void defaultCase(Node node) {
if (logger.isDebugEnabled())
logger.debug("Found node in pred builder: " + node + "::" + node.getClass());
}
private static List<Node> doInsert(
Node insertionNode,
List<Node> clonedNodes,
XFormsInstance modifiedInstance,
boolean doDispatch) {
final List<Node> insertedNodes = new ArrayList<Node>(clonedNodes.size());
if (insertionNode instanceof Element) {
// Insert inside an element
final Element insertContextElement = (Element) insertionNode;
int otherNodeIndex = 0;
for (Node clonedNode : clonedNodes) {
if (clonedNode != null) { // NOTE: we allow passing some null nodes so we check on null
if (clonedNode instanceof Attribute) {
// Add attribute to element
// NOTE: In XML, attributes are unordered. dom4j handles them as a list so has order,
// but the
// XForms spec shouldn't rely on attribute order. We could try to keep the order, but it
// is harder
// as we have to deal with removing duplicate attributes and find a reasonable insertion
// strategy.
final Attribute clonedAttribute = (Attribute) clonedNode;
final Attribute existingAttribute =
insertContextElement.attribute(clonedAttribute.getQName());
if (existingAttribute != null) insertContextElement.remove(existingAttribute);
insertContextElement.add(clonedAttribute);
if (existingAttribute != null) {
// Dispatch xxforms-replace event if required and possible
// NOTE: For now, still dispatch xforms-insert for backward compatibility.
if (doDispatch && modifiedInstance != null) {
final DocumentWrapper documentWrapper =
(DocumentWrapper) modifiedInstance.documentInfo();
Dispatch.dispatchEvent(
new XXFormsReplaceEvent(
modifiedInstance,
documentWrapper.wrap(existingAttribute),
documentWrapper.wrap(clonedAttribute)));
}
}
insertedNodes.add(clonedAttribute);
} else if (!(clonedNode instanceof Document)) {
// Add other node to element
insertContextElement.content().add(otherNodeIndex++, clonedNode);
insertedNodes.add(clonedNode);
} else {
// "If a cloned node cannot be placed at the target location due to a node type
// conflict, then the
// insertion for that particular clone node is ignored."
}
}
}
return insertedNodes;
} else if (insertionNode instanceof Document) {
final Document insertContextDocument = (Document) insertionNode;
// "If there is more than one cloned node to insert, only the first node that does not cause a
// conflict is
// considered."
for (Node clonedNode : clonedNodes) {
// Only an element can be inserted at the root of an instance
if (clonedNode instanceof Element) {
final Element formerRootElement = insertContextDocument.getRootElement();
insertContextDocument.setRootElement((Element) clonedNode);
// Dispatch xxforms-replace event if required and possible
// NOTE: For now, still dispatch xforms-insert for backward compatibility.
if (doDispatch && modifiedInstance != null) {
final DocumentWrapper documentWrapper =
(DocumentWrapper) modifiedInstance.documentInfo();
Dispatch.dispatchEvent(
new XXFormsReplaceEvent(
modifiedInstance,
documentWrapper.wrap(formerRootElement),
documentWrapper.wrap(insertContextDocument.getRootElement())));
}
insertedNodes.add(clonedNode);
return insertedNodes;
}
}
// NOTE: The spec does not allow inserting comments and PIs at the root of an instance
// document at this
// point.
return insertedNodes;
} else {
throw new OXFException(
"Unsupported insertion node type: " + insertionNode.getClass().getName());
}
}