protected JXPathContext(JXPathContext parentContext,
    Object contextBean) 
{
        this.parentContext = parentContext;
        this.contextBean = contextBean;
}

This constructor should remain protected - it is to be overridden by subclasses, but never explicitly invoked by clients.

 public static CompiledExpression compile(String xpath) 
{
        if (compilationContext == null) {
            compilationContext = JXPathContext.newContext(null);
        }
        return compilationContext.compilePath(xpath);
}

Compiles the supplied XPath and returns an internal representation of the path that can then be evaluated. Use CompiledExpressions when you need to evaluate the same expression multiple times and there is a convenient place to cache CompiledExpression between invocations.

 abstract protected CompiledExpression compilePath(String xpath)
Overridden by each concrete implementation of JXPathContext
to perform compilation. Is called by compile().

 abstract public Pointer createPath(String xpath)
Creates missing elements of the path by invoking an AbstractFactory,
which should first be installed on the context by calling "setFactory".

Will throw an exception if the AbstractFactory fails to create
an instance for a path element.

 abstract public Pointer createPathAndSetValue(String xpath,
    Object value)
The same as setValue, except it creates intermediate elements of
the path by invoking an AbstractFactory, which should first be
installed on the context by calling "setFactory".

Will throw an exception if one of the following conditions occurs:

Elements of the xpath aleady exist, but the path does not in
 fact describe an existing property
The AbstractFactory fails to create an instance for an intermediate
element.
The property is not writable (no public, non-static set method)

 public Object getContextBean() 
{
        return contextBean;
}

Returns the JavaBean associated with this context.

 abstract public Pointer getContextPointer()
Returns a Pointer for the context bean.

 public DecimalFormatSymbols getDecimalFormatSymbols(String name) 
{
        if (decimalFormats == null) {
            if (parentContext != null) {
                return parentContext.getDecimalFormatSymbols(name);
            }
            return null;
        }
        return (DecimalFormatSymbols) decimalFormats.get(name);
}

 public AbstractFactory getFactory() 
{
        if (factory == null && parentContext != null) {
            return parentContext.getFactory();
        }
        return factory;
}

Returns the AbstractFactory installed on this context. If none has been installed and this context has a parent context, returns the parent's factory. Otherwise returns null.

 public Functions getFunctions() 
{
        if (functions != null) {
            return functions;
        }
        if (parentContext == null) {
            return GENERIC_FUNCTIONS;
        }
        return null;
}

Returns the set of functions installed on the context.

 public IdentityManager getIdentityManager() 
{
        if (idManager == null && parentContext != null) {
            return parentContext.getIdentityManager();
        }
        return idManager;
}

Returns this context's identity manager. If none has been installed, returns the identity manager of the parent context.

 public KeyManager getKeyManager() 
{
        if (keyManager == null && parentContext != null) {
            return parentContext.getKeyManager();
        }
        return keyManager;
}

Returns this context's key manager. If none has been installed, returns the key manager of the parent context.

 public Locale getLocale() 
{
        if (locale == null) {
            if (parentContext != null) {
                return parentContext.getLocale();
            }
            else {
                locale = Locale.getDefault();
            }
        }
        return locale;
}

Returns the locale set with setLocale. If none was set and the context has a parent, returns the parent's locale. Otherwise, returns Locale.getDefault().

 public Pointer getNamespaceContextPointer() 
{
        throw new UnsupportedOperationException(
                "Namespace registration is not implemented by " + getClass());
}

Returns the namespace context pointer set with setNamespaceContextPointer() or, if none has been specified, the context pointer otherwise.

 public String getNamespaceURI(String prefix) 
{
        throw new UnsupportedOperationException(
                "Namespace registration is not implemented by " + getClass());
}

Given a prefix, returns a registered namespace URI. If the requested prefix was not defined explicitly using the registerNamespace method, JXPathContext will then check the context node to see if the prefix is defined there. See setNamespaceContextPointer .

 public JXPathContext getParentContext() 
{
        return parentContext;
}

Returns the parent context of this context or null.

 abstract public Pointer getPointer(String xpath)
Traverses the xpath and returns a Pointer.
A Pointer provides easy access to a property.
If the xpath matches no properties
in the graph, the pointer will be null.

 public Pointer getPointerByID(String id) 
{
        IdentityManager manager = getIdentityManager();
        if (manager != null) {
            return manager.getPointerByID(this, id);
        }
        else {
            throw new JXPathException(
                "Cannot find an element by ID - "
                    + "no IdentityManager has been specified");
        }
}

Locates a Node by its ID.

 public Pointer getPointerByKey(String key,
    String value) 
{
        KeyManager manager = getKeyManager();
        if (manager != null) {
            return manager.getPointerByKey(this, key, value);
        }
        else {
            throw new JXPathException(
                "Cannot find an element by key - "
                    + "no KeyManager has been specified");
        }
}

Locates a Node by a key value.

 abstract public JXPathContext getRelativeContext(Pointer pointer)
