Java XPath Evaluate asByte(String expression, Node node)

Description

Evaluates the specified XPath expression and returns the result as a Byte.

License

Open Source License

Parameter

Parameter	Description
expression	The XPath expression to evaluate.
node	The node to run the expression on.

Exception

Parameter	Description
XPathExpressionException	If there was a problem processing the specified XPathexpression.

Return

The Byte result.

Declaration

public static Byte asByte(String expression, Node node)
        throws XPathExpressionException 

Method Source Code

//package com.java2s;
/*/*from   w  w w  .  j av  a  2  s .co  m*/
 * Copyright 2010 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  http://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file 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.
 */

import javax.xml.xpath.XPathExpressionException;

import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class Main {
    /**
     * Evaluates the specified XPath expression and returns the result as a
     * Byte.
     *
     * @param expression
     *            The XPath expression to evaluate.
     * @param node
     *            The node to run the expression on.
     *
     * @return The Byte result.
     *
     * @throws XPathExpressionException
     *             If there was a problem processing the specified XPath
     *             expression.
     */
    public static Byte asByte(String expression, Node node)
            throws XPathExpressionException {
        String byteString = evaluateAsString(expression, node);
        return (isEmptyString(byteString)) ? null : Byte
                .valueOf(byteString);
    }

    /**
     * Evaluates the specified expression on the specified node and returns the
     * result as a String.
     *
     * @param expression
     *            The Xpath expression to evaluate.
     * @param node
     *            The node on which to evaluate the expression.
     *
     * @return The result of evaluating the specified expression, or null if the
     *         evaluation didn't return any result.
     *
     * @throws XPathExpressionException
     *             If there are any problems evaluating the Xpath expression.
     */
    private static String evaluateAsString(String expression, Node node)
            throws XPathExpressionException {
        if (isEmpty(node))
            return null;

        String s = evaluateXPath(node, expression);
        if (s == null) {
            return null;
        } else {
            return s.trim();
        }
    }

    /**
     * Returns true if the specified string is null or empty.
     *
     * @param s
     *            The string to test.
     * @return True if the specified string is null or empty.
     */
    private static boolean isEmptyString(String s) {
        if (s == null)
            return true;
        if (s.trim().equals(""))
            return true;

        return false;
    }

    /**
     * Returns true if the specified node is null or has no children.
     *
     * @param node
     *            The node to test.
     *
     * @return True if the specified node is null or has no children.
     */
    public static boolean isEmpty(Node node) {
        return (node == null);
    }

    private static String evaluateXPath(Node node, String xPath) {
        int currentSearchIndex = 0;
        while (currentSearchIndex < xPath.length()) {

            int endingIndex = xPath.indexOf("/", currentSearchIndex);

            String noderNameFromXPath = null;
            if (endingIndex == -1) {
                noderNameFromXPath = xPath.substring(currentSearchIndex);
            } else {
                noderNameFromXPath = xPath.substring(currentSearchIndex,
                        endingIndex);
            }

            node = findChildNodeWithName(node, noderNameFromXPath);

            if (endingIndex == -1) {
                break;
            }

            currentSearchIndex = endingIndex + 1;
        }

        if (node != null && node.getFirstChild() != null) {
            return node.getFirstChild().getNodeValue();
        } else if (node != null) {
            return node.getNodeValue();
        } else {
            return null;
        }
    }

    private static Node findChildNodeWithName(Node node, String childName) {
        if (node == null) {
            return null;
        } else {
            if (node.getNodeName().equals(childName)) {
                return node;
            } else {
                NodeList nodeList = node.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    if (nodeList.item(i).getNodeName().equals(childName)) {
                        return nodeList.item(i);
                    }
                }

                return null;
            }
        }
    }
}

Related

1. asByte(String expression, Node node)
2. convertToXpath(String qname)
3. evaluate(Document doc)
4. evaluate(File xmlFile, String xPathExpression)