Android XPath Evaluate asByteBuffer(String expression, Node node)

Description

Evaluates the specified xpath expression, base64 decodes the data and returns the result as a ByteBuffer.

License

Open Source License

Parameter

Parameter	Description
expression	The Xpath expression to evaluate.
node	The node on which to evaluate the expression.

Exception

Parameter	Description
XPathExpressionException	If there are any problems evaluating the Xpath expression.

Return

A ByteBuffer of base64 decoded data from the result of evaluating the specified Xpath expression.

Declaration

public static ByteBuffer asByteBuffer(String expression, Node node)
        throws XPathExpressionException

Method Source Code

//package com.java2s;
/*/*www .  ja v a2s.  c om*/
 * 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 java.io.UnsupportedEncodingException;

import java.nio.ByteBuffer;

import javax.xml.xpath.XPathExpressionException;

import org.apache.commons.codec.binary.Base64;

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

import com.amazonaws.AmazonClientException;

public class Main {
    /**
     * Evaluates the specified xpath expression, base64 decodes the data and
     * returns the result as a ByteBuffer.
     *
     * @param expression
     *            The Xpath expression to evaluate.
     * @param node
     *            The node on which to evaluate the expression.
     *
     * @return A ByteBuffer of base64 decoded data from the result of evaluating
     *         the specified Xpath expression.
     *
     * @throws XPathExpressionException
     *             If there are any problems evaluating the Xpath expression.
     */
    public static ByteBuffer asByteBuffer(String expression, Node node)
            throws XPathExpressionException {
        String base64EncodedString = evaluateAsString(expression, node);
        if (isEmptyString(base64EncodedString))
            return null;

        if (!isEmpty(node)) {
            try {
                byte[] base64EncodedBytes = base64EncodedString
                        .getBytes("UTF-8");
                byte[] decodedBytes = Base64
                        .decodeBase64(base64EncodedBytes);
                return ByteBuffer.wrap(decodedBytes);
            } catch (UnsupportedEncodingException e) {
                throw new AmazonClientException(
                        "Unable to unmarshall XML data into a ByteBuffer",
                        e);
            }
        }
        return null;
    }

    /**
     * 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;
            }
        }
    }
}