NodePointer.java
/*
* 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
*
* https://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.commons.jxpath.ri.model;
import java.util.HashSet;
import java.util.Locale;
import org.apache.commons.jxpath.AbstractFactory;
import org.apache.commons.jxpath.ExceptionHandler;
import org.apache.commons.jxpath.JXPathContext;
import org.apache.commons.jxpath.JXPathException;
import org.apache.commons.jxpath.JXPathNotFoundException;
import org.apache.commons.jxpath.NodeSet;
import org.apache.commons.jxpath.Pointer;
import org.apache.commons.jxpath.ri.Compiler;
import org.apache.commons.jxpath.ri.JXPathContextReferenceImpl;
import org.apache.commons.jxpath.ri.NamespaceResolver;
import org.apache.commons.jxpath.ri.QName;
import org.apache.commons.jxpath.ri.compiler.NodeNameTest;
import org.apache.commons.jxpath.ri.compiler.NodeTest;
import org.apache.commons.jxpath.ri.compiler.NodeTypeTest;
import org.apache.commons.jxpath.ri.model.beans.NullPointer;
/**
* Common superclass for Pointers of all kinds. A NodePointer maps to a deterministic XPath that represents the location of a node in an object graph. This
* XPath uses only simple axes: child, namespace and attribute and only simple, context-independent predicates.
*/
public abstract class NodePointer implements Pointer {
/** Serialization version */
private static final long serialVersionUID = 8117201322861007777L;
/** Whole collection index. */
public static final int WHOLE_COLLECTION = Integer.MIN_VALUE;
/** Constant to indicate unknown namespace */
public static final String UNKNOWN_NAMESPACE = "<<unknown namespace>>";
/**
* Allocates an new child NodePointer by iterating through all installed NodePointerFactories until it finds one that can create a pointer.
*
* @param parent pointer
* @param qName QName
* @param bean Object
* @return NodePointer
*/
public static NodePointer newChildNodePointer(final NodePointer parent, final QName qName, final Object bean) {
final NodePointerFactory[] factories = JXPathContextReferenceImpl.getNodePointerFactories();
for (final NodePointerFactory element : factories) {
final NodePointer pointer = element.createNodePointer(parent, qName, bean);
if (pointer != null) {
return pointer;
}
}
throw new JXPathException("Could not allocate a NodePointer for object of " + bean.getClass());
}
/**
* Allocates an entirely new NodePointer by iterating through all installed NodePointerFactories until it finds one that can create a pointer.
*
* @param qName QName
* @param bean Object
* @param locale Locale
* @return NodePointer
*/
public static NodePointer newNodePointer(final QName qName, final Object bean, final Locale locale) {
NodePointer pointer;
if (bean == null) {
pointer = new NullPointer(qName, locale);
return pointer;
}
final NodePointerFactory[] factories = JXPathContextReferenceImpl.getNodePointerFactories();
for (final NodePointerFactory element : factories) {
pointer = element.createNodePointer(qName, bean, locale);
if (pointer != null) {
return pointer;
}
}
throw new JXPathException("Could not allocate a NodePointer for object of " + bean.getClass());
}
/**
* Print deep
*
* @param pointer to print
* @param indent indentation level
*/
private static void printDeep(final NodePointer pointer, final String indent) {
if (indent.length() == 0) {
System.err.println("POINTER: " + pointer + "(" + pointer.getClass().getName() + ")");
} else {
System.err.println(indent + " of " + pointer + "(" + pointer.getClass().getName() + ")");
}
if (pointer.getImmediateParentPointer() != null) {
printDeep(pointer.getImmediateParentPointer(), indent + " ");
}
}
private static boolean safeEquals(final Object o1, final Object o2) {
return o1 == o2 || o1 != null && o1.equals(o2);
}
/**
* Verify the structure of a given NodePointer.
*
* @param nodePointer to check
* @return nodePointer
* @throws JXPathNotFoundException Thrown when there is no value at the NodePointer.
*/
public static NodePointer verify(final NodePointer nodePointer) {
if (!nodePointer.isActual()) {
// We need to differentiate between pointers representing
// a non-existing property and ones representing a property
// whose value is null. In the latter case, the pointer
// is going to have isActual == false, but its parent,
// which is a non-node pointer identifying the bean property,
// will return isActual() == true.
final NodePointer parent = nodePointer.getImmediateParentPointer();
if (parent == null || !parent.isContainer() || !parent.isActual()) {
throw new JXPathNotFoundException("No value for xpath: " + nodePointer);
}
}
return nodePointer;
}
/** Index for this NodePointer. */
protected int index = WHOLE_COLLECTION;
/**
* Whether this is an attribute.
*/
private boolean attribute;
/**
* Namespace resolver.
*/
private NamespaceResolver namespaceResolver;
/**
* Exception handler for {@link #handle(Throwable, NodePointer)}.
*/
private ExceptionHandler exceptionHandler;
/**
* Root node.
*/
private transient Object rootNode;
/** Parent pointer */
protected NodePointer parent;
/** Locale */
protected Locale locale;
/**
* Constructs a new NodePointer.
*
* @param parent Pointer
*/
protected NodePointer(final NodePointer parent) {
this.parent = parent;
}
/**
* Constructs a new NodePointer.
*
* @param parent Pointer
* @param locale Locale
*/
protected NodePointer(final NodePointer parent, final Locale locale) {
this.parent = parent;
this.locale = locale;
}
/**
* Returns an XPath that maps to this Pointer.
*
* @return String XPath expression
*/
@Override
public String asPath() {
// If the parent of this node is a container, it is responsible
// for appended this node's part of the path.
if (parent != null && parent.isContainer()) {
return parent.asPath();
}
final StringBuilder buffer = new StringBuilder();
if (parent != null) {
buffer.append(parent.asPath());
}
if (buffer.length() == 0 || buffer.charAt(buffer.length() - 1) != '/') {
buffer.append('/');
}
if (attribute) {
buffer.append('@');
}
buffer.append(getName());
if (index != WHOLE_COLLECTION && isCollection()) {
buffer.append('[').append(index + 1).append(']');
}
return buffer.toString();
}
/**
* Returns a NodeIterator that iterates over all attributes of the current node matching the supplied node name (could have a wildcard). May return null if
* the object does not support the attributes.
*
* @param qname the attribute name to test
* @return NodeIterator
*/
public NodeIterator attributeIterator(final QName qname) {
final NodePointer valuePointer = getValuePointer();
return valuePointer == null || valuePointer == this ? null : valuePointer.attributeIterator(qname);
}
/**
* Returns a NodeIterator that iterates over all children or all children that match the given NodeTest, starting with the specified one.
*
* @param test NodeTest to filter children
* @param reverse specified iteration direction
* @param startWith the NodePointer to start with
* @return NodeIterator
*/
public NodeIterator childIterator(final NodeTest test, final boolean reverse, final NodePointer startWith) {
final NodePointer valuePointer = getValuePointer();
return valuePointer == null || valuePointer == this ? null : valuePointer.childIterator(test, reverse, startWith);
}
/**
* Clone this NodePointer.
*
* @return cloned NodePointer
*/
@Override
public Object clone() {
try {
final NodePointer ptr = (NodePointer) super.clone();
if (parent != null) {
ptr.parent = (NodePointer) parent.clone();
}
return ptr;
} catch (final CloneNotSupportedException ex) {
// Of course it is supported
ex.printStackTrace();
}
return null;
}
/**
* Compares two child NodePointers and returns a positive number, zero or a positive number according to the order of the pointers.
*
* @param pointer1 first pointer to be compared
* @param pointer2 second pointer to be compared
* @return int per Java comparison conventions
*/
public abstract int compareChildNodePointers(NodePointer pointer1, NodePointer pointer2);
/**
* Compare node pointers.
*
* @param p1 pointer 1
* @param depth1 depth 1
* @param p2 pointer 2
* @param depth2 depth 2
* @return comparison result: (< 0) -> (p1 lt p2); (0) -> (p1 eq p2); (> 0) -> (p1 gt p2)
*/
private int compareNodePointers(final NodePointer p1, final int depth1, final NodePointer p2, final int depth2) {
if (depth1 < depth2) {
final int r = compareNodePointers(p1, depth1, p2.parent, depth2 - 1);
return r == 0 ? -1 : r;
}
if (depth1 > depth2) {
final int r = compareNodePointers(p1.parent, depth1 - 1, p2, depth2);
return r == 0 ? 1 : r;
}
// henceforth depth1 == depth2:
if (safeEquals(p1, p2)) {
return 0;
}
if (depth1 == 1) {
throw new JXPathException("Cannot compare pointers that do not belong to the same tree: '" + p1 + "' and '" + p2 + "'");
}
final int r = compareNodePointers(p1.parent, depth1 - 1, p2.parent, depth2 - 1);
return r == 0 ? p1.parent.compareChildNodePointers(p1, p2) : r;
}
@Override
public int compareTo(final Object object) {
if (object == this) {
return 0;
}
// Let it throw a ClassCastException
final NodePointer pointer = (NodePointer) object;
if (safeEquals(parent, pointer.parent)) {
return parent == null ? 0 : parent.compareChildNodePointers(this, pointer);
}
// Task 1: find the common parent
int depth1 = 0;
NodePointer p1 = this;
final HashSet<NodePointer> parents1 = new HashSet<>();
while (p1 != null) {
depth1++;
p1 = p1.parent;
if (p1 != null) {
parents1.add(p1);
}
}
boolean commonParentFound = false;
int depth2 = 0;
NodePointer p2 = pointer;
while (p2 != null) {
depth2++;
p2 = p2.parent;
if (parents1.contains(p2)) {
commonParentFound = true;
}
}
// nodes from different graphs are equal, else continue comparison:
return commonParentFound ? compareNodePointers(this, depth1, pointer, depth2) : 0;
}
/**
* Called to create a non-existing attribute
*
* @param context the owning JXPathCOntext
* @param qName the QName at which an attribute should be created
* @return created NodePointer
*/
public NodePointer createAttribute(final JXPathContext context, final QName qName) {
throw new JXPathException("Cannot create an attribute for path " + asPath() + "/@" + qName + ", operation is not allowed for this type of node");
}
/**
* Called by a child pointer when it needs to create a parent object for a non-existent collection element. It may have to expand the collection, then
* create an element object and return a new pointer describing the newly created element.
*
* @param context the owning JXPathCOntext
* @param qName the QName at which a child should be created
* @param index child index.
* @return created NodePointer
*/
public NodePointer createChild(final JXPathContext context, final QName qName, final int index) {
throw new JXPathException(
"Cannot create an object for path " + asPath() + "/" + qName + "[" + (index + 1) + "], operation is not allowed for this type of node");
}
/**
* Called by a child pointer if that child needs to assign the value supplied in the createPath(context, value) call to a non-existent node. This method may
* have to expand the collection in order to assign the element.
*
* @param context the owning JXPathCOntext
* @param qName the QName at which a child should be created
* @param index child index.
* @param value node value to set
* @return created NodePointer
*/
public NodePointer createChild(final JXPathContext context, final QName qName, final int index, final Object value) {
throw new JXPathException(
"Cannot create an object for path " + asPath() + "/" + qName + "[" + (index + 1) + "], operation is not allowed for this type of node");
}
/**
* Called by a child pointer when it needs to create a parent object. Must create an object described by this pointer and return a new pointer that properly
* describes the new object.
*
* @param context the owning JXPathContext
* @return created NodePointer
*/
public NodePointer createPath(final JXPathContext context) {
return this;
}
/**
* Called directly by JXPathContext. Must create path and set value.
*
* @param context the owning JXPathContext
* @param value the new value to set
* @return created NodePointer
*/
public NodePointer createPath(final JXPathContext context, final Object value) {
setValue(value);
return this;
}
/**
* Return a string escaping single and double quotes.
*
* @param string string to treat
* @return string with any necessary changes made.
*/
protected String escape(final String string) {
final char[] c = { '\'', '"' };
final String[] esc = { "'", """ };
StringBuilder sb = null;
for (int i = 0; sb == null && i < c.length; i++) {
if (string.indexOf(c[i]) >= 0) {
sb = new StringBuilder(string);
}
}
if (sb == null) {
return string;
}
for (int i = 0; i < c.length; i++) {
if (string.indexOf(c[i]) < 0) {
continue;
}
int pos = 0;
while (pos < sb.length()) {
if (sb.charAt(pos) == c[i]) {
sb.replace(pos, pos + 1, esc[i]);
pos += esc[i].length();
} else {
pos++;
}
}
}
return sb.toString();
}
/**
* Gets the AbstractFactory associated with the specified JXPathContext.
*
* @param context JXPathContext
* @return AbstractFactory
*/
protected AbstractFactory getAbstractFactory(final JXPathContext context) {
final AbstractFactory factory = context.getFactory();
if (factory == null) {
throw new JXPathException("Factory is not set on the JXPathContext - cannot create path: " + asPath());
}
return factory;
}
/**
* Gets the value represented by the pointer before indexing. So, if the node represents an element of a collection, this method returns the collection
* itself.
*
* @return Object value
*/
public abstract Object getBaseValue();
/**
* Gets the default ns uri
*
* @return String uri
*/
protected String getDefaultNamespaceURI() {
return null;
}
/**
* Returns the object the pointer points to; does not convert it to a "canonical" type.
*
* @return Object node
*/
public abstract Object getImmediateNode();
/**
* Gets the immediate parent pointer.
*
* @return NodePointer
*/
public NodePointer getImmediateParentPointer() {
return parent;
}
/**
* Gets this instance by default, subclasses can return a pointer for the immediately contained value.
*
* @return NodePointer is either {@code this} or a pointer for the immediately contained value.
* @see #getValuePointer()
*/
public NodePointer getImmediateValuePointer() {
return this;
}
/**
* If the pointer represents a collection, the index identifies an element of that collection. The default value of {@code index} is
* {@code WHOLE_COLLECTION}, which just means that the pointer is not indexed at all. Note: the index on NodePointer starts with 0, not 1.
*
* @return the index.
*/
public int getIndex() {
return index;
}
/**
* If the pointer represents a collection (or collection element), returns the length of the collection. Otherwise returns 1 (even if the value is null).
*
* @return the length.
*/
public abstract int getLength();
/**
* If the Pointer has a parent, returns the parent's locale; otherwise returns the locale specified when this Pointer was created.
*
* @return Locale for this NodePointer
*/
public Locale getLocale() {
if (locale == null && parent != null) {
locale = parent.getLocale();
}
return locale;
}
/**
* Gets the name of this node. Can be null.
*
* @return QName The name of this node. Can be null.
*/
public abstract QName getName();
/**
* Gets the NamespaceResolver associated with this NodePointer.
*
* @return NamespaceResolver
*/
public NamespaceResolver getNamespaceResolver() {
if (namespaceResolver == null && parent != null) {
namespaceResolver = parent.getNamespaceResolver();
}
return namespaceResolver;
}
/**
* Returns the namespace URI associated with this Pointer.
*
* @return String uri
*/
public String getNamespaceURI() {
return null;
}
/**
* Decodes a namespace prefix to the corresponding URI.
*
* @param prefix prefix to decode
* @return String uri
*/
public String getNamespaceURI(final String prefix) {
return null;
}
/**
* Returns the object the pointer points to; does not convert it to a "canonical" type. Opens containers, properties etc and returns the ultimate contents.
*
* @return Object node
*/
@Override
public Object getNode() {
return getValuePointer().getImmediateNode();
}
/**
* Find a NodeSet by key/value.
*
* @param context owning JXPathContext
* @param key key to search for
* @param value value to match
* @return NodeSet found
*/
public NodeSet getNodeSetByKey(final JXPathContext context, final String key, final Object value) {
return context.getNodeSetByKey(key, value);
}
/**
* Returns the object the pointer points to; does not convert it to a "canonical" type.
*
* @return Object node value
* @deprecated 1.1 Please use getNode()
*/
@Deprecated
public Object getNodeValue() {
return getNode();
}
/**
* Gets the parent pointer.
*
* @return NodePointer
*/
public NodePointer getParent() {
NodePointer pointer = parent;
while (pointer != null && pointer.isContainer()) {
pointer = pointer.getImmediateParentPointer();
}
return pointer;
}
/**
* Locates a node by ID.
*
* @param context JXPathContext owning context
* @param id String id
* @return Pointer found
*/
public Pointer getPointerByID(final JXPathContext context, final String id) {
return context.getPointerByID(id);
}
/**
* Locates a node by key and value.
*
* @param context owning JXPathContext
* @param key key to search for
* @param value value to match
* @return Pointer found
*/
public Pointer getPointerByKey(final JXPathContext context, final String key, final String value) {
return context.getPointerByKey(key, value);
}
/**
* Gets the root node.
*
* @return Object value of this pointer's root (top parent).
*/
@Override
public synchronized Object getRootNode() {
if (rootNode == null) {
rootNode = parent == null ? getImmediateNode() : parent.getRootNode();
}
return rootNode;
}
/**
* By default, returns {@code getNode()}, can be overridden to return a "canonical" value, like for instance a DOM element should return its string value.
*
* @return Object value
*/
@Override
public Object getValue() {
final NodePointer valuePointer = getValuePointer();
if (valuePointer != this) {
return valuePointer.getValue();
}
// Default behavior is to return the same as getNode()
return getNode();
}
/**
* If this pointer manages a transparent container, like a variable, this method returns the pointer to the contents. Only an auxiliary (non-node) pointer
* can (and should) return a value pointer other than itself. Note that you probably don't want to override {@code getValuePointer()} directly. Override the
* {@code getImmediateValuePointer()} method instead. The {@code getValuePointer()} method is calls {@code getImmediateValuePointer()} and, if the result is
* not {@code this}, invokes {@code getValuePointer()} recursively. The idea here is to open all nested containers. Let's say we have a container within a
* container within a container. The {@code getValuePointer()} method should then open all those containers and return the pointer to the ultimate contents.
* It does so with the above recursion.
*
* @return NodePointer
*/
public NodePointer getValuePointer() {
final NodePointer ivp = getImmediateValuePointer();
return ivp == this ? this : ivp.getValuePointer();
}
/**
* Handle a Throwable using an installed ExceptionHandler, if available. Public to facilitate calling for RI support; not truly intended for public
* consumption.
*
* @param t to handle
*/
public void handle(final Throwable t) {
handle(t, this);
}
/**
* Handle a Throwable using an installed ExceptionHandler, if available. Public to facilitate calling for RI support; not truly intended for public
* consumption.
*
* @param t to handle
* @param originator context
*/
public void handle(final Throwable t, final NodePointer originator) {
if (exceptionHandler != null) {
exceptionHandler.accept(t, originator);
return;
}
if (parent != null) {
parent.handle(t, originator);
}
}
/**
* An actual pointer points to an existing part of an object graph, even if it is null. A non-actual pointer represents a part that does not exist at all.
* For instance consider the pointer "/address/street". If both <em>address</em> and <em>street</em> are not null, the pointer is actual. If
* <em>address</em> is not null, but <em>street</em> is null, the pointer is still actual. If <em>address</em> is null, the pointer is not actual. (In
* JavaBeans) if <em>address</em> is not a property of the root bean, a Pointer for this path cannot be obtained at all - actual or otherwise.
*
* @return boolean
*/
public boolean isActual() {
return index == WHOLE_COLLECTION || index >= 0 && index < getLength();
}
/**
* Returns true if the pointer represents the "attribute::" axis.
*
* @return boolean
*/
public boolean isAttribute() {
return attribute;
}
/**
* Returns {@code true} if the value of the pointer is an array or a Collection.
*
* @return boolean
*/
public abstract boolean isCollection();
/**
* If true, this node is auxiliary and can only be used as an intermediate in the chain of pointers.
*
* @return boolean
*/
public boolean isContainer() {
return false;
}
/**
* Returns true if the supplied prefix represents the default namespace in the context of the current node.
*
* @param prefix the prefix to check
* @return {@code true} if prefix is default
*/
protected boolean isDefaultNamespace(final String prefix) {
if (prefix == null) {
return true;
}
final String namespace = getNamespaceURI(prefix);
return namespace != null && namespace.equals(getDefaultNamespaceURI());
}
/**
* Check whether our locale matches the specified language.
*
* @param lang String language to check
* @return true if the selected locale name starts with the specified prefix <em>lang</em>, case-insensitive.
*/
public boolean isLanguage(final String lang) {
final Locale loc = getLocale();
final String name = loc.toString().replace('_', '-');
return name.toUpperCase(Locale.ENGLISH).startsWith(lang.toUpperCase(Locale.ENGLISH));
}
/**
* If true, this node does not have children
*
* @return boolean
*/
public abstract boolean isLeaf();
/**
* Tests whether this pointer is considered to be a node.
*
* @return boolean
* @deprecated Please use !isContainer()
*/
@Deprecated
public boolean isNode() {
return !isContainer();
}
/**
* Returns true if this Pointer has no parent.
*
* @return boolean
*/
public boolean isRoot() {
return parent == null;
}
/**
* Returns a NodeIterator that iterates over all namespaces of the value currently pointed at. May return null if the object does not support the
* namespaces.
*
* @return NodeIterator
*/
public NodeIterator namespaceIterator() {
return null;
}
/**
* Returns a NodePointer for the specified namespace. Will return null if namespaces are not supported. Will return UNKNOWN_NAMESPACE if there is no such
* namespace.
*
* @param namespace incoming namespace
* @return NodePointer for {@code namespace}
*/
public NodePointer namespacePointer(final String namespace) {
return null;
}
/**
* Print internal structure of a pointer for debugging
*/
public void printPointerChain() {
printDeep(this, "");
}
/**
* Remove the node of the object graph this pointer points to.
*/
public void remove() {
// It is a no-op
// System.err.println("REMOVING: " + asPath() + " " + getClass());
// printPointerChain();
}
/**
* Sets to true if the pointer represents the "attribute::" axis.
*
* @param attribute boolean
*/
public void setAttribute(final boolean attribute) {
this.attribute = attribute;
}
/**
* Sets the exceptionHandler of this NodePointer.
*
* @param exceptionHandler the ExceptionHandler to set
*/
public void setExceptionHandler(final ExceptionHandler exceptionHandler) {
this.exceptionHandler = exceptionHandler;
}
/**
* Sets the index of this NodePointer.
*
* @param index int
*/
public void setIndex(final int index) {
this.index = index;
}
/**
* Sets the NamespaceResolver for this NodePointer.
*
* @param namespaceResolver NamespaceResolver
*/
public void setNamespaceResolver(final NamespaceResolver namespaceResolver) {
this.namespaceResolver = namespaceResolver;
}
/**
* Converts the value to the required type and changes the corresponding object to that value.
*
* @param value the value to set
*/
@Override
public abstract void setValue(Object value);
/**
* Checks if this Pointer matches the supplied NodeTest.
*
* @param test the NodeTest to execute
* @return true if a match
*/
public boolean testNode(final NodeTest test) {
if (test == null) {
return true;
}
if (test instanceof NodeNameTest) {
if (isContainer()) {
return false;
}
final NodeNameTest nodeNameTest = (NodeNameTest) test;
final QName testName = nodeNameTest.getNodeName();
final QName nodeName = getName();
if (nodeName == null) {
return false;
}
final String testPrefix = testName.getPrefix();
final String nodePrefix = nodeName.getPrefix();
if (!safeEquals(testPrefix, nodePrefix)) {
final String testNS = getNamespaceURI(testPrefix);
final String nodeNS = getNamespaceURI(nodePrefix);
if (!safeEquals(testNS, nodeNS)) {
return false;
}
}
if (nodeNameTest.isWildcard()) {
return true;
}
return testName.getName().equals(nodeName.getName());
}
return test instanceof NodeTypeTest && ((NodeTypeTest) test).getNodeType() == Compiler.NODE_TYPE_NODE && isNode();
}
@Override
public String toString() {
return asPath();
}
}