|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object net.sf.saxon.xpath.XPathEvaluator
public class XPathEvaluator
XPathEvaluator implements the JAXP API for standalone XPath processing (that is, executing XPath expressions in the absence of an XSLT stylesheet). It is an implementation of the JAXP 1.3 XPath interface, with additional methods provided (a) for backwards compatibility (b) to give extra control over the XPath evaluation, and (c) to support XPath 2.0.
It is intended to evolve this so that it only supports the JAXP style of operation. Some of the methods are therefore marked as deprecated in this release, and will be dropped in a future release.
For an alternative XPath API, offering more direct access to Saxon capabilities,
see XPathEvaluator
.
Note that the XPathEvaluator
links to a Saxon Configuration
object. By default a new Configuration
is created automatically. In many
applications, however, it is desirable to share a configuration. The default configuration
is not schema aware. All source documents used by XPath expressions under this evaluator
must themselves be built using the Configuration
used by this evaluator.
Constructor Summary | |
---|---|
XPathEvaluator()
Default constructor. |
|
XPathEvaluator(Configuration config)
Construct an XPathEvaluator with a specified configuration. |
|
XPathEvaluator(Source source)
Construct an XPathEvaluator to process a particular source document. |
Method Summary | |
---|---|
XPathExpression |
compile(String expr)
Compile an XPath 2.0 expression |
XPathExpressionImpl |
createExpression(String expression)
Deprecated. since Saxon 8.9 - use compile(String) |
String |
evaluate(String expr,
InputSource inputSource)
Single-shot method to parse and build a source document, and compile an execute an XPath 2.0 expression, against that document, returning the result as a string |
Object |
evaluate(String expr,
InputSource inputSource,
QName qName)
Single-shot method to parse and build a source document, and compile an execute an XPath 2.0 expression, against that document |
String |
evaluate(String expr,
Object node)
Single-shot method to compile an execute an XPath 2.0 expression, returning the result as a string. |
Object |
evaluate(String expr,
Object node,
QName qName)
Single-shot method to compile and execute an XPath 2.0 expression. |
Configuration |
getConfiguration()
Get the Configuration used by this XPathEvaluator |
NamespaceContext |
getNamespaceContext()
Get the namespace context, if one has been set using setNamespaceContext(javax.xml.namespace.NamespaceContext) |
JAXPXPathStaticContext |
getStaticContext()
Get the current static context |
XPathFunctionResolver |
getXPathFunctionResolver()
Get the resolver for XPath functions |
XPathVariableResolver |
getXPathVariableResolver()
Get the resolver for XPath variables |
void |
importSchema(Source source)
Import a schema. |
boolean |
isBackwardsCompatible()
Get the value of XPath 1.0 compatibility mode |
static void |
main(String[] args)
A simple command-line interface for the XPathEvaluator (not documented). |
void |
reset()
|
void |
setBackwardsCompatible(boolean compatible)
Set XPath 1.0 compatibility mode on or off (by default, it is false). |
void |
setContextNode(NodeInfo node)
Deprecated. since Saxon 8.9 - use the various method defined in the JAXP interface definition, which allow a NodeInfo object to be supplied as the value of the Source argument |
void |
setNamespaceContext(NamespaceContext namespaceContext)
Set the namespace context to be used. |
NodeInfo |
setSource(Source source)
Supply a document against which XPath expressions are to be executed, converting it to a Saxon NodeInfo object. |
void |
setStaticContext(JAXPXPathStaticContext context)
Set the static context for compiling XPath expressions. |
void |
setStripSpace(boolean strip)
Deprecated. since 8.9. The preferred way to define options for the way in which source documents are built is to use the class AugmentedSource for any
of the methods expecting a Source object. |
void |
setXPathFunctionResolver(XPathFunctionResolver xPathFunctionResolver)
Set the resolver for XPath functions |
void |
setXPathVariableResolver(XPathVariableResolver xPathVariableResolver)
Set the resolver for XPath variables |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public XPathEvaluator()
public XPathEvaluator(Configuration config)
config
- the configuration to be used. If schema-aware XPath expressions are to be used,
this must be an EnterpriseConfiguration.public XPathEvaluator(Source source) throws XPathException
source
- The source document (or a specific node within it).
XPathException
Method Detail |
---|
public Configuration getConfiguration()
public void setStripSpace(boolean strip)
AugmentedSource
for any
of the methods expecting a Source
object.
strip
- True if all whitespace text nodes are to be stripped from the source document,
false otherwise. The default if the method is not called is false.public NodeInfo setSource(Source source) throws XPathException
If the supplied source is a NodeInfo
, it is returned unchanged.
If the supplied source is a DOMSource
, the result is a Saxon NodeInfo
wrapper around the DOM Node contained by the DOMSource.
In all other cases, the result is a document node, and is the same as the result of calling
Configuration.buildDocument(javax.xml.transform.Source)
with the same argument;
except that when whitespace stripping has been requested using setStripSpace(boolean)
,
this request is passed on.
Despite the name of this method, it does not change the state of the XPathEvaluator
in any way.
source
- Any javax.xml.transform.Source object representing the document against
which XPath expressions will be executed. Note that a Saxon DocumentInfo
(indeed any NodeInfo
)
can be used as a Source. To use a third-party DOM Document as a source, create an instance of
DOMSource
to wrap it.
The Source object supplied also determines the initial setting of the context item. In most cases the context node will be the root of the supplied document; however, if a NodeInfo or DOMSource is supplied it can be any node in the document.
XPathException
- if the supplied Source is a NodeInfo object that was built using an incompatible
Configuration (that is, a Configuration using a different NamePool). Also, if any error occurs parsing
the document supplied as the Source.
XPathException
public void setStaticContext(JAXPXPathStaticContext context)
context
- the static context
IllegalArgumentException
- if the supplied static context uses a different and incompatible
Configuration from the one used in this XPathEvaluatorpublic JAXPXPathStaticContext getStaticContext()
public XPathExpressionImpl createExpression(String expression) throws XPathException
compile(String)
expression
- The XPath expression to be evaluated, supplied as a string.
XPathException
- if the syntax of the expression is wrong, or if it references namespaces,
variables, or functions that have not been declared.public void setContextNode(NodeInfo node)
node
- The node to be used as the context node. The node must be within a tree built using
the same Saxon Configuration
as used by this XPathEvaluator.
IllegalArgumentException
- if the supplied node was built using the wrong Configurationpublic void reset()
reset
in interface XPath
public void setBackwardsCompatible(boolean compatible)
compatible
- true if XPath 1.0 compatibility mode is to be set to true, false
if it is to be set to false.public boolean isBackwardsCompatible()
public void setXPathVariableResolver(XPathVariableResolver xPathVariableResolver)
setXPathVariableResolver
in interface XPath
xPathVariableResolver
- a resolver for variablespublic XPathVariableResolver getXPathVariableResolver()
getXPathVariableResolver
in interface XPath
public void setXPathFunctionResolver(XPathFunctionResolver xPathFunctionResolver)
setXPathFunctionResolver
in interface XPath
xPathFunctionResolver
- a resolver for XPath function callspublic XPathFunctionResolver getXPathFunctionResolver()
getXPathFunctionResolver
in interface XPath
public void setNamespaceContext(NamespaceContext namespaceContext)
setNamespaceContext
in interface XPath
namespaceContext
- The namespace contextpublic NamespaceContext getNamespaceContext()
setNamespaceContext(javax.xml.namespace.NamespaceContext)
getNamespaceContext
in interface XPath
public void importSchema(Source source) throws SchemaException
source
- A Source object identifying the schema document to be loaded
SchemaException
- if the schema contained in this document is invalid
UnsupportedOperationException
- if the configuration is not schema-awarepublic XPathExpression compile(String expr) throws XPathExpressionException
compile
in interface XPath
expr
- the XPath 2.0 expression to be compiled, as a string
XPathExpressionException
- if there are any static errors in the expression.
Note that references to undeclared variables are not treated as static errors, because
variables are not pre-declared using this API.public Object evaluate(String expr, Object node, QName qName) throws XPathExpressionException
evaluate
in interface XPath
expr
- The XPath 2.0 expression to be compiled and executednode
- The context node for evaluation of the expression.
This may be a NodeInfo object, representing a node in Saxon's native implementation of the data model, or it may be a node in any supported external object model: DOM, JDOM, DOM4J, or XOM, or any other model for which support has been configured in the Configuration. Note that the supporting libraries for the chosen model must be on the class path.
Contrary to the interface specification, Saxon does not supply an empty
document when the value is null. This is because Saxon supports multiple object models,
and it's unclear what kind of document node would be appropriate. Instead, Saxon uses
the node supplied to the setContextNode(net.sf.saxon.om.NodeInfo)
method if available, and if none
is available, executes the XPath expression with the context item undefined.
qName
- The type of result required. For details, see
XPathExpressionImpl.evaluate(Object, javax.xml.namespace.QName)
XPathExpressionImpl.evaluate(Object, javax.xml.namespace.QName)
XPathExpressionException
- if any static or dynamic error occurs
in evaluating the expression.public String evaluate(String expr, Object node) throws XPathExpressionException
evaluate
in interface XPath
expr
- The XPath 2.0 expression to be compiled and executednode
- The context node for evaluation of the expression
This may be a NodeInfo object, representing a node in Saxon's native implementation of the data model, or it may be a node in any supported external object model: DOM, JDOM, DOM4J, or XOM, or any other model for which support has been configured in the Configuration. Note that the supporting libraries for the chosen model must be on the class path.
Contrary to the interface specification, Saxon does not supply an empty
document when the value is null. This is because Saxon supports multiple object models,
and it's unclear what kind of document node would be appropriate. Instead, Saxon uses
the node supplied to the setContextNode(net.sf.saxon.om.NodeInfo)
method if available, and if none
is available, executes the XPath expression with the context item undefined.
XPathExpressionException
- if any static or dynamic error occurs
in evaluating the expression.public Object evaluate(String expr, InputSource inputSource, QName qName) throws XPathExpressionException
evaluate
in interface XPath
expr
- The XPath 2.0 expression to be compiled and executedinputSource
- The source document: this will be parsed and built into a tree,
and the XPath expression will be executed with the root node of the tree as the
context node.qName
- The type of result required. For details, see
XPathExpressionImpl.evaluate(Object, javax.xml.namespace.QName)
XPathExpressionImpl.evaluate(Object, javax.xml.namespace.QName)
XPathExpressionException
- if any static or dynamic error occurs
in evaluating the expression.
NullPointerException
- if any of the three arguments is nullpublic String evaluate(String expr, InputSource inputSource) throws XPathExpressionException
evaluate
in interface XPath
expr
- The XPath 2.0 expression to be compiled and executedinputSource
- The source document: this will be parsed and built into a tree,
and the XPath expression will be executed with the root node of the tree as the
context node
XPathExpressionException
- if any static or dynamic error occurs
in evaluating the expression.
NullPointerException
- if either of the two arguments is nullpublic static void main(String[] args) throws Exception
args
- command line arguments.
First parameter is the filename containing the source document, second
parameter is the XPath expression.
Exception
- if any error occurs
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |