org/objectweb/proactive/core/xml/XMLPropertiesStore.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.xml;


public class XMLPropertiesStore {
    //
    //  ----- STATIC MEMBERS -----------------------------------------------------------------------------------
    //
    //
    //  ----- PRIVATE MEMBERS -----------------------------------------------------------------------------------
    //

    private String targetURI;

    private org.w3c.dom.Document targetDocument;

    private org.w3c.dom.Element rootElement;

    //
    //  ----- CONSTRUCTORS -----------------------------------------------------------------------------------
    //

    public XMLPropertiesStore(String uri) throws java.io.IOException {
        this.targetURI = uri;
        this.targetDocument = parseFromURI(uri);
        this.rootElement = targetDocument.getDocumentElement();
    }

    //
    //  ----- STATIC METHODS -----------------------------------------------------------------------------------
    //

    public static org.w3c.dom.Document parseFromURI(String uri)
        throws java.io.IOException {
        try {
            javax.xml.parsers.DocumentBuilderFactory factory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
            javax.xml.parsers.DocumentBuilder documentBuilder = factory.newDocumentBuilder();
            return documentBuilder.parse(uri);
        } catch (org.xml.sax.SAXException e) {
            throw new java.io.IOException(e.toString());
        } catch (javax.xml.parsers.ParserConfigurationException e) {
            throw new java.io.IOException(e.toString());
        }
    }

    //
    //  ----- PUBLIC METHODS -----------------------------------------------------------------------------------
    //

    public String getValueAsString(String path) {
        return getValueAsString(path, rootElement);
    }

    public int getValueAsInt(String path, int defaultValue) {
        return getValueAsInt(path, rootElement, defaultValue);
    }

    public org.w3c.dom.Node getValueAsNode(String path) {
        return getValueAsNode(path, rootElement);
    }

    public org.w3c.dom.Node[] getAllNodes(String path) {
        return getAllNodes(path, rootElement);
    }

    public String getValueAsString(String path, org.w3c.dom.Node context) {
        if (context.getOwnerDocument() != targetDocument) {
            return null;
        }
        org.w3c.dom.Node node = findNodeFromXPath(path, context);
        if (node == null) {
            return null;
        }
        int type = node.getNodeType();
        if (type == org.w3c.dom.Node.ELEMENT_NODE) {
            org.w3c.dom.Node child = node.getFirstChild();
            if (child == null) {
                return null;
            }
            return child.getNodeValue();
        } else {
            return node.getNodeValue();
        }
    }

    public int getValueAsInt(String path, org.w3c.dom.Node context,
        int defaultValue) {
        String s = getValueAsString(path, context);
        if (s == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    public org.w3c.dom.Node getValueAsNode(String path, org.w3c.dom.Node context) {
        if (context.getOwnerDocument() != targetDocument) {
            return null;
        }
        return findNodeFromXPath(path, context);
    }

    public org.w3c.dom.Node[] getAllNodes(String path, org.w3c.dom.Node context) {
        if (context.getOwnerDocument() != targetDocument) {
            return null;
        }
        return findNodesFromXPath(path, context);
    }

    /*
       // for testing purpose
       public static void main(String[] args) {
         String uri = null;
         if (args.length > 0) {
           uri = args[0];
         } else {
           uri = "file:///D:/cygwin/home/lmestre/ProActive/ProActiveDescriptor2.xml";
           System.out.println("uri="+uri);
         }
         try {
           XMLPropertiesStore p = new XMLPropertiesStore(uri);
           System.out.println("p="+p.toString());
           System.out.println("  ====  ");
         } catch (java.io.IOException e) {
           e.printStackTrace();
         }
       }
       // for testing purpose
       public String toString() {
         try {
           return serializeDocumentToString(targetDocument);
         } catch (java.io.IOException e) {
           e.printStackTrace();
           return null;
         }
       }
       public static String serializeDocumentToString(org.w3c.dom.Document doc) throws java.io.IOException {
         org.apache.xml.serialize.OutputFormat of = new org.apache.xml.serialize.OutputFormat(
             org.apache.xml.serialize.Method.XML,
             org.apache.xml.serialize.OutputFormat.Defaults.Encoding,true);
         of.setIndent(2);
         org.apache.xml.serialize.XMLSerializer ts = new org.apache.xml.serialize.XMLSerializer(of);
         java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
         java.io.Writer writer = new java.io.PrintWriter(baos,false);
         ts.setOutputCharStream(writer);
         ts.serialize(doc);
         writer.flush();
         writer.close();
         return baos.toString();
       }
     */

    //
    //  ----- PRIVATE METHODS -----------------------------------------------------------------------------------
    //

    private org.w3c.dom.Node findNodeFromXPath(String path,
        org.w3c.dom.Node node) {
        // deals with special cases if path is empty or point to the current node
        if ((path == null) || (path.length() == 0) || path.equals(".")) {
            return node;
        }

        // find the possible attribute in the XPath expression
        int n = path.indexOf('@');
        String attributeName = null;
        if ((n > -1) && (n < (path.length() - 1))) {
            attributeName = path.substring(n + 1);
            path = path.substring(0, n);
        }

        // deal with case where the XPath was just an attribute
        if (path.length() == 0) {
            return findNamedAttribute(attributeName, node);
        }

        java.util.StringTokenizer st = new java.util.StringTokenizer(path, "/");
        if (path.charAt(0) == '/') {
            // case of an absolute path (starting from the root node)
            // in this case we process the current node
            node = rootElement;
            if (st.hasMoreTokens()) {
                String t = st.nextToken();
                if (!t.equals(node.getNodeName())) {
                    return null;
                }
            }
        }

        // iterates through the /
        while (st.hasMoreTokens() && (node != null)) {
            String t = st.nextToken();
            if (t.equals(".")) {
                break;
            }
            node = findNamedChild(t, node);
        }
        return findNamedAttribute(attributeName, node);
    }

    private org.w3c.dom.Node[] findNodesFromXPath(String path,
        org.w3c.dom.Node node) {
        // deals with special cases if path is empty or point to the current node
        if ((path == null) || (path.length() == 0) || path.equals(".")) {
            return null;
        }

        // remove possible attribute in the XPath expression
        int n = path.indexOf('@');
        if ((n > -1) && (n < (path.length() - 1))) {
            path = path.substring(0, n);
        }

        // deal with case where the XPath was just an attribute
        if (path.length() == 0) {
            return null;
        }

        java.util.StringTokenizer st = new java.util.StringTokenizer(path, "/");
        if (path.charAt(0) == '/') {
            // case of an absolute path (starting from the root node)
            // in this case we process the current node
            node = rootElement;
            if (st.hasMoreTokens()) {
                String t = st.nextToken();
                if (!t.equals(node.getNodeName())) {
                    return null;
                }
            }
        }

        // iterates through the /
        if (!st.hasMoreTokens()) {
            return null;
        }
        while (node != null) {
            String t = st.nextToken();
            if (t.equals(".")) {
                return null;
            }
            if (st.hasMoreTokens()) {
                node = findNamedChild(t, node);
            } else {
                return findNamedChilds(t, node);
            }
        }
        return null;
    }

    private org.w3c.dom.Node findNamedAttribute(String attributeName,
        org.w3c.dom.Node node) {
        if ((attributeName == null) || (attributeName.length() == 0)) {
            return node;
        }
        org.w3c.dom.NamedNodeMap attributes = node.getAttributes();
        if (attributes == null) {
            return null;
        }
        return attributes.getNamedItem(attributeName);
    }

    private org.w3c.dom.Node findNamedChild(String name, org.w3c.dom.Node node) {
        org.w3c.dom.Node child = node.getFirstChild();
        while (child != null) {
            if (name.equals(child.getNodeName())) {
                return child;
            }
            child = child.getNextSibling();
        }
        return child;
    }

    private org.w3c.dom.Node[] findNamedChilds(String name,
        org.w3c.dom.Node node) {
        org.w3c.dom.Node child = node.getFirstChild();
        java.util.ArrayList result = new java.util.ArrayList();
        while (child != null) {
            if (name.equals(child.getNodeName())) {
                result.add(child);
            }
            child = child.getNextSibling();
        }
        int n = result.size();
        if (n == 0) {
            return null;
        }
        org.w3c.dom.Node[] resultArray = new org.w3c.dom.Node[n];
        return (org.w3c.dom.Node[]) result.toArray(resultArray);
    }
}

---