FileDocCategorySizeDatePackage
XPathImpl.javaAPI DocJava SE 5 API22918Fri Aug 26 14:56:10 BST 2005com.sun.org.apache.xpath.internal.jaxp

XPathImpl

public class XPathImpl extends Object implements XPath
The XPathImpl class provides implementation for the methods defined in javax.xml.xpath.XPath interface. This provide simple access to the results of an XPath expression.
version
$Revision: 1.15 $
author
Ramesh Mandava

Fields Summary
private XPathVariableResolver
variableResolver
private XPathFunctionResolver
functionResolver
private XPathVariableResolver
origVariableResolver
private XPathFunctionResolver
origFunctionResolver
private NamespaceContext
namespaceContext
private JAXPPrefixResolver
prefixResolver
private boolean
featureSecureProcessing
private static Document
d
Constructors Summary
XPathImpl(XPathVariableResolver vr, XPathFunctionResolver fr)

 

          
        this.origVariableResolver = this.variableResolver = vr;
        this.origFunctionResolver = this.functionResolver = fr;
XPathImpl(XPathVariableResolver vr, XPathFunctionResolver fr, boolean featureSecureProcessing)

        this.origVariableResolver = this.variableResolver = vr;
        this.origFunctionResolver = this.functionResolver = fr;
        this.featureSecureProcessing = featureSecureProcessing;
Methods Summary
public javax.xml.xpath.XPathExpressioncompile(java.lang.String expression)

Compile an XPath expression for later evaluation.

If expression contains any {@link XPathFunction}s, they must be available via the {@link XPathFunctionResolver}. An {@link XPathExpressionException} will be thrown if the XPathFunction cannot be resovled with the XPathFunctionResolver.

If expression is null, a NullPointerException is thrown.

param
expression The XPath expression.
return
Compiled XPath expression.
throws
XPathExpressionException If expression cannot be compiled.
throws
NullPointerException If expression is null.

        if ( expression == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPath expression"} );
            throw new NullPointerException ( fmsg );
        }
        try {
            com.sun.org.apache.xpath.internal.XPath xpath = new XPath (expression, null,
                    prefixResolver, com.sun.org.apache.xpath.internal.XPath.SELECT );
            // Can have errorListener
            XPathExpressionImpl ximpl = new XPathExpressionImpl (xpath,
                    prefixResolver, functionResolver, variableResolver,
                    featureSecureProcessing );
            return ximpl;
        } catch ( javax.xml.transform.TransformerException te ) {
            throw new XPathExpressionException ( te ) ;
        }
private com.sun.org.apache.xpath.internal.objects.XObjecteval(java.lang.String expression, java.lang.Object contextItem)

        com.sun.org.apache.xpath.internal.XPath xpath = new com.sun.org.apache.xpath.internal.XPath( expression,
            null, prefixResolver, com.sun.org.apache.xpath.internal.XPath.SELECT ); 
        com.sun.org.apache.xpath.internal.XPathContext xpathSupport = null;
        if ( functionResolver != null ) {
            JAXPExtensionsProvider jep = new JAXPExtensionsProvider(
                    functionResolver, featureSecureProcessing );
            xpathSupport = new com.sun.org.apache.xpath.internal.XPathContext( jep );
        } else { 
            xpathSupport = new com.sun.org.apache.xpath.internal.XPathContext();
        }

        XObject xobj = null;
        
        xpathSupport.setVarStack(new JAXPVariableStack(variableResolver));
        
        // If item is null, then we will create a a Dummy contextNode
        if ( contextItem instanceof Node ) {
            xobj = xpath.execute (xpathSupport, (Node)contextItem,
                    prefixResolver );
        } else {
            xobj = xpath.execute ( xpathSupport, DTM.NULL, prefixResolver );
        }
 
        return xobj;
public java.lang.Objectevaluate(java.lang.String expression, java.lang.Object item, javax.xml.namespace.QName returnType)

Evaluate an XPath expression in the specified context and return the result as the specified type.

See "Evaluation of XPath Expressions" section of JAXP 1.3 spec for context item evaluation, variable, function and QName resolution and return type conversion.

