source: trunk/gsdl3/src/java/org/greenstone/gsdl3/util/GSXML.java@ 3466

package org.greenstone.gsdl3.util;

import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
import org.w3c.dom.Text;

import java.util.HashMap;

/** various functions for extracting info out of GS XML */
public class GSXML {

    public static final String PARAM_TYPE_INTEGER = "integer";
    public static final String PARAM_TYPE_BOOLEAN = "boolean";
    public static final String PARAM_TYPE_ENUM = "enum";
  // takes a node with a resource elements inside it and extracts all the 
  // HASh oids - name att for resource
    public static String [] getResourceNameList(Element content) {
    
    Node n = content.getFirstChild();
    while (n!=null && !n.getNodeName().equals("resourceList")) {
        n = n.getNextSibling();
    }
    if (n==null) { // no docs found
        return null;
    }
        
    NodeList docs = n.getChildNodes();
    
    int numdocs = docs.getLength();
    String []ids = new String[numdocs];
    for (int i=0; i<numdocs; i++) {
        Element e = (Element)docs.item(i);
        String id = e.getAttribute("name");
        // check that its a valid id - ie starts with HASH 
        // need to change this if use different ids
        
        ids[i] = id;
        
    }

    return ids;
    }

    /** extracts metadata names out of an element */
    public static String [] getMetaNameList(Element content) {
    Node n = content.getFirstChild();
    while (n!=null && !n.getNodeName().equals("metadataList")) {
        n = n.getNextSibling();
    }
    if (n==null) { // no metadatas found
        return null;
    }
    NodeList elems = n.getChildNodes();
    
    int numelems = elems.getLength();
    String []ids = new String[numelems];
    for (int i=0; i<numelems; i++) {
        Element e = (Element)elems.item(i);
        String id = e.getAttribute("name");
        ids[i] = id;
    }

    return ids;
    }

    /** takes a paramList element, and gets a HashMap of name-value pairs */
    public static HashMap extractParams(Element xml) {

    if (!xml.getNodeName().equals("paramList")) {
        System.err.println("GSXML:paramList element should have been passed to extractParams, instead it was "+xml.getNodeName());
        return null;
    }
    NodeList params = xml.getChildNodes();
    HashMap param_map = new HashMap();
    for (int i=0; i<params.getLength(); i++) {
        Element param = (Element)params.item(i);
        String name=param.getAttribute("name");
        String value=param.getAttribute("value");
        if (value.equals("")) { // the value is in the content of the param
        value=getNodeText(param); 
        }
        param_map.put(name, value);
        
    }
    return param_map;
    }

    public static String getValue(Element e) {
    String val = e.getAttribute("value");
    if (val ==null || val.equals("")) {
        // have to get it out of the text
        val=getNodeText(e); 

    }
    return val;
    }
    /** extracts the text out of a node */
    public static String getNodeText(Element param) {
    param.normalize();
    Node n = param.getFirstChild();
    while (n!=null && n.getNodeType() !=Node.TEXT_NODE) {
        n=n.getNextSibling();
    }
    if (n==null) { // no text node
        return "";
    }
    return n.getNodeValue();
    }
    /** creates a new document Element */
    public static Element createResourceElement(Document owner, String oid) { 
    Element e = owner.createElement("resource");
    e.setAttribute("name", oid);
    
    return e;
    }
    
    /** add text to a document/subsection  element */
    public static boolean addDocText(Document owner, Element doc, String text) {

    Element content = owner.createElement("content");
    Text t = owner.createTextNode(text);
    content.appendChild(t);
    doc.appendChild(content);
    return true;
    }
    /** adds an empty MetadataList elem to a doc, and returns a ref to it*/
    public static Element addMetaList(Document owner, Element doc) {
    Element list = owner.createElement("metadataList");
    doc.appendChild(list);
    return list;
    }
    /** adds a metadata elem to a list */
    public static boolean addMetadata(Document owner, Element list, 
                      String meta_name, String meta_value) {
    if (meta_value==null || meta_value.equals("")) {
        return false;
    }
    Element data = owner.createElement("metadata");
    data.setAttribute("name", meta_name);
    Text t = owner.createTextNode(meta_value);
    data.appendChild(t);
    list.appendChild(data);
    return true;

    }

