/*
* 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.commons.jxpath.ri;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;
import java.util.Map.Entry;
import org.apache.commons.jxpath.CompiledExpression;
import org.apache.commons.jxpath.Function;
import org.apache.commons.jxpath.Functions;
import org.apache.commons.jxpath.JXPathContext;
import org.apache.commons.jxpath.JXPathException;
import org.apache.commons.jxpath.JXPathFunctionNotFoundException;
import org.apache.commons.jxpath.JXPathInvalidSyntaxException;
import org.apache.commons.jxpath.JXPathNotFoundException;
import org.apache.commons.jxpath.JXPathTypeConversionException;
import org.apache.commons.jxpath.Pointer;
import org.apache.commons.jxpath.ri.axes.InitialContext;
import org.apache.commons.jxpath.ri.axes.RootContext;
import org.apache.commons.jxpath.ri.compiler.Expression;
import org.apache.commons.jxpath.ri.compiler.LocationPath;
import org.apache.commons.jxpath.ri.compiler.Path;
import org.apache.commons.jxpath.ri.compiler.TreeCompiler;
import org.apache.commons.jxpath.ri.model.NodePointer;
import org.apache.commons.jxpath.ri.model.NodePointerFactory;
import org.apache.commons.jxpath.ri.model.VariablePointerFactory;
import org.apache.commons.jxpath.ri.model.beans.BeanPointerFactory;
import org.apache.commons.jxpath.ri.model.beans.CollectionPointerFactory;
import org.apache.commons.jxpath.ri.model.container.ContainerPointerFactory;
import org.apache.commons.jxpath.ri.model.dynamic.DynamicPointerFactory;
import org.apache.commons.jxpath.util.ReverseComparator;
import org.apache.commons.jxpath.util.TypeUtils;
/**
* The reference implementation of JXPathContext.
*
* @author Dmitri Plotnikov
* @version $Revision: 670727 $ $Date: 2008-06-23 15:10:38 -0500 (Mon, 23 Jun 2008) $
*/
public class JXPathContextReferenceImpl extends JXPathContext {
/**
* Change this to <code>false</code> to disable soft caching of
* CompiledExpressions.
*/
public static final boolean USE_SOFT_CACHE = true;
private static final Compiler COMPILER = new TreeCompiler();
private static Map compiled = new HashMap();
private static int cleanupCount = 0;
private static NodePointerFactory[] nodeFactoryArray = null;
// The frequency of the cache cleanup
private static final int CLEANUP_THRESHOLD = 500;
private static final Vector nodeFactories = new Vector();
static {
nodeFactories.add(new CollectionPointerFactory());
nodeFactories.add(new BeanPointerFactory());
nodeFactories.add(new DynamicPointerFactory());
nodeFactories.add(new VariablePointerFactory());
// DOM factory is only registered if DOM support is on the classpath
Object domFactory = allocateConditionally(
"org.apache.commons.jxpath.ri.model.dom.DOMPointerFactory",
"org.w3c.dom.Node");
if (domFactory != null) {
nodeFactories.add(domFactory);
}
// JDOM factory is only registered if JDOM is on the classpath
Object jdomFactory = allocateConditionally(
"org.apache.commons.jxpath.ri.model.jdom.JDOMPointerFactory",
"org.jdom.Document");
if (jdomFactory != null) {
nodeFactories.add(jdomFactory);
}
// DynaBean factory is only registered if BeanUtils are on the classpath
Object dynaBeanFactory =
allocateConditionally(
"org.apache.commons.jxpath.ri.model.dynabeans."
+ "DynaBeanPointerFactory",
"org.apache.commons.beanutils.DynaBean");
if (dynaBeanFactory != null) {
nodeFactories.add(dynaBeanFactory);
}
nodeFactories.add(new ContainerPointerFactory());
createNodeFactoryArray();
}
/**
* Create the default node factory array.
*/
private static synchronized void createNodeFactoryArray() {
if (nodeFactoryArray == null) {
nodeFactoryArray =
(NodePointerFactory[]) nodeFactories.
toArray(new NodePointerFactory[nodeFactories.size()]);
Arrays.sort(nodeFactoryArray, new Comparator() {
public int compare(Object a, Object b) {
int orderA = ((NodePointerFactory) a).getOrder();
int orderB = ((NodePointerFactory) b).getOrder();
return orderA - orderB;
}
});
}
}
/**
* Call this with a custom NodePointerFactory to add support for
* additional types of objects. Make sure the factory returns
* a name that puts it in the right position on the list of factories.
* @param factory NodePointerFactory to add
*/
public static void addNodePointerFactory(NodePointerFactory factory) {
synchronized (nodeFactories) {
nodeFactories.add(factory);
nodeFactoryArray = null;
}
}
/**
* Get the registered NodePointerFactories.
* @return NodePointerFactory[]
*/
public static NodePointerFactory[] getNodePointerFactories() {
return nodeFactoryArray;
}
/** Namespace resolver */
protected NamespaceResolver namespaceResolver;
private Pointer rootPointer;
private Pointer contextPointer;
/**
* Create a new JXPathContextReferenceImpl.
* @param parentContext parent context
* @param contextBean Object
*/
protected JXPathContextReferenceImpl(JXPathContext parentContext,
Object contextBean) {
this(parentContext, contextBean, null);
}
/**
* Create a new JXPathContextReferenceImpl.
* @param parentContext parent context
* @param contextBean Object
* @param contextPointer context pointer
*/
public JXPathContextReferenceImpl(JXPathContext parentContext,
Object contextBean, Pointer contextPointer) {
super(parentContext, contextBean);
synchronized (nodeFactories) {
createNodeFactoryArray();
}
if (contextPointer != null) {
this.contextPointer = contextPointer;
this.rootPointer =
NodePointer.newNodePointer(
new QName(null, "root"),
contextPointer.getRootNode(),
getLocale());
}
else {
this.contextPointer =
NodePointer.newNodePointer(
new QName(null, "root"),
contextBean,
getLocale());
this.rootPointer = this.contextPointer;
}
NamespaceResolver parentNR = null;
if (parentContext instanceof JXPathContextReferenceImpl) {
parentNR = ((JXPathContextReferenceImpl) parentContext).getNamespaceResolver();
}
namespaceResolver = new NamespaceResolver(parentNR);
namespaceResolver
.setNamespaceContextPointer((NodePointer) this.contextPointer);
}
/**
* Returns a static instance of TreeCompiler.
*
* Override this to return an alternate compiler.
* @return Compiler
*/
protected Compiler getCompiler() {
return COMPILER;
}
protected CompiledExpression compilePath(String xpath) {
return new JXPathCompiledExpression(xpath, compileExpression(xpath));
}
/**
* Compile the given expression.
* @param xpath to compile
* @return Expression
*/
private Expression compileExpression(String xpath) {
Expression expr;
synchronized (compiled) {
if (USE_SOFT_CACHE) {
expr = null;
SoftReference ref = (SoftReference) compiled.get(xpath);
if (ref != null) {
expr = (Expression) ref.get();
}
}
else {
expr = (Expression) compiled.get(xpath);
}
}
if (expr != null) {
return expr;
}
expr = (Expression) Parser.parseExpression(xpath, getCompiler());
synchronized (compiled) {
if (USE_SOFT_CACHE) {
if (cleanupCount++ >= CLEANUP_THRESHOLD) {
Iterator it = compiled.entrySet().iterator();
while (it.hasNext()) {
Entry me = (Entry) it.next();
if (((SoftReference) me.getValue()).get() == null) {
it.remove();
}
}
cleanupCount = 0;
}
compiled.put(xpath, new SoftReference(expr));
}
else {
compiled.put(xpath, expr);
}
}
return expr;
}
/**
* Traverses the xpath and returns the resulting object. Primitive
* types are wrapped into objects.
* @param xpath expression
* @return Object found
*/
public Object getValue(String xpath) {
Expression expression = compileExpression(xpath);
// TODO: (work in progress) - trying to integrate with Xalan
// Object ctxNode = getNativeContextNode(expression);
// if (ctxNode != null) {
// System.err.println("WILL USE XALAN: " + xpath);
// CachedXPathAPI api = new CachedXPathAPI();
// try {
// if (expression instanceof Path) {
// Node node = api.selectSingleNode((Node)ctxNode, xpath);
// System.err.println("NODE: " + node);
// if (node == null) {
// return null;
// }
// return new DOMNodePointer(node, null).getValue();
// }
// else {
// XObject object = api.eval((Node)ctxNode, xpath);
// switch (object.getType()) {
// case XObject.CLASS_STRING: return object.str();
// case XObject.CLASS_NUMBER: return new Double(object.num());
// case XObject.CLASS_BOOLEAN: return new Boolean(object.bool());
// default:
// System.err.println("OTHER TYPE: " + object.getTypeString());
// }
// }
// }
// catch (TransformerException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// return
// }
return getValue(xpath, expression);
}
// private Object getNativeContextNode(Expression expression) {
// Object node = getNativeContextNode(getContextBean());
// if (node == null) {
// return null;
// }
//
// List vars = expression.getUsedVariables();
// if (vars != null) {
// return null;
// }
//
// return node;
// }
// private Object getNativeContextNode(Object bean) {
// if (bean instanceof Number || bean instanceof String || bean instanceof Boolean) {
// return bean;
// }
// if (bean instanceof Node) {
// return (Node)bean;
// }
//
// if (bean instanceof Container) {
// bean = ((Container)bean).getValue();
// return getNativeContextNode(bean);
// }
//
// return null;
// }
/**
* Get the value indicated.
* @param xpath String
* @param expr Expression
* @return Object
*/
public Object getValue(String xpath, Expression expr) {
Object result = expr.computeValue(getEvalContext());
if (result == null) {
if (expr instanceof Path && !isLenient()) {
throw new JXPathNotFoundException("No value for xpath: "
+ xpath);
}
return null;
}
if (result instanceof EvalContext) {
EvalContext ctx = (EvalContext) result;
result = ctx.getSingleNodePointer();
if (!isLenient() && result == null) {
throw new JXPathNotFoundException("No value for xpath: "
+ xpath);
}
}
if (result instanceof NodePointer) {
result = ((NodePointer) result).getValuePointer();
if (!isLenient() && !((NodePointer) result).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.
NodePointer parent =
((NodePointer) result).getImmediateParentPointer();
if (parent == null
|| !parent.isContainer()
|| !parent.isActual()) {
throw new JXPathNotFoundException("No value for xpath: "
+ xpath);
}
}
result = ((NodePointer) result).getValue();
}
return result;
}
/**
* Calls getValue(xpath), converts the result to the required type
* and returns the result of the conversion.
* @param xpath expression
* @param requiredType Class
* @return Object
*/
public Object getValue(String xpath, Class requiredType) {
Expression expr = compileExpression(xpath);
return getValue(xpath, expr, requiredType);
}
/**
* Get the value indicated.
* @param xpath expression
* @param expr compiled Expression
* @param requiredType Class
* @return Object
*/
public Object getValue(String xpath, Expression expr, Class requiredType) {
Object value = getValue(xpath, expr);
if (value != null && requiredType != null) {
if (!TypeUtils.canConvert(value, requiredType)) {
throw new JXPathTypeConversionException(
"Invalid expression type. '"
+ xpath
+ "' returns "
+ value.getClass().getName()
+ ". It cannot be converted to "
+ requiredType.getName());
}
value = TypeUtils.convert(value, requiredType);
}
return value;
}
/**
* Traverses the xpath and returns a Iterator of all results found
* for the path. If the xpath matches no properties
* in the graph, the Iterator will not be null.
* @param xpath expression
* @return Iterator
*/
public Iterator iterate(String xpath) {
return iterate(xpath, compileExpression(xpath));
}
/**
* Traverses the xpath and returns a Iterator of all results found
* for the path. If the xpath matches no properties
* in the graph, the Iterator will not be null.
* @param xpath expression
* @param expr compiled Expression
* @return Iterator
*/
public Iterator iterate(String xpath, Expression expr) {
return expr.iterate(getEvalContext());
}
public Pointer getPointer(String xpath) {
return getPointer(xpath, compileExpression(xpath));
}
/**
* Get a pointer to the specified path/expression.
* @param xpath String
* @param expr compiled Expression
* @return Pointer
*/
public Pointer getPointer(String xpath, Expression expr) {
Object result = expr.computeValue(getEvalContext());
if (result instanceof EvalContext) {
result = ((EvalContext) result).getSingleNodePointer();
}
if (result instanceof Pointer) {
if (!isLenient() && !((NodePointer) result).isActual()) {
throw new JXPathNotFoundException("No pointer for xpath: "
+ xpath);
}
return (Pointer) result;
}
return NodePointer.newNodePointer(null, result, getLocale());
}
public void setValue(String xpath, Object value) {
setValue(xpath, compileExpression(xpath), value);
}
/**
* Set the value of xpath to value.
* @param xpath path
* @param expr compiled Expression
* @param value Object
*/
public void setValue(String xpath, Expression expr, Object value) {
try {
setValue(xpath, expr, value, false);
}
catch (Throwable ex) {
throw new JXPathException(
"Exception trying to set value with xpath " + xpath, ex);
}
}
public Pointer createPath(String xpath) {
return createPath(xpath, compileExpression(xpath));
}
/**
* Create the given path.
* @param xpath String
* @param expr compiled Expression
* @return resulting Pointer
*/
public Pointer createPath(String xpath, Expression expr) {
try {
Object result = expr.computeValue(getEvalContext());
Pointer pointer = null;
if (result instanceof Pointer) {
pointer = (Pointer) result;
}
else if (result instanceof EvalContext) {
EvalContext ctx = (EvalContext) result;
pointer = ctx.getSingleNodePointer();
}
else {
checkSimplePath(expr);
// This should never happen
throw new JXPathException("Cannot create path:" + xpath);
}
return ((NodePointer) pointer).createPath(this);
}
catch (Throwable ex) {
throw new JXPathException(
"Exception trying to create xpath " + xpath,
ex);
}
}
public Pointer createPathAndSetValue(String xpath, Object value) {
return createPathAndSetValue(xpath, compileExpression(xpath), value);
}
/**
* Create the given path setting its value to value.
* @param xpath String
* @param expr compiled Expression
* @param value Object
* @return resulting Pointer
*/
public Pointer createPathAndSetValue(String xpath, Expression expr,
Object value) {
try {
return setValue(xpath, expr, value, true);
}
catch (Throwable ex) {
throw new JXPathException(
"Exception trying to create xpath " + xpath,
ex);
}
}
/**
* Set the specified value.
* @param xpath path
* @param expr compiled Expression
* @param value destination value
* @param create whether to create missing node(s)
* @return Pointer created
*/
private Pointer setValue(String xpath, Expression expr, Object value,
boolean create) {
Object result = expr.computeValue(getEvalContext());
Pointer pointer = null;
if (result instanceof Pointer) {
pointer = (Pointer) result;
}
else if (result instanceof EvalContext) {
EvalContext ctx = (EvalContext) result;
pointer = ctx.getSingleNodePointer();
}
else {
if (create) {
checkSimplePath(expr);
}
// This should never happen
throw new JXPathException("Cannot set value for xpath: " + xpath);
}
if (create) {
pointer = ((NodePointer) pointer).createPath(this, value);
}
else {
pointer.setValue(value);
}
return pointer;
}
/**
* Checks if the path follows the JXPath restrictions on the type
* of path that can be passed to create... methods.
* @param expr Expression to check
*/
private void checkSimplePath(Expression expr) {
if (!(expr instanceof LocationPath)
|| !((LocationPath) expr).isSimplePath()) {
throw new JXPathInvalidSyntaxException(
"JXPath can only create a path if it uses exclusively "
+ "the child:: and attribute:: axes and has "
+ "no context-dependent predicates");
}
}
/**
* Traverses the xpath and returns an Iterator of Pointers.
* A Pointer provides easy access to a property.
* If the xpath matches no properties
* in the graph, the Iterator be empty, but not null.
* @param xpath expression
* @return Iterator
*/
public Iterator iteratePointers(String xpath) {
return iteratePointers(xpath, compileExpression(xpath));
}
/**
* Traverses the xpath and returns an Iterator of Pointers.
* A Pointer provides easy access to a property.
* If the xpath matches no properties
* in the graph, the Iterator be empty, but not null.
* @param xpath expression
* @param expr compiled Expression
* @return Iterator
*/
public Iterator iteratePointers(String xpath, Expression expr) {
return expr.iteratePointers(getEvalContext());
}
public void removePath(String xpath) {
removePath(xpath, compileExpression(xpath));
}
/**
* Remove the specified path.
* @param xpath expression
* @param expr compiled Expression
*/
public void removePath(String xpath, Expression expr) {
try {
NodePointer pointer = (NodePointer) getPointer(xpath, expr);
if (pointer != null) {
((NodePointer) pointer).remove();
}
}
catch (Throwable ex) {
throw new JXPathException(
"Exception trying to remove xpath " + xpath,
ex);
}
}
public void removeAll(String xpath) {
removeAll(xpath, compileExpression(xpath));
}
/**
* Remove all matching nodes.
* @param xpath expression
* @param expr compiled Expression
*/
public void removeAll(String xpath, Expression expr) {
try {
ArrayList list = new ArrayList();
Iterator it = expr.iteratePointers(getEvalContext());
while (it.hasNext()) {
list.add(it.next());
}
Collections.sort(list, ReverseComparator.INSTANCE);
it = list.iterator();
if (it.hasNext()) {
NodePointer pointer = (NodePointer) it.next();
pointer.remove();
while (it.hasNext()) {
removePath(((NodePointer) it.next()).asPath());
}
}
}
catch (Throwable ex) {
throw new JXPathException(
"Exception trying to remove all for xpath " + xpath,
ex);
}
}
public JXPathContext getRelativeContext(Pointer pointer) {
Object contextBean = pointer.getNode();
if (contextBean == null) {
throw new JXPathException(
"Cannot create a relative context for a non-existent node: "
+ pointer);
}
return new JXPathContextReferenceImpl(this, contextBean, pointer);
}
public Pointer getContextPointer() {
return contextPointer;
}
/**
* Get absolute root pointer.
* @return NodePointer
*/
private NodePointer getAbsoluteRootPointer() {
return (NodePointer) rootPointer;
}
/**
* Get the evaluation context.
* @return EvalContext
*/
private EvalContext getEvalContext() {
return new InitialContext(new RootContext(this,
(NodePointer) getContextPointer()));
}
/**
* Get the absolute root context.
* @return EvalContext
*/
public EvalContext getAbsoluteRootContext() {
return new InitialContext(new RootContext(this,
getAbsoluteRootPointer()));
}
/**
* Get a VariablePointer for the given variable name.
* @param name variable name
* @return NodePointer
*/
public NodePointer getVariablePointer(QName name) {
return NodePointer.newNodePointer(name, VariablePointerFactory
.contextWrapper(this), getLocale());
}
/**
* Get the named Function.
* @param functionName name
* @param parameters function args
* @return Function
*/
public Function getFunction(QName functionName, Object[] parameters) {
String namespace = functionName.getPrefix();
String name = functionName.getName();
JXPathContext funcCtx = this;
Function func = null;
Functions funcs;
while (funcCtx != null) {
funcs = funcCtx.getFunctions();
if (funcs != null) {
func = funcs.getFunction(namespace, name, parameters);
if (func != null) {
return func;
}
}
funcCtx = funcCtx.getParentContext();
}
throw new JXPathFunctionNotFoundException(
"Undefined function: " + functionName.toString());
}
public void registerNamespace(String prefix, String namespaceURI) {
if (namespaceResolver.isSealed()) {
namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
}
namespaceResolver.registerNamespace(prefix, namespaceURI);
}
public String getNamespaceURI(String prefix) {
return namespaceResolver.getNamespaceURI(prefix);
}
/**
* {@inheritDoc}
* @see org.apache.commons.jxpath.JXPathContext#getPrefix(java.lang.String)
*/
public String getPrefix(String namespaceURI) {
return namespaceResolver.getPrefix(namespaceURI);
}
public void setNamespaceContextPointer(Pointer pointer) {
if (namespaceResolver.isSealed()) {
namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
}
namespaceResolver.setNamespaceContextPointer((NodePointer) pointer);
}
public Pointer getNamespaceContextPointer() {
return namespaceResolver.getNamespaceContextPointer();
}
/**
* Get the namespace resolver.
* @return NamespaceResolver
*/
public NamespaceResolver getNamespaceResolver() {
namespaceResolver.seal();
return namespaceResolver;
}
/**
* Checks if existenceCheckClass exists on the class path. If so, allocates
* an instance of the specified class, otherwise returns null.
* @param className to instantiate
* @param existenceCheckClassName guard class
* @return className instance
*/
public static Object allocateConditionally(String className,
String existenceCheckClassName) {
try {
try {
Class.forName(existenceCheckClassName);
}
catch (ClassNotFoundException ex) {
return null;
}
Class cls = Class.forName(className);
return cls.newInstance();
}
catch (Exception ex) {
throw new JXPathException("Cannot allocate " + className, ex);
}
}
}