If returnType is not one of the types defined in {@link XPathConstants} ( {@link XPathConstants#NUMBER NUMBER}, {@link XPathConstants#STRING STRING}, {@link XPathConstants#BOOLEAN BOOLEAN}, {@link XPathConstants#NODE NODE} or {@link XPathConstants#NODESET NODESET}) then an IllegalArgumentException is thrown.

If a null value is provided for item, an empty document will be used for the context. If expression or returnType is null, then a NullPointerException is thrown.

param
expression The XPath expression.
param
item The starting context (node or node list, for example).
param
returnType The desired return type.
return
Result of evaluating an XPath expression as an Object of returnType.
throws
XPathExpressionException If expression cannot be evaluated.
throws
IllegalArgumentException If returnType is not one of the types defined in {@link XPathConstants}.
throws
NullPointerException If expression or returnType is null.

        if ( expression == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPath expression"} );
            throw new NullPointerException ( fmsg );
        }
        if ( returnType == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"returnType"} );
            throw new NullPointerException ( fmsg );
        }
        // Checking if requested returnType is supported. returnType need to
        // be defined in XPathConstants
        if ( !isSupported ( returnType ) ) {
            String fmsg = XSLMessages.createXPATHMessage(
                    XPATHErrorResources.ER_UNSUPPORTED_RETURN_TYPE,
                    new Object[] { returnType.toString() } );
            throw new IllegalArgumentException ( fmsg );
        }

        try {
 
            XObject resultObject = eval( expression, item );
            return getResultAsType( resultObject, returnType );
        } catch ( java.lang.NullPointerException npe ) {
            // If VariableResolver returns null Or if we get 
            // NullPointerException at this stage for some other reason
            // then we have to reurn XPathException 
            throw new XPathExpressionException ( npe );
        } catch ( javax.xml.transform.TransformerException te ) {
            Throwable nestedException = te.getException();
            if ( nestedException instanceof javax.xml.xpath.XPathFunctionException ) {
                throw (javax.xml.xpath.XPathFunctionException)nestedException;
            } else {
                // For any other exceptions we need to throw 
                // XPathExpressionException ( as per spec )
                throw new XPathExpressionException ( te );
            }
        }
public java.lang.Stringevaluate(java.lang.String expression, java.lang.Object item)

Evaluate an XPath expression in the specified context and return the result as a String.

This method calls {@link #evaluate(String expression, Object item, QName returnType)} with a returnType of {@link XPathConstants#STRING}.

See "Evaluation of XPath Expressions" of JAXP 1.3 spec for context item evaluation, variable, function and QName resolution and return type conversion.

If a null value is provided for item, an empty document will be used for the context. If expression is null, then a NullPointerException is thrown.

param
expression The XPath expression.
param
item The starting context (node or node list, for example).
return
The String that is the result of evaluating the expression and converting the result to a String.
throws
XPathExpressionException If expression cannot be evaluated.
throws
NullPointerException If expression is null.

        return (String)this.evaluate( expression, item, XPathConstants.STRING );
public java.lang.Objectevaluate(java.lang.String expression, org.xml.sax.InputSource source, javax.xml.namespace.QName returnType)

Evaluate an XPath expression in the context of the specified InputSource and return the result as the specified type.

This method builds a data model for the {@link InputSource} and calls {@link #evaluate(String expression, Object item, QName returnType)} on the resulting document object.

See "Evaluation of XPath Expressions" section of JAXP 1.3 spec for context item evaluation, variable, function and QName resolution and return type conversion.

If returnType is not one of the types defined in {@link XPathConstants}, then an IllegalArgumentException is thrown.

If expression, source or returnType is null, then a NullPointerException is thrown.

param
expression The XPath expression.
param
source The input source of the document to evaluate over.
param
returnType The desired return type.
return
The Object that encapsulates the result of evaluating the expression.
throws
XPathExpressionException If expression cannot be evaluated.
throws
IllegalArgumentException If returnType is not one of the types defined in {@link XPathConstants}.
throws
NullPointerException If expression, source or returnType is null.

        // Checking validity of different parameters
        if( source== null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"source"} );
            throw new NullPointerException ( fmsg );
        }
        if ( expression == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPath expression"} );
            throw new NullPointerException ( fmsg );
        }
        if ( returnType == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"returnType"} );
            throw new NullPointerException ( fmsg );
        }

        //Checking if requested returnType is supported. 
        //returnType need to be defined in XPathConstants
        if ( !isSupported ( returnType ) ) {
            String fmsg = XSLMessages.createXPATHMessage(
                    XPATHErrorResources.ER_UNSUPPORTED_RETURN_TYPE,
                    new Object[] { returnType.toString() } );
            throw new IllegalArgumentException ( fmsg );
        }
        
        try {

            Document document = getParser().parse( source );

            XObject resultObject = eval( expression, document );
            return getResultAsType( resultObject, returnType );
        } catch ( SAXException e ) {
            throw new XPathExpressionException ( e );
        } catch( IOException e ) {
            throw new XPathExpressionException ( e );            
        } catch ( javax.xml.transform.TransformerException te ) {
            Throwable nestedException = te.getException();
            if ( nestedException instanceof javax.xml.xpath.XPathFunctionException ) {
                throw (javax.xml.xpath.XPathFunctionException)nestedException;
            } else {
                throw new XPathExpressionException ( te );
            }
        }
public java.lang.Stringevaluate(java.lang.String expression, org.xml.sax.InputSource source)

Evaluate an XPath expression in the context of the specified InputSource and return the result as a String.

This method calls {@link #evaluate(String expression, InputSource source, QName returnType)} with a returnType of {@link XPathConstants#STRING}.

See "Evaluation of XPath Expressions" section of JAXP 1.3 spec for context item evaluation, variable, function and QName resolution and return type conversion.

If expression or source is null, then a NullPointerException is thrown.

param
expression The XPath expression.
param
source The InputSource of the document to evaluate over.
return
The String that is the result of evaluating the expression and converting the result to a String.
throws
XPathExpressionException If expression cannot be evaluated.
throws
NullPointerException If expression or source is null.

        return (String)this.evaluate( expression, source, XPathConstants.STRING );
private static org.w3c.dom.DocumentgetDummyDocument()

        // we don't need synchronization here; even if two threads
        // enter this code at the same time, we just waste a little time
        if(d==null) {
            DOMImplementation dim = getParser().getDOMImplementation();
            d = dim.createDocument("http://java.sun.com/jaxp/xpath",
                "dummyroot", null);
        }
        return d;
public javax.xml.namespace.NamespaceContextgetNamespaceContext()

Returns the current namespace context.

return
Current Namespace context

        return namespaceContext;
private static javax.xml.parsers.DocumentBuildergetParser()

    
        
        try {
            // we'd really like to cache those DocumentBuilders, but we can't because:
            // 1. thread safety. parsers are not thread-safe, so at least
            //    we need one instance per a thread.
            // 2. parsers are non-reentrant, so now we are looking at having a
            // pool of parsers.
            // 3. then the class loading issue. The look-up procedure of
            //    DocumentBuilderFactory.newInstance() depends on context class loader
            //    and system properties, which may change during the execution of JVM.
            //
            // so we really have to create a fresh DocumentBuilder every time we need one
            // - KK
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            dbf.setNamespaceAware( true );
            dbf.setValidating( false );
            return dbf.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            // this should never happen with a well-behaving JAXP implementation. 
            throw new Error(e);
        }
private java.lang.ObjectgetResultAsType(com.sun.org.apache.xpath.internal.objects.XObject resultObject, javax.xml.namespace.QName returnType)

        // XPathConstants.STRING
        if ( returnType.equals( XPathConstants.STRING ) ) { 
            return resultObject.str();
        }
        // XPathConstants.NUMBER
        if ( returnType.equals( XPathConstants.NUMBER ) ) { 
            return new Double ( resultObject.num());
        }
        // XPathConstants.BOOLEAN
        if ( returnType.equals( XPathConstants.BOOLEAN ) ) { 
            return new Boolean( resultObject.bool());
        }
        // XPathConstants.NODESET ---ORdered, UNOrdered???
        if ( returnType.equals( XPathConstants.NODESET ) ) { 
            return resultObject.nodelist();
        }
        // XPathConstants.NODE
        if ( returnType.equals( XPathConstants.NODE ) ) { 
            NodeIterator ni = resultObject.nodeset(); 
            //Return the first node, or null
            return ni.nextNode();
        }
        String fmsg = XSLMessages.createXPATHMessage(
                XPATHErrorResources.ER_UNSUPPORTED_RETURN_TYPE,
                new Object[] { returnType.toString()});
        throw new IllegalArgumentException( fmsg );
public javax.xml.xpath.XPathFunctionResolvergetXPathFunctionResolver()

Returns the current function resolver.

return
Current function resolver

        return functionResolver;
public javax.xml.xpath.XPathVariableResolvergetXPathVariableResolver()

Returns the current variable resolver.

return
Current variable resolver

        return variableResolver;
private booleanisSupported(javax.xml.namespace.QName returnType)

        if ( ( returnType.equals( XPathConstants.STRING ) ) ||
             ( returnType.equals( XPathConstants.NUMBER ) ) ||
             ( returnType.equals( XPathConstants.BOOLEAN ) ) ||
             ( returnType.equals( XPathConstants.NODE ) ) ||
             ( returnType.equals( XPathConstants.NODESET ) )  ) {
  
            return true;
        }
        return false;
public voidreset()

Reset this XPath to its original configuration.

XPath is reset to the same state as when it was created with {@link XPathFactory#newXPath()}. reset() is designed to allow the reuse of existing XPaths thus saving resources associated with the creation of new XPaths.

The reset XPath is not guaranteed to have the same {@link XPathFunctionResolver}, {@link XPathVariableResolver} or {@link NamespaceContext} Objects, e.g. {@link Object#equals(Object obj)}. It is guaranteed to have a functionally equal XPathFunctionResolver, XPathVariableResolver and NamespaceContext.

        this.variableResolver = this.origVariableResolver;
        this.functionResolver = this.origFunctionResolver;
        this.namespaceContext = null;
public voidsetNamespaceContext(javax.xml.namespace.NamespaceContext nsContext)

Establishes a namespace context.

param
nsContext Namespace context to use

        if ( nsContext == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"NamespaceContext"} );
            throw new NullPointerException( fmsg ); 
        }
        this.namespaceContext = nsContext;
        this.prefixResolver = new JAXPPrefixResolver ( nsContext );
public voidsetXPathFunctionResolver(javax.xml.xpath.XPathFunctionResolver resolver)

Establishes a function resolver.

param
resolver XPath function resolver

        if ( resolver == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPathFunctionResolver"} );
            throw new NullPointerException( fmsg );
        }
        this.functionResolver = resolver;
public voidsetXPathVariableResolver(javax.xml.xpath.XPathVariableResolver resolver)

Establishes a variable resolver.

param
resolver Variable Resolver

        if ( resolver == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPathVariableResolver"} );
            throw new NullPointerException( fmsg );
        }
        this.variableResolver = resolver;