Android XPath Evaluate asFloat(String expression, Node node)

Description

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

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 Float result.

Declaration

public static Float asFloat(String expression, Node node)
        throws XPathExpressionException 

Method Source Code

//package com.java2s;
/*/*  ww w.ja  v a 2 s. c  o m*/
 * Copyright 2010-2013 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
     * Float.
     *
     * @param expression
     *            The XPath expression to evaluate.
     * @param node
     *            The node to run the expression on.
     *
     * @return The Float result.
     *
     * @throws XPathExpressionException
     *             If there was a problem processing the specified XPath
     *             expression.
     */
    public static Float asFloat(String expression, Node node)
            throws XPathExpressionException {
        String floatString = evaluateAsString(expression, node);
        return (isEmptyString(floatString)) ? null : Float
                .valueOf(floatString);
    }

    /**
     * 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. asString(String expression, Node node)
2. asNode(String nodeName, Node node)
3. asNodeList(String nodeName, Node node)
4. asLong(String expression, Node node)
5. asInteger(String expression, Node node)
6. asDouble(String expression, Node node)
7. asDate(String expression, Node node)
8. asByte(String expression, Node node)
9. asByteBuffer(String expression, Node node)