Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

*

* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

*

* For more information, contact:

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ib??ez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

package es.gva.cit.catalogClient.metadataXML;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringWriter;

import java.util.StringTokenizer;

import java.util.Vector;

import org.apache.xml.serialize.OutputFormat;

import org.apache.xml.serialize.XMLSerializer;

import org.w3c.dom.Document;

/*

 * Created on 15-abr-2005

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Style - Code Templates

 */

/**

 * Utils to parse XML trees using DOM

 * 

 * 

 * @author Jorge Piera Llodra (piera_jor@gva.es)

 */

public class XMLTree {

/**

 * Create a XML node from a File

 * 

 * 

 * @return XML node

 * @param file File name

 */

    public static XMLNode xmlToTree(File file) {        

        try {

            return new XMLNode(file);

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

            return null;

        }

    } 

/**

 * Create a XML node from a InputStream

 * 

 * 

 * @return XML node

 * @param stream InputStream

 */

    public static XMLNode xmlToTree(InputStream stream) {        

        try {

            return new XMLNode(stream);

        } catch (Exception e) {

            // TODO Auto-generated catch block

            //e.printStackTrace();

            return null;

        }

    } 

/**

 * Devuelve un fichero que crea a partir de un arbol XML

 * 

 * 

 * @return Devuelve el fichero escrito

 * @param dom Documento en XML

 * @param nombreFichero Nombre del fichero.

 */

    public static File treeToXML(Document dom, String nombreFichero) {        

        OutputFormat format = null;

        StringWriter stringOut = null;

        XMLSerializer serial = null;

        FileWriter file = null;

        //Creamos un fichero para almacenar la respuesta

        File file_answer = new File(nombreFichero);

        format = new OutputFormat(dom);

        format.setEncoding("ISO-8859-1");

        format.setIndent(5);

        stringOut = new StringWriter();

        serial = new XMLSerializer(stringOut, format);

        try {

            serial.asDOMSerializer();

            serial.serialize(dom);

            file = new FileWriter(file_answer);

            file.write(stringOut.toString());

            file.close();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

            return null;

        }

        return file_answer;

    } 

/**

 * Busca un Nodo dado una ruta de nodo del tipo "nodoRaiz:nodoPrimerNivel:...:nodoNivelN":

 * 

 * 

 * @return Devuelve el Nodo que corresponde a la ruta correcta o 'null' si no

 * lo encuentra

 * @param nodoRaiz Nodo a partir del cual se quiere hacer la b?squeda

 * @param etiqueta Ruta del campo que queremos buscar, separando los niveles por ':'

 */

    public static XMLNode searchNode(XMLNode nodoRaiz, String etiqueta) {        

        XMLNode[] nodes = searchMultipleNode(nodoRaiz, etiqueta);

        if ((nodes != null) && (nodes.length > 0)) {

            return nodes[0];

        } else {

            return null;

        }

    } 

/**

 * Busca el padre de un Nodo dado una ruta de nodo del tipo "nodoRaiz:nodoPrimerNivel:...:nodoNivelN":

 * 

 * @param nodoRaiz Nodo a partir del cual se quiere hacer la b?squeda

 * @param etiqueta Ruta del campo que queremos buscar, separando los niveles por ':'

 * 

 * @return Devuelve el Nodo padre que corresponde a la ruta correcta o 'null' si no

 * lo encuentra

 * @param rootNode 

 * @param label 

 */

    public static XMLNode searchParentNode(XMLNode rootNode, String label) {        

        StringTokenizer sti = new StringTokenizer(label, "->");

        if (rootNode == null) {

            return null;

        }

        XMLNode currentNode = rootNode.getSubNode(0);

        XMLNode parentNode = rootNode;

        //A cuantos niveles est? el TOKEN

        int niveles = sti.countTokens();

        String nombreNodo = sti.nextToken();

        int nivelActual = 1;

        int i = 0;

        while (i < parentNode.getNumSubNodes()) {

            if (nombreNodo.equals(currentNode.getName())) {

                if (niveles == nivelActual) {

                    return parentNode;

                }

                parentNode = currentNode;

                currentNode = currentNode.getSubNode(0);

                nombreNodo = sti.nextToken();

                nivelActual++;

                i = 0;

            } else {

                currentNode = currentNode.getSubNode(i);

                i ++;

            }

        }

        return null;

    } 

/**

 * Hace una busqueda de un atributo de un nodo

 * 

 * @param nodo Nodo del que se quiere buscar el atributo

 * @param nombreAtributo Nombre del atributo

 * 

 * @return Valor del atributo, o null si no lo ha encontrado

 * @param node 

 * @param attributeName 

 */