    public static boolean mergeMetadataLists(Node to, Node from) {
    Node to_meta = GSXML.getChildByTagName(to, "metadataList");
    Node from_meta = getChildByTagName(from, "metadataList");
    
    if  (from_meta == null) { // nothing to copy
        return true;
    }
    Document to_owner = to.getOwnerDocument();
    Node new_from = to_owner.importNode(from_meta, true);

    if (to_meta == null) { // just copy the whole list
        to.appendChild(new_from);
        return true;
    }
    
    // copy individual elements
    Node child = new_from.getFirstChild();
    while ( child != null) {
        to_meta.appendChild(child);
        child = child.getNextSibling();
    }
    return true;
    }
    
    /** takes two nodes - should have the same node type, tag name, etc
     * copies the info from 'from' into 'to' 
     -- not finished haven't thought through the algo yet.*/
    /*
    public static boolean mergeElements(Element to, Element from) {

    if (to.getNodeName()!=from.getNodeName()) {
        System.err.println("cant merge two nodes with different names");
        return false;
    }

    // copy any atts over - ignore for now

    // copy the children
    if (!from.hasChildNodes()) {
        return true;
    }

    // check if they belong to the same document
    Document to_doc = to.getOwnerDocument();
    Document from_doc = from.getOwnerDocument();
    Element newfrom;
    if (to_doc != from_doc) {
        nfrom = to_doc.importNode(from, true);
    } else {
        newfrom = from;
    }
    
    if (!to.hasChildNodes()) {
        // just copy all the children over
        Node child = newfrom.getFirstChild();
        while (child !=null) {
        to.appendChild(child);
        child = child.getNextSibling();
        }
        return true;
    }
    
    // have to check each one to see if already present or not
    HashMap children = getChildrenMap(to);
    
    Node child = newfrom.getFirstChild();
    while (child !=null) {
        String name = child.getNodeName();
        Node n = map.get(name);
        if (n==null) { // there is no elem by that name in to
        to.appendChild(child);
        }
        else {
    }
    return true;
    }
    */
    /** returns the (first) child element with the given name */
    public static Node getChildByTagName(Node n, String name) {

    Node child = n.getFirstChild();
    while (child!=null) {
        if (child.getNodeName().equals(name)) {
        return child;
        }
        child = child.getNextSibling();
    }
    return null; //not found
    }

    /** takes an xpath type expression of the form name/name/... 
    and returns the first node that matches, or null if not found */
    public static Node getNodeByPath(Node n, String path) {
    
    String link = GSPath.getFirstLink(path);
    path = GSPath.removeFirstLink(path);
    while (!link.equals("")) {
        n = getChildByTagName(n, link);
        if (n==null) {
        return null;
        }
        link = GSPath.getFirstLink(path);
        path = GSPath.removeFirstLink(path);
    }
    return n;
    }
    public static HashMap getChildrenMap(Node n) {
    
    HashMap map= new HashMap();
    Node child = n.getFirstChild();
    while (child!=null) {
        String name = child.getNodeName();
        map.put(name, child);
        child = child.getNextSibling();
    }
    return map;
    }
       
    public static Element createTextElement(Document owner, String elem_name,
                        String text) {
    Element e = owner.createElement(elem_name);
    Text t = owner.createTextNode(text);
    e.appendChild(t);
    return e;

    }


    public static Element createParameter(Document owner, String param_name,
                      String type, String default_value,
                      String []values) {


    Element p = owner.createElement("param");
    p.setAttribute("name", param_name);
    p.setAttribute("type", type);
    p.setAttribute("default", default_value);
    
    if (type.equals(PARAM_TYPE_ENUM)) {
        for (int i=0; i<values.length; i++) {
        Element e = owner.createElement("element");
        e.setAttribute("name", values[i]);
        p.appendChild(e);
        }
    }
    return p;
    }

    /** returns the element parent/node_name[@attribute_name='attribute_value']
     */
    public static Element getNamedElement(Element parent, String node_name,
                      String attribute_name, 
                      String attribute_value) {

    NodeList children = parent.getChildNodes();
    for (int i=0; i<children.getLength(); i++) {
        Node child = children.item(i);
        if (child.getNodeName().equals(node_name)) {
        if (((Element)child).getAttribute(attribute_name).equals(attribute_value))
            return (Element)child;
        }
    }
    // not found
    return null;
    }
}