Java XPathException类代码示例

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
* Creates a parsed XPath expression with resolved namespaces. This is
* useful when an expression will be reused in an application since it
* makes it possible to compile the expression string into a more
* efficient internal form and preresolve all namespace prefixes which
* occur within the expression.
*
* @param expression The XPath expression string to be parsed.
* @param resolver The <code>resolver</code> permits translation of
*   prefixes within the XPath expression into appropriate namespace URIs
*   . If this is specified as <code>null</code>, any namespace prefix
*   within the expression will result in <code>DOMException</code>
*   being thrown with the code <code>NAMESPACE_ERR</code>.
* @return The compiled form of the XPath expression.
* @exception XPathException
*   INVALID_EXPRESSION_ERR: Raised if the expression is not legal
*   according to the rules of the <code>XPathEvaluator</code>i
* @exception DOMException
*   NAMESPACE_ERR: Raised if the expression contains namespace prefixes
*   which cannot be resolved by the specified
*   <code>XPathNSResolver</code>.
*
    * @see org.w3c.dom.xpath.XPathEvaluator#createExpression(String, XPathNSResolver)
    */
   public XPathExpression createExpression(
           String expression,
           XPathNSResolver resolver)
           throws XPathException, DOMException {

           try {

                   // If the resolver is null, create a dummy prefix resolver
                   XPath xpath =  new XPath(expression,null,
                        ((null == resolver) ? new DummyPrefixResolver() : ((PrefixResolver)resolver)),
                         XPath.SELECT);

       return new XPathExpressionImpl(xpath, m_doc);

           } catch (TransformerException e) {
                   // Need to pass back exception code DOMException.NAMESPACE_ERR also.
                   // Error found in DOM Level 3 XPath Test Suite.
                   if(e instanceof XPathStylesheetDOM3Exception)
                           throw new DOMException(DOMException.NAMESPACE_ERR,e.getMessageAndLocation());
                   else
                           throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,e.getMessageAndLocation());

           }
   }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
     * Returns the <code>index</code>th item in the snapshot collection. If
     * <code>index</code> is greater than or equal to the number of nodes in
     * the list, this method returns <code>null</code>. Unlike the iterator
     * result, the snapshot does not become invalid, but may not correspond
     * to the current document if it is mutated.
     * @param index Index into the snapshot collection.
     * @return The node at the <code>index</code>th position in the
     *   <code>NodeList</code>, or <code>null</code> if that is not a valid
     *   index.
     * @exception XPathException
     *   TYPE_ERR: raised if <code>resultType</code> is not
     *   <code>UNORDERED_NODE_SNAPSHOT_TYPE</code> or
     *   <code>ORDERED_NODE_SNAPSHOT_TYPE</code>.
     *
         * @see org.w3c.dom.xpath.XPathResult#snapshotItem(int)
         */
        public Node snapshotItem(int index) throws XPathException {

                if ((m_resultType != UNORDERED_NODE_SNAPSHOT_TYPE) &&
                    (m_resultType != ORDERED_NODE_SNAPSHOT_TYPE)) {
           String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_NON_SNAPSHOT_TYPE, new Object[] {m_xpath.getPatternString(), getTypeString(m_resultType)});
           throw new XPathException(XPathException.TYPE_ERR, fmsg);
//              "The method snapshotItem cannot be called on the XPathResult of XPath expression {0} because its XPathResultType is {1}.
//              This method applies only to types UNORDERED_NODE_SNAPSHOT_TYPE and ORDERED_NODE_SNAPSHOT_TYPE."},
            }

        Node node = m_list.item(index);

        // Wrap "namespace node" in an XPathNamespace
        if (isNamespaceNode(node)) {
            return new XPathNamespaceImpl(node);
        } else {
            return node;
        }
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
protected void update(Node n) {
    if (!isSelected(n)) {
        try {
            double matchScore
                = xpath.execute(context, n, prefixResolver).num();
            if (matchScore != XPath.MATCH_SCORE_NONE) {
                if (!descendantSelected(n)) {
                    nodes.add(n);
                }
            } else {
                n = n.getFirstChild();
                while (n != null) {
                    update(n);
                    n = n.getNextSibling();
                }
            }
        } catch (javax.xml.transform.TransformerException te) {
            AbstractDocument doc
                = (AbstractDocument) contentElement.getOwnerDocument();
            throw doc.createXPathException
                (XPathException.INVALID_EXPRESSION_ERR,
                 "xpath.error",
                 new Object[] { expression, te.getMessage() });
        }
    }
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
DomXPathExpression(DomDocument doc, String expression,
                   XPathNSResolver resolver)
  throws XPathException
{
  this.doc = doc;
  this.resolver = resolver;

              XPathFactory factory = XPathFactory.newInstance();
              XPath xpath = factory.newXPath();
              if (resolver != null)
                {
                              xpath.setNamespaceContext(new DomNSResolverContext(resolver));
                }
  try
    {
      this.expression = xpath.compile(expression);
    }
  catch (XPathExpressionException e)
    {
      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
                                                                   e.getMessage ());
    }
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
public Node getSingleNodeValue()
{
  switch (type)
    {
    case XPathResult.FIRST_ORDERED_NODE_TYPE:
    case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
    case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
    case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
    case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
      Collection ns = (Collection) value;
      if (ns.isEmpty ())
        {
          return null;
        }
      else
        {
          return (Node) ns.iterator ().next ();
        }
    }
  throw new XPathException (XPathException.TYPE_ERR, value.toString ());
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
public Node iterateNext()
{
  if (iterator != null)
    {
      if (iterator.hasNext ())
        {
          return (Node) iterator.next ();
        }
      else
        {
          iterator = null;
          return null;
        }
    }
  throw new XPathException (XPathException.TYPE_ERR, value.toString ());
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
public Node snapshotItem(int index)
{
  switch (type)
    {
    case XPathResult.FIRST_ORDERED_NODE_TYPE:
    case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
    case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
    case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
    case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
      Collection ns = (Collection) value;
      Node[] nodes = new Node[ns.size ()];
      ns.toArray (nodes);
      return nodes[index];
    }
  throw new XPathException (XPathException.TYPE_ERR, value.toString ());
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
DomXPathExpression(DomDocument doc, String expression,
                   XPathNSResolver resolver)
  throws XPathException
{
  this.doc = doc;
  this.resolver = resolver;
  
XPathFactory factory = XPathFactory.newInstance();
XPath xpath = factory.newXPath();
if (resolver != null)
  {
		xpath.setNamespaceContext(new DomNSResolverContext(resolver));
	  }
  try
    {
      this.expression = xpath.compile(expression);
    }
  catch (XPathExpressionException e)
    {
      throw new XPathException(XPathException.INVALID_EXPRESSION_ERR,
				                     e.getMessage ());
    }
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
         *  The value of this number result.
     * @exception XPathException
     *   TYPE_ERR: raised if <code>resultType</code> is not
     *   <code>NUMBER_TYPE</code>.
         * @see org.w3c.dom.xpath.XPathResult#getNumberValue()
         */
        public double getNumberValue() throws XPathException {
                if (getResultType() != NUMBER_TYPE) {
                        String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_CANT_CONVERT_XPATHRESULTTYPE_TO_NUMBER, new Object[] {m_xpath.getPatternString(), getTypeString(m_resultType)});
                        throw new XPathException(XPathException.TYPE_ERR,fmsg);
//              "The XPathResult of XPath expression {0} has an XPathResultType of {1} which cannot be converted to a number"
                } else {
                        try {
                           return m_resultObj.num();
                        } catch (Exception e) {
                                // Type check above should prevent this exception from occurring.
                                throw new XPathException(XPathException.TYPE_ERR,e.getMessage());
                        }
                }
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
         * The value of this string result.
     * @exception XPathException
     *   TYPE_ERR: raised if <code>resultType</code> is not
     *   <code>STRING_TYPE</code>.
     *
         * @see org.w3c.dom.xpath.XPathResult#getStringValue()
         */
        public String getStringValue() throws XPathException {
                if (getResultType() != STRING_TYPE) {
                        String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_CANT_CONVERT_TO_STRING, new Object[] {m_xpath.getPatternString(), m_resultObj.getTypeString()});
                        throw new XPathException(XPathException.TYPE_ERR,fmsg);
//              "The XPathResult of XPath expression {0} has an XPathResultType of {1} which cannot be converted to a string."
                } else {
                        try {
                           return m_resultObj.str();
                        } catch (Exception e) {
                                // Type check above should prevent this exception from occurring.
                                throw new XPathException(XPathException.TYPE_ERR,e.getMessage());
                        }
                }
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
         * @see org.w3c.dom.xpath.XPathResult#getBooleanValue()
         */
        public boolean getBooleanValue() throws XPathException {
                if (getResultType() != BOOLEAN_TYPE) {
                        String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_CANT_CONVERT_TO_BOOLEAN, new Object[] {m_xpath.getPatternString(), getTypeString(m_resultType)});
                        throw new XPathException(XPathException.TYPE_ERR,fmsg);
//              "The XPathResult of XPath expression {0} has an XPathResultType of {1} which cannot be converted to a boolean."
                } else {
                        try {
                           return m_resultObj.bool();
                        } catch (TransformerException e) {
                                // Type check above should prevent this exception from occurring.
                                throw new XPathException(XPathException.TYPE_ERR,e.getMessage());
                        }
                }
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
         * The value of this single node result, which may be <code>null</code>.
     * @exception XPathException
     *   TYPE_ERR: raised if <code>resultType</code> is not
     *   <code>ANY_UNORDERED_NODE_TYPE</code> or
     *   <code>FIRST_ORDERED_NODE_TYPE</code>.
     *
         * @see org.w3c.dom.xpath.XPathResult#getSingleNodeValue()
         */
        public Node getSingleNodeValue() throws XPathException {

                if ((m_resultType != ANY_UNORDERED_NODE_TYPE) &&
                    (m_resultType != FIRST_ORDERED_NODE_TYPE)) {
                                String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_CANT_CONVERT_TO_SINGLENODE, new Object[] {m_xpath.getPatternString(), getTypeString(m_resultType)});
                                throw new XPathException(XPathException.TYPE_ERR,fmsg);
//                              "The XPathResult of XPath expression {0} has an XPathResultType of {1} which cannot be converted to a single node.
//                               This method applies only to types ANY_UNORDERED_NODE_TYPE and FIRST_ORDERED_NODE_TYPE."
            }

                NodeIterator result = null;
                try {
                        result = m_resultObj.nodeset();
                } catch (TransformerException te) {
                        throw new XPathException(XPathException.TYPE_ERR,te.getMessage());
                }

        if (null == result) return null;

        Node node = result.nextNode();

        // Wrap "namespace node" in an XPathNamespace
        if (isNamespaceNode(node)) {
            return new XPathNamespaceImpl(node);
        } else {
            return node;
        }
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
         * The number of nodes in the result snapshot. Valid values for
     * snapshotItem indices are <code>0</code> to
     * <code>snapshotLength-1</code> inclusive.
     * @exception XPathException
     *   TYPE_ERR: raised if <code>resultType</code> is not
     *   <code>UNORDERED_NODE_SNAPSHOT_TYPE</code> or
     *   <code>ORDERED_NODE_SNAPSHOT_TYPE</code>.
     *
         * @see org.w3c.dom.xpath.XPathResult#getSnapshotLength()
         */
        public int getSnapshotLength() throws XPathException {

                if ((m_resultType != UNORDERED_NODE_SNAPSHOT_TYPE) &&
                    (m_resultType != ORDERED_NODE_SNAPSHOT_TYPE)) {
                                String fmsg = XPATHMessages.createXPATHMessage(XPATHErrorResources.ER_CANT_GET_SNAPSHOT_LENGTH, new Object[] {m_xpath.getPatternString(), getTypeString(m_resultType)});
                                throw new XPathException(XPathException.TYPE_ERR,fmsg);
//                              "The method getSnapshotLength cannot be called on the XPathResult of XPath expression {0} because its XPathResultType is {1}.
            }

                return m_list.getLength();
        }
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
 * Parses the XPath selector.
 */
protected void parse() {
    context = new XPathContext();
    try {
        xpath = new XPath(expression, null, prefixResolver, XPath.MATCH);
    } catch (javax.xml.transform.TransformerException te) {
        AbstractDocument doc
            = (AbstractDocument) contentElement.getOwnerDocument();
        throw doc.createXPathException
            (XPathException.INVALID_EXPRESSION_ERR,
             "xpath.invalid.expression",
             new Object[] { expression, te.getMessage() });
    }
}
 

import org.w3c.dom.xpath.XPathException; //导入依赖的package包/类
/**
 * <b>DOM</b>: Implements
 * {@link org.w3c.dom.xpath.XPathEvaluator#evaluate(String,Node,XPathNSResolver,short,Object)}.
 */
public Object evaluate(String expression,
                       Node contextNode,
                       XPathNSResolver resolver,
                       short type,
                       Object result)
        throws XPathException, DOMException {
    XPathExpression xpath = createExpression(expression, resolver);
    return xpath.evaluate(contextNode, type, result);
}