Returns a JXPathContext that is relative to the current JXPathContext.
The supplied pointer becomes the context pointer of the new context.
The relative context inherits variables, extension functions, locale etc
from the parent context.

 abstract public Object getValue(String xpath)
Evaluates the xpath and returns the resulting object. Primitive
types are wrapped into objects.

 abstract public Object getValue(String xpath,
    Class requiredType)
Evaluates the xpath, converts the result to the specified class and
returns the resulting object.

 public Variables getVariables() 
{
        if (vars == null) {
            vars = new BasicVariables();
        }
        return vars;
}

Returns the variable pool associated with the context. If no such pool was specified with the setVariables() method, returns the default implementation of Variables, BasicVariables .

 public boolean isLenient() 
{
        if (!lenientSet && parentContext != null) {
            return parentContext.isLenient();
        }
        return lenient;
}

 abstract public Iterator iterate(String xpath)
Traverses the xpath and returns an Iterator of all results found
for the path. If the xpath matches no properties
in the graph, the Iterator will be empty, but not null.

 abstract public Iterator iteratePointers(String 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.

 public static JXPathContext newContext(Object contextBean) 
{
        return getContextFactory().newContext(null, contextBean);
}

Creates a new JXPathContext with the specified object as the root node.

 public static JXPathContext newContext(JXPathContext parentContext,
    Object contextBean) 
{
        return getContextFactory().newContext(parentContext, contextBean);
}

Creates a new JXPathContext with the specified bean as the root node and the specified parent context. Variables defined in a parent context can be referenced in XPaths passed to the child context.

 public  void registerNamespace(String prefix,
    String namespaceURI) 
{
        throw new UnsupportedOperationException(
                "Namespace registration is not implemented by " + getClass());
}

Registers a namespace prefix.

 abstract public  void removeAll(String xpath)
Removes all elements of the object graph described by the xpath.

 abstract public  void removePath(String xpath)
Removes the element of the object graph described by the xpath.

 public List selectNodes(String xpath) 
{
    	ArrayList list = new ArrayList();
    	Iterator iterator = iteratePointers(xpath);
    	while (iterator.hasNext()) {
			Pointer pointer = (Pointer) iterator.next();
			list.add(pointer.getNode());
		}
		return list;
}

Finds all nodes that match the specified XPath.

 public Object selectSingleNode(String xpath) 
{
    	Pointer pointer = getPointer(xpath);
    	if (pointer == null) {
    		return null;
    	}
		return pointer.getNode();
}

Finds the first object that matches the specified XPath. It is equivalent to getPointer(xpath).getNode(). Note, that this method produces the same result as getValue() on object models like JavaBeans, but a different result for DOM/JDOM etc., because it returns the Node itself, rather than its textual contents.

 public  void setDecimalFormatSymbols(String name,
    DecimalFormatSymbols symbols) 
{
        if (decimalFormats == null) {
            decimalFormats = new HashMap();
        }
        decimalFormats.put(name, symbols);
}

Sets DecimalFormatSymbols for a given name. The DecimalFormatSymbols can be referenced as the third, optional argument in the invocation of format-number (number,format,decimal-format-name) function. By default, JXPath uses the symbols for the current locale.

 public  void setFactory(AbstractFactory factory) 
{
        this.factory = factory;
}

Install an abstract factory that should be used by the createPath() and createPathAndSetValue() methods.

 public  void setFunctions(Functions functions) 
{
        this.functions = functions;
}

Install a library of extension functions.

 public  void setIdentityManager(IdentityManager idManager) 
{
        this.idManager = idManager;
}

Install an identity manager that will be used by the context to look up a node by its ID.

 public  void setKeyManager(KeyManager keyManager) 
{
        this.keyManager = keyManager;
}

Install a key manager that will be used by the context to look up a node by a key value.

 public  void setLenient(boolean lenient) 
{
        this.lenient = lenient;
        lenientSet = true;
}

If the context is in the lenient mode, then getValue() returns null for inexistent paths. Otherwise, a path that does not map to an existing property will throw an exception. Note that if the property exists, but its value is null, the exception is not thrown.

By default, lenient = false

 public  void setLocale(Locale locale) 
{
        this.locale = locale;
}

Set the locale for this context. The value of the "lang" attribute as well as the the lang() function will be affected by the locale. By default, JXPath uses Locale.getDefault()

 public  void setNamespaceContextPointer(Pointer namespaceContextPointer) 
{
        throw new UnsupportedOperationException(
                "Namespace registration is not implemented by " + getClass());
}

Namespace prefixes can be defined implicitly by specifying a pointer to a context where the namespaces are defined. By default, NamespaceContextPointer is the same as the Context Pointer, see getContextPointer()

 abstract public  void setValue(String xpath,
    Object value)
Modifies the value of the property described by the supplied xpath.
Will throw an exception if one of the following conditions occurs:

The xpath does not in fact describe an existing property
The property is not writable (no public, non-static set method)

 public  void setVariables(Variables vars) 
{
        this.vars = vars;
}

Installs a custom implementation of the Variables interface.