    public static String searchAtribute(XMLNode node, String attributeName) {        

        return node.getAttribute(attributeName);

    } 

/**

 * Hace una busqueda de una etiqueta en un nodo y devuelve

 * su valor

 * 

 * @param nodo Nodo del que se quiere buscar el atributo

 * 

 * @return Valor de la etiqueta

 * @param node 

 * @param etiqueta Nombre de la etiqueta

 */

    public static String searchNodeValue(XMLNode node, String etiqueta) {        

        XMLNode nodoB = searchNode(node, etiqueta);

        if (nodoB == null)

            return null;

        return nodoB.getText();

    } 

/**

 * Hace una busqueda de una etiqueta en un nodo y devuelve

 * el valor del atributo correspondiente

 * 

 * @param nodo Nodo del que se quiere buscar el atributo

 * 

 * @return Valor del atributo de la etiqueta o null

 * @param node 

 * @param etiqueta Nombre de la etiqueta

 * @param atributo 

 */

    public static String searchNodeAtribute(XMLNode node, String etiqueta, String atributo) {        

        XMLNode nodoB = searchNode(node, etiqueta);

        if (nodoB == null) {

            return null;

        } else {

            return searchAtribute(nodoB, atributo);

        }

    } 

/**

 * Hace una busqueda de nodos que se llaman igual y devuleve el valor

 * 

 * @param parentLabel Ruta del campo que queremos buscar, separando los niveles por '->'

 * 

 * @return Un vector con valores de las etiquetas

 * @param rootNode Nodo a partir del cual se quiere hacer la b?squeda

 * @param label Node label

 */

    public static String[] searchMultipleNodeValue(XMLNode rootNode, String label) {        

        XMLNode[] nodes = searchMultipleNode(rootNode, label);

        if ((nodes == null) || (nodes.length == 0)) {

            return null;

        }

        String[] values = new String[nodes.length];

        for (int i = 0; i < nodes.length; i++)

            //if (nodes[i].getFirstChild() != null) {

                values[i] = nodes[i].getText();

            //}

        return values;

    } 

/**

 * Hace una busqueda de nodos que se llaman igual desde uno dado(sin recursividad)

 * 

 * @param etiqueta Ruta del campo que queremos buscar, separando los niveles por ':'

 * 

 * @return Un vector con los nodos que ha encontrado

 * @param nodoRaiz Nodo a partir del cual se quiere hacer la b?squeda

 * @param label 

 */

    public static XMLNode[] searchMultipleNode(XMLNode nodoRaiz, String label) {        

        Vector rootNodes = new Vector();

        Vector leafNodes = new Vector();

        String firstLabel = null;

        leafNodes.add(nodoRaiz);

        int level = getLevelNumber(label);

        int k = 1;

        while (k <= level) {

            firstLabel = getParentLabel(label);

            label = getChildLabel(label);

            rootNodes = new Vector(leafNodes);

            leafNodes.clear();

            for (int i = 0; i < rootNodes.size(); i++) {

                XMLNode root = (XMLNode) rootNodes.get(i);

                if (root != null) {

                    XMLNode[] nodes = root.getSubnodes();

                    for (int j = 0; j < nodes.length; j++) {

                        if (nodes[j].getName().equals(firstLabel)) {

                            leafNodes.add(nodes[j]);

                        }

                    }

                }

            }

            k++;

        }

        XMLNode[] nodes = new XMLNode[leafNodes.size()];

        for (int i = 0; i < leafNodes.size(); i++)

            nodes[i] = (XMLNode) leafNodes.get(i);

        return nodes;

    } 

/**

 * Gets the parent node label

 * 

 * 

 * @return The parent node label

 * @param nodeLabel Node label

 */

    private static String getParentLabel(String nodeLabel) {        

          return separateParams(nodeLabel,"->")[0];

    } 

/**

 * It cuts an String in an array of Strings separated by a pattern

 * 

 * 

 * @return An array of Strings

 * @param text Text to cut

 * @param separator Pattent to find      *

 */

    private static String[] separateParams(String text, String separator) {        

       return text.split(separator);

    } 

/**

 * Gets the node label

 * 

 * 

 * @return The node label

 * @param nodeLabel Node label

 */

    private static String getChildLabel(String nodeLabel) {        

        String st = null;

        String[] labels = separateParams(nodeLabel,"->");

        if (labels.length  == 1){

            return labels[0];

        }

        st = labels[1];

        for (int i=2 ; i<labels.length ; i++)

            st = st + "->" + labels[i];

        return st;

    } 

/**

 * 

 * 

 * 

 * @return 

 * @param nodeLabel 

 */

    private static int getLevelNumber(String nodeLabel) {        

        String[] labels = separateParams(nodeLabel,"->");

        return labels.length;

    } 

 }