Changeset 24984

Show
Ignore:
Timestamp:
26.01.2012 11:22:27 (7 years ago)
Author:
sjm84
Message:

Reformatting this file ahead of some changes

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/util/GSXML.java

    r24609 r24984  
    11/* 
    2 *    GSXML.java 
    3 *    Copyright (C) 2008 New Zealand Digital Library, http://www.nzdl.org 
    4 * 
    5 *    This program is free software; you can redistribute it and/or modify 
    6 *    it under the terms of the GNU General Public License as published by 
    7 *    the Free Software Foundation; either version 2 of the License, or 
    8 *    (at your option) any later version. 
    9 * 
    10 *    This program is distributed in the hope that it will be useful, 
    11 *    but WITHOUT ANY WARRANTY; without even the implied warranty of 
    12 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    13 *    GNU General Public License for more details. 
    14 * 
    15 *    You should have received a copy of the GNU General Public License 
    16 *    along with this program; if not, write to the Free Software 
    17 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
    18 */ 
     2 *    GSXML.java 
     3 *    Copyright (C) 2008 New Zealand Digital Library, http://www.nzdl.org 
     4 * 
     5 *    This program is free software; you can redistribute it and/or modify 
     6 *    it under the terms of the GNU General Public License as published by 
     7 *    the Free Software Foundation; either version 2 of the License, or 
     8 *    (at your option) any later version. 
     9 * 
     10 *    This program is distributed in the hope that it will be useful, 
     11 *    but WITHOUT ANY WARRANTY; without even the implied warranty of 
     12 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     13 *    GNU General Public License for more details. 
     14 * 
     15 *    You should have received a copy of the GNU General Public License 
     16 *    along with this program; if not, write to the Free Software 
     17 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     18 */ 
    1919package org.greenstone.gsdl3.util; 
    2020 
     
    4444 
    4545/** various functions for extracting info out of GS XML */ 
    46 public class GSXML { 
     46public class GSXML 
     47{ 
    4748 
    4849    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.util.GSXML.class.getName()); 
     
    9394 
    9495    public static final String DBINFO_ELEM = "dbInfo"; 
    95     public static final String DBNAME_ATT = "dbname";   
     96    public static final String DBNAME_ATT = "dbname"; 
    9697    public static final String DBPATH_ATT = "dbpath"; 
    9798    public static final String SQLSTATE_ATT = "sqlstate"; 
     
    100101    public static final String NOTIFY_ELEM = "notify"; 
    101102    public static final String NOTIFY_HOST_ATT = "host"; 
    102      
     103 
    103104    //doc.xml file elems 
    104105    public static final String DOCXML_SECTION_ELEM = "Section"; 
     
    116117    //public final static String DESCRIPTION_ELEM = "description"; 
    117118 
    118     public static final String  ACTION_ELEM = "action"; 
    119     public static final String  SUBACTION_ELEM = "subaction"; 
     119    public static final String ACTION_ELEM = "action"; 
     120    public static final String SUBACTION_ELEM = "subaction"; 
    120121 
    121122    // add on to another elem type to get a list of that type 
     
    218219    public static final String SERVICE_TYPE_OAI = "oai"; 
    219220    public static final String FLAX_PAGE = "flaxPage"; 
    220     public static final String FLAX_PAGE_GENERATION = "FlaxPageGeneration";   
     221    public static final String FLAX_PAGE_GENERATION = "FlaxPageGeneration"; 
    221222 
    222223    // system command types and attributes 
     
    246247 
    247248    //for authentication 
    248     public static final String AUTHEN_NODE_ELEM="authenticationNode"; 
    249     public static final String USER_NODE_ELEM="userNode"; 
     249    public static final String AUTHEN_NODE_ELEM = "authenticationNode"; 
     250    public static final String USER_NODE_ELEM = "userNode"; 
    250251 
    251252    //for configure action results 
     
    253254    public static final String ERROR = "error"; 
    254255 
    255     /** takes a list of elements, and returns an array of strings 
    256 * of the values of attribute att_name */ 
    257     public static String [] getAttributeValuesFromList(Element list, 
    258     String att_name) { 
    259          
     256    /** 
     257     * takes a list of elements, and returns an array of strings of the values 
     258     * of attribute att_name 
     259     */ 
     260    public static String[] getAttributeValuesFromList(Element list, String att_name) 
     261    { 
     262 
    260263        NodeList children = list.getChildNodes(); 
    261          
     264 
    262265        int num_nodes = children.getLength(); 
    263         String []ids = new String[num_nodes]; 
    264         for (int i=0; i<num_nodes; i++) { 
    265             Element e = (Element)children.item(i); 
     266        String[] ids = new String[num_nodes]; 
     267        for (int i = 0; i < num_nodes; i++) 
     268        { 
     269            Element e = (Element) children.item(i); 
    266270            String id = e.getAttribute(att_name); 
    267271            ids[i] = id; 
    268272        } 
    269          
     273 
    270274        return ids; 
    271275    } 
    272276 
    273     public static HashMap extractParams(Element xml, boolean deep) { 
     277    public static HashMap extractParams(Element xml, boolean deep) 
     278    { 
    274279        return extractParams(xml, deep, null); 
    275280    } 
    276281 
    277     /** takes a paramList element, and gets a HashMap of name-value pairs 
    278 * if deep=true, extracts embedded params, otherwise just top level 
    279 * params*/ 
    280     public static HashMap extractParams(Element xml, boolean deep, String toFind) { 
    281          
    282         if (!xml.getNodeName().equals(PARAM_ELEM+LIST_MODIFIER)) { 
    283             logger.error("paramList element should have been passed to extractParams, instead it was "+xml.getNodeName()); 
     282    /** 
     283     * takes a paramList element, and gets a HashMap of name-value pairs if 
     284     * deep=true, extracts embedded params, otherwise just top level params 
     285     */ 
     286    public static HashMap extractParams(Element xml, boolean deep, String toFind) 
     287    { 
     288 
     289        if (!xml.getNodeName().equals(PARAM_ELEM + LIST_MODIFIER)) 
     290        { 
     291            logger.error("paramList element should have been passed to extractParams, instead it was " + xml.getNodeName()); 
    284292            return null; 
    285293        } 
    286          
     294 
    287295        NodeList params = null; 
    288         if (deep) { // get all the nested ones 
     296        if (deep) 
     297        { // get all the nested ones 
    289298            params = xml.getElementsByTagName(PARAM_ELEM); 
    290         } else { // just get the top  level ones 
     299        } 
     300        else 
     301        { // just get the top  level ones 
    291302            params = xml.getChildNodes(); 
    292303        } 
    293304        HashMap param_map = new HashMap(); 
    294         for (int i=0; i<params.getLength(); i++) { 
    295             if (params.item(i).getNodeName().equals(PARAM_ELEM)) { 
    296                 Element param = (Element)params.item(i); 
    297                 String name=param.getAttribute(NAME_ATT); 
    298                 String value=getValue(param); //att or content 
     305        for (int i = 0; i < params.getLength(); i++) 
     306        { 
     307            if (params.item(i).getNodeName().equals(PARAM_ELEM)) 
     308            { 
     309                Element param = (Element) params.item(i); 
     310                String name = param.getAttribute(NAME_ATT); 
     311                String value = getValue(param); //att or content 
    299312 
    300313                // For only one parameter 
    301                 if(toFind != null && name.equals(toFind)) { 
     314                if (toFind != null && name.equals(toFind)) 
     315                { 
    302316                    param_map.put(name, value); 
    303317                    return param_map; 
    304                 }        
    305                 else if(toFind != null) 
    306                 continue; 
     318                } 
     319                else if (toFind != null) 
     320                    continue; 
    307321 
    308322                int pos = name.indexOf('.'); 
    309                 if (pos == -1) { // a base param 
     323                if (pos == -1) 
     324                { // a base param 
    310325                    param_map.put(name, value); 
    311                 } else { // a namespaced param 
    312                      
     326                } 
     327                else 
     328                { // a namespaced param 
     329 
    313330                    String namespace = name.substring(0, pos); 
    314                     name = name.substring(pos+1); 
    315                     HashMap map = (HashMap)param_map.get(namespace); 
    316                     if (map == null) { 
     331                    name = name.substring(pos + 1); 
     332                    HashMap map = (HashMap) param_map.get(namespace); 
     333                    if (map == null) 
     334                    { 
    317335                        map = new HashMap(); 
    318336                        param_map.put(namespace, map); 
     
    326344 
    327345    /** gets the value att or the text content */ 
    328     public static String getValue(Element e) { 
     346    public static String getValue(Element e) 
     347    { 
    329348        String val = e.getAttribute(VALUE_ATT); 
    330         if (val ==null || val.equals("")) { 
     349        if (val == null || val.equals("")) 
     350        { 
    331351            // have to get it out of the text 
    332             val=getNodeText(e); 
    333              
    334         } else { 
     352            val = getNodeText(e); 
     353 
     354        } 
     355        else 
     356        { 
    335357            // unescape the xml stuff 
    336358            val = unXmlSafe(val); 
     
    340362 
    341363    /** extracts the text out of a node */ 
    342     public static Node getNodeTextNode(Element param) { 
     364    public static Node getNodeTextNode(Element param) 
     365    { 
    343366        param.normalize(); 
    344367        Node n = param.getFirstChild(); 
    345         while (n!=null && n.getNodeType() !=Node.TEXT_NODE) { 
    346             n=n.getNextSibling(); 
     368        while (n != null && n.getNodeType() != Node.TEXT_NODE) 
     369        { 
     370            n = n.getNextSibling(); 
    347371        } 
    348372        return n; 
     
    350374 
    351375    /** extracts the text out of a node */ 
    352     public static String getNodeText(Element param) { 
     376    public static String getNodeText(Element param) 
     377    { 
    353378        Node text_node = getNodeTextNode(param); 
    354         if (text_node == null) { 
     379        if (text_node == null) 
     380        { 
    355381            return ""; 
    356382        } 
     
    358384    } 
    359385 
    360     public static void setNodeText(Element elem, String text) { 
     386    public static void setNodeText(Element elem, String text) 
     387    { 
    361388        Node old_text_node = getNodeTextNode(elem); 
    362         if (old_text_node != null) { 
     389        if (old_text_node != null) 
     390        { 
    363391            elem.removeChild(old_text_node); 
    364392        } 
     
    367395    } 
    368396 
    369     /** add text to a document/subsection  element */ 
    370     public static boolean addDocText(Document owner, Element doc, String text) { 
    371          
     397    /** add text to a document/subsection element */ 
     398    public static boolean addDocText(Document owner, Element doc, String text) 
     399    { 
     400 
    372401        Element content = owner.createElement(NODE_CONTENT_ELEM); 
    373402        Text t = owner.createTextNode(text); 
     
    378407 
    379408    /** add an error message, unknown error type */ 
    380     public static boolean addError(Document owner, Element doc, String text) { 
     409    public static boolean addError(Document owner, Element doc, String text) 
     410    { 
    381411        return addError(owner, doc, text, ERROR_TYPE_OTHER); 
    382412    } 
     413 
    383414    /** add an error message */ 
    384     public static boolean addError(Document owner, Element doc, String text, 
    385     String error_type) { 
    386          
     415    public static boolean addError(Document owner, Element doc, String text, String error_type) 
     416    { 
     417 
    387418        Element content = owner.createElement(ERROR_ELEM); 
    388419        content.setAttribute(ERROR_TYPE_ATT, error_type); 
     
    394425 
    395426    /** add an error message */ 
    396     public static boolean addError(Document owner, Element doc, Throwable error) { 
     427    public static boolean addError(Document owner, Element doc, Throwable error) 
     428    { 
    397429        return addError(owner, doc, error, ERROR_TYPE_OTHER); 
    398430    } 
    399431 
    400432    /** add an error message */ 
    401     public static boolean addError(Document owner, Element doc, 
    402     Throwable error, String error_type) { 
     433    public static boolean addError(Document owner, Element doc, Throwable error, String error_type) 
     434    { 
    403435        error.printStackTrace(); 
    404436        return addError(owner, doc, error.toString(), error_type); 
    405437    } 
    406438 
    407     public static Element createMetadataParamList(Document owner, Vector meta_values) { 
    408          
    409         Element meta_param_list = owner.createElement(PARAM_ELEM+LIST_MODIFIER); 
     439    public static Element createMetadataParamList(Document owner, Vector meta_values) 
     440    { 
     441 
     442        Element meta_param_list = owner.createElement(PARAM_ELEM + LIST_MODIFIER); 
    410443        Iterator i = meta_values.iterator(); 
    411         while(i.hasNext()) { 
    412             String next = (String)i.next(); 
     444        while (i.hasNext()) 
     445        { 
     446            String next = (String) i.next(); 
    413447            Element meta_param = owner.createElement(PARAM_ELEM); 
    414448            meta_param_list.appendChild(meta_param); 
     
    420454 
    421455    /** adds a metadata elem to a list */ 
    422     public static boolean addMetadata(Document owner, Element list, 
    423     String meta_name, String meta_value) { 
    424         if (meta_value==null || meta_value.equals("")) { 
     456    public static boolean addMetadata(Document owner, Element list, String meta_name, String meta_value) 
     457    { 
     458        if (meta_value == null || meta_value.equals("")) 
     459        { 
    425460            return false; 
    426461        } 
     
    431466        list.appendChild(data); 
    432467        return true; 
    433          
    434     } 
    435  
    436     /** copies the metadata out of the metadataList of 'from' into 
    437 * the metadataList of 'to' */ 
    438     public static boolean mergeMetadataLists(Node to, Node from) { 
    439         Node from_meta = getChildByTagName(from, METADATA_ELEM+LIST_MODIFIER); 
    440         if  (from_meta == null) { // nothing to copy 
     468 
     469    } 
     470 
     471    /** 
     472     * copies the metadata out of the metadataList of 'from' into the 
     473     * metadataList of 'to' 
     474     */ 
     475    public static boolean mergeMetadataLists(Node to, Node from) 
     476    { 
     477        Node from_meta = getChildByTagName(from, METADATA_ELEM + LIST_MODIFIER); 
     478        if (from_meta == null) 
     479        { // nothing to copy 
    441480            return true; 
    442481        } 
     
    444483    } 
    445484 
    446  
    447     /** copies the metadata out of the meta_list metadataList  into 
    448 * the metadataList of 'to' */ 
    449     public static boolean mergeMetadataFromList(Node to, Node meta_list) { 
    450         if (meta_list == null) return false; 
    451         Node to_meta = getChildByTagName(to, METADATA_ELEM+LIST_MODIFIER); 
     485    /** 
     486     * copies the metadata out of the meta_list metadataList into the 
     487     * metadataList of 'to' 
     488     */ 
     489    public static boolean mergeMetadataFromList(Node to, Node meta_list) 
     490    { 
     491        if (meta_list == null) 
     492            return false; 
     493        Node to_meta = getChildByTagName(to, METADATA_ELEM + LIST_MODIFIER); 
    452494        Document to_owner = to.getOwnerDocument(); 
    453         if (to_meta == null) { 
     495        if (to_meta == null) 
     496        { 
    454497            to.appendChild(to_owner.importNode(meta_list, true)); 
    455498            return true; 
    456499        } 
    457500        // copy individual metadata elements 
    458         NodeList meta_items = ((Element)meta_list).getElementsByTagName(METADATA_ELEM); 
    459         for (int i=0; i<meta_items.getLength(); i++) { 
    460             to_meta.appendChild(to_owner.importNode(meta_items.item(i),true)); 
     501        NodeList meta_items = ((Element) meta_list).getElementsByTagName(METADATA_ELEM); 
     502        for (int i = 0; i < meta_items.getLength(); i++) 
     503        { 
     504            to_meta.appendChild(to_owner.importNode(meta_items.item(i), true)); 
    461505        } 
    462506        return true; 
     
    464508 
    465509    /** copies all the children from from to to */ 
    466     public static boolean mergeElements(Element to, Element from) { 
    467          
     510    public static boolean mergeElements(Element to, Element from) 
     511    { 
     512 
    468513        Document owner = to.getOwnerDocument(); 
    469514        Node child = from.getFirstChild(); 
    470         while (child != null) { 
     515        while (child != null) 
     516        { 
    471517            to.appendChild(owner.importNode(child, true)); 
    472518            child = child.getNextSibling(); 
     
    474520        return true; 
    475521    } 
     522 
    476523    /** returns the (first) element child of the node n */ 
    477     public static Element getFirstElementChild(Node n) { 
    478          
     524    public static Element getFirstElementChild(Node n) 
     525    { 
     526 
    479527        Node child = n.getFirstChild(); 
    480         while (child!=null) { 
    481             if (child.getNodeType() == Node.ELEMENT_NODE) { 
    482                 return (Element)child; 
     528        while (child != null) 
     529        { 
     530            if (child.getNodeType() == Node.ELEMENT_NODE) 
     531            { 
     532                return (Element) child; 
    483533            } 
    484534            child = child.getNextSibling(); 
     
    486536        return null; //no element child found 
    487537    } 
     538 
    488539    /** returns the (first) child element with the given name */ 
    489     public static Node getChildByTagName(Node n, String name) { 
    490         if(n != null) { // this line is an attempted solution to the NullPointerException mentioned  
     540    public static Node getChildByTagName(Node n, String name) 
     541    { 
     542        if (n != null) 
     543        { // this line is an attempted solution to the NullPointerException mentioned  
    491544            // in trac bug ticket #225. If n is null can't do n.getFirstChild() below. As per bug #225:  
    492545            // GSXML.getNodeByPath() is called by GS2BrowseAction, which then calls this method. 
     
    495548 
    496549            Node child = n.getFirstChild(); 
    497             while (child!=null) { 
    498                 if (child.getNodeName().equals(name)) { 
     550            while (child != null) 
     551            { 
     552                if (child.getNodeName().equals(name)) 
     553                { 
    499554                    return child; 
    500555                } 
     
    505560    } 
    506561 
    507     /** returns the (nth) child element with the given name 
    508 * index numbers start at 0 */ 
    509     public static Node getChildByTagNameIndexed(Node n, String name, int index) { 
    510         if (index == -1) { 
     562    /** 
     563     * returns the (nth) child element with the given name index numbers start 
     564     * at 0 
     565     */ 
     566    public static Node getChildByTagNameIndexed(Node n, String name, int index) 
     567    { 
     568        if (index == -1) 
     569        { 
    511570            return getChildByTagName(n, name); 
    512571        } 
    513572        int count = 0; 
    514573        Node child = n.getFirstChild(); 
    515         while (child!=null) { 
    516             if (child.getNodeName().equals(name)) { 
    517                 if (count == index) { 
     574        while (child != null) 
     575        { 
     576            if (child.getNodeName().equals(name)) 
     577            { 
     578                if (count == index) 
     579                { 
    518580                    return child; 
    519                 } else { 
     581                } 
     582                else 
     583                { 
    520584                    count++; 
    521585                } 
     
    526590    } 
    527591 
    528     /** takes an xpath type expression of the form name/name/... 
    529 * and returns the first node that matches, or null if not found */ 
    530     public static Node getNodeByPath(Node n, String path) { 
    531          
     592    /** 
     593     * takes an xpath type expression of the form name/name/... and returns the 
     594     * first node that matches, or null if not found 
     595     */ 
     596    public static Node getNodeByPath(Node n, String path) 
     597    { 
     598 
    532599        String link = GSPath.getFirstLink(path); 
    533600        path = GSPath.removeFirstLink(path); 
    534         while (!link.equals("")) { 
     601        while (!link.equals("")) 
     602        { 
    535603            n = getChildByTagName(n, link); 
    536             if (n==null) { 
     604            if (n == null) 
     605            { 
    537606                return null; 
    538607            } 
     
    543612    } 
    544613 
    545     /** takes an xpath type expression of the form name/name/... 
    546 * and returns the first node that matches, or null if not found 
    547 * can include [i] indices. index numbers start at 0 */ 
    548     public static Node getNodeByPathIndexed(Node n, String path) { 
    549          
     614    /** 
     615     * takes an xpath type expression of the form name/name/... and returns the 
     616     * first node that matches, or null if not found can include [i] indices. 
     617     * index numbers start at 0 
     618     */ 
     619    public static Node getNodeByPathIndexed(Node n, String path) 
     620    { 
     621 
    550622        String link = GSPath.getFirstLink(path); 
    551623        int index = GSPath.getIndex(link); 
    552         if (index != -1) { 
     624        if (index != -1) 
     625        { 
    553626            link = GSPath.removeIndex(link); 
    554627        } 
    555628        path = GSPath.removeFirstLink(path); 
    556         while (!link.equals("")) { 
     629        while (!link.equals("")) 
     630        { 
    557631            n = getChildByTagNameIndexed(n, link, index); 
    558             if (n==null) { 
     632            if (n == null) 
     633            { 
    559634                return null; 
    560635            } 
    561636            link = GSPath.getFirstLink(path); 
    562637            index = GSPath.getIndex(link); 
    563             if (index != -1) { 
     638            if (index != -1) 
     639            { 
    564640                link = GSPath.removeIndex(link); 
    565641            } 
     
    569645    } 
    570646 
    571     public static HashMap getChildrenMap(Node n) { 
    572          
    573         HashMap map= new HashMap(); 
     647    public static HashMap getChildrenMap(Node n) 
     648    { 
     649 
     650        HashMap map = new HashMap(); 
    574651        Node child = n.getFirstChild(); 
    575         while (child!=null) { 
     652        while (child != null) 
     653        { 
    576654            String name = child.getNodeName(); 
    577655            map.put(name, child); 
     
    581659    } 
    582660 
    583     public static NodeList getChildrenByTagName(Node n, String name) { 
     661    public static NodeList getChildrenByTagName(Node n, String name) 
     662    { 
    584663        MyNodeList node_list = new MyNodeList(); 
    585664        Node child = n.getFirstChild(); 
    586         while (child!=null) { 
    587             if (child.getNodeName().equals(name)) { 
     665        while (child != null) 
     666        { 
     667            if (child.getNodeName().equals(name)) 
     668            { 
    588669                node_list.addNode(child); 
    589670            } 
     
    593674    } 
    594675 
    595  
    596676    /** Duplicates an element, but gives it a new name */ 
    597     public static Element duplicateWithNewName(Document owner, Element element, 
    598     String element_name, boolean with_attributes) { 
     677    public static Element duplicateWithNewName(Document owner, Element element, String element_name, boolean with_attributes) 
     678    { 
    599679        return duplicateWithNewNameNS(owner, element, element_name, null, with_attributes); 
    600680    } 
    601681 
    602682    /** Duplicates an element, but gives it a new name */ 
    603     public static Element duplicateWithNewNameNS(Document owner, 
    604     Element element, 
    605     String element_name, 
    606     String namespace_uri, 
    607     boolean with_attributes) { 
     683    public static Element duplicateWithNewNameNS(Document owner, Element element, String element_name, String namespace_uri, boolean with_attributes) 
     684    { 
    608685        Element duplicate; 
    609         if (namespace_uri == null) { 
     686        if (namespace_uri == null) 
     687        { 
    610688            duplicate = owner.createElement(element_name); 
    611         } else { 
     689        } 
     690        else 
     691        { 
    612692            duplicate = owner.createElementNS(namespace_uri, element_name); 
    613693        } 
    614694        // Copy element attributes 
    615         if (with_attributes) { 
     695        if (with_attributes) 
     696        { 
    616697            NamedNodeMap attributes = element.getAttributes(); 
    617             for (int i = 0; i < attributes.getLength(); i++) { 
     698            for (int i = 0; i < attributes.getLength(); i++) 
     699            { 
    618700                Node attribute = attributes.item(i); 
    619701                duplicate.setAttribute(attribute.getNodeName(), attribute.getNodeValue()); 
    620702            } 
    621703        } 
    622          
     704 
    623705        // Copy element children 
    624706        NodeList children = element.getChildNodes(); 
    625         for (int i = 0; i < children.getLength(); i++) { 
     707        for (int i = 0; i < children.getLength(); i++) 
     708        { 
    626709            Node child = children.item(i); 
    627710            duplicate.appendChild(owner.importNode(child, true)); 
    628711        } 
    629          
     712 
    630713        return duplicate; 
    631714    } 
    632715 
    633     public static void copyAllChildren(Element to, Element from) { 
    634          
     716    public static void copyAllChildren(Element to, Element from) 
     717    { 
     718 
    635719        Document to_doc = to.getOwnerDocument(); 
    636720        Node child = from.getFirstChild(); 
    637         while (child != null) { 
     721        while (child != null) 
     722        { 
    638723            to.appendChild(to_doc.importNode(child, true)); 
    639724            child = child.getNextSibling(); 
    640725        } 
    641726    } 
     727 
    642728    /** returns a basic request message */ 
    643     public static  Element createBasicRequest(Document owner, 
    644     String request_type, String to, 
    645     String lang, 
    646     String uid) { 
     729    public static Element createBasicRequest(Document owner, String request_type, String to, String lang, String uid) 
     730    { 
    647731        Element request = owner.createElement(REQUEST_ELEM); 
    648732        request.setAttribute(TYPE_ATT, request_type); 
     
    652736        return request; 
    653737    } 
    654      
     738 
    655739    public static Element createBasicResponse(Document owner, String from) 
    656740    { 
     
    660744        return response; 
    661745    } 
    662      
     746 
    663747    public static Element createMetadataElement(Document owner, String name, String value) 
    664748    { 
     
    669753    } 
    670754 
    671     public static Element createTextElement(Document owner, String elem_name, 
    672     String text) { 
     755    public static Element createTextElement(Document owner, String elem_name, String text) 
     756    { 
    673757        Element e = owner.createElement(elem_name); 
    674758        Text t = owner.createTextNode(text); 
    675759        e.appendChild(t); 
    676760        return e; 
    677          
    678     } 
    679  
    680     public static Element createTextElement(Document owner, String elem_name, 
    681     String text, String att_name, String att_value) { 
     761 
     762    } 
     763 
     764    public static Element createTextElement(Document owner, String elem_name, String text, String att_name, String att_value) 
     765    { 
    682766        Element e = owner.createElement(elem_name); 
    683767        e.setAttribute(att_name, att_value); 
     
    685769        e.appendChild(t); 
    686770        return e; 
    687          
    688     } 
    689      
    690     public static Element createDisplayTextElement(Document owner, 
    691     String text_name, 
    692     String text) { 
     771 
     772    } 
     773 
     774    public static Element createDisplayTextElement(Document owner, String text_name, String text) 
     775    { 
    693776        Element e = owner.createElement(DISPLAY_TEXT_ELEM); 
    694777        e.setAttribute(NAME_ATT, text_name); 
     
    696779        e.appendChild(t); 
    697780        return e; 
    698          
    699     } 
    700  
    701  
    702     public static Element createParameter(Document owner, String name, 
    703     String value) { 
     781 
     782    } 
     783 
     784    public static Element createParameter(Document owner, String name, String value) 
     785    { 
    704786        Element param = owner.createElement(PARAM_ELEM); 
    705787        param.setAttribute(NAME_ATT, name); 
     
    708790    } 
    709791 
    710     public static void addParametersToList(Document owner, Element param_list, 
    711     HashMap params) { 
     792    public static void addParametersToList(Document owner, Element param_list, HashMap params) 
     793    { 
    712794        if (params == null) 
    713795        { 
    714796            return; 
    715797        } 
    716          
     798 
    717799        Set items = params.entrySet(); 
    718800        Iterator i = items.iterator(); 
    719         while(i.hasNext()) { 
    720             Map.Entry m = (Map.Entry)i.next(); 
    721             param_list.appendChild(createParameter(owner, (String)m.getKey(), (String)m.getValue())); 
    722         } 
    723          
    724     } 
    725  
    726     public static Element createParameterDescription(Document owner, 
    727     String id, 
    728     String display_name, 
    729     String type, 
    730     String default_value, 
    731     String []option_ids, 
    732     String []option_names) { 
    733          
    734          
     801        while (i.hasNext()) 
     802        { 
     803            Map.Entry m = (Map.Entry) i.next(); 
     804            param_list.appendChild(createParameter(owner, (String) m.getKey(), (String) m.getValue())); 
     805        } 
     806 
     807    } 
     808 
     809    public static Element createParameterDescription(Document owner, String id, String display_name, String type, String default_value, String[] option_ids, String[] option_names) 
     810    { 
     811 
    735812        Element p = owner.createElement(PARAM_ELEM); 
    736813        p.setAttribute(NAME_ATT, id); 
    737814        p.setAttribute(TYPE_ATT, type); 
    738815        p.appendChild(createDisplayTextElement(owner, GSXML.DISPLAY_TEXT_NAME, display_name)); 
    739          
    740         if (default_value != null) { 
     816 
     817        if (default_value != null) 
     818        { 
    741819            p.setAttribute(DEFAULT_ATT, default_value); 
    742820        } 
    743         if (option_ids!=null && option_names!=null) { 
    744             for (int i=0; i<option_ids.length; i++) { 
     821        if (option_ids != null && option_names != null) 
     822        { 
     823            for (int i = 0; i < option_ids.length; i++) 
     824            { 
    745825                Element e = owner.createElement(PARAM_OPTION_ELEM); 
    746826                e.setAttribute(NAME_ATT, option_ids[i]); 
     
    751831        return p; 
    752832    } 
    753     public static Element createParameterDescription2(Document owner, 
    754     String id, 
    755     String display_name, 
    756     String type, 
    757     String default_value, 
    758     ArrayList option_ids, 
    759     ArrayList option_names) { 
    760          
    761          
     833 
     834    public static Element createParameterDescription2(Document owner, String id, String display_name, String type, String default_value, ArrayList option_ids, ArrayList option_names) 
     835    { 
     836 
    762837        Element p = owner.createElement(PARAM_ELEM); 
    763838        p.setAttribute(NAME_ATT, id); 
    764839        p.setAttribute(TYPE_ATT, type); 
    765840        p.appendChild(createDisplayTextElement(owner, GSXML.DISPLAY_TEXT_NAME, display_name)); 
    766         if (default_value != null) { 
     841        if (default_value != null) 
     842        { 
    767843            p.setAttribute(DEFAULT_ATT, default_value); 
    768844        } 
    769         if (option_ids!=null && option_names!=null) { 
    770             for (int i=0; i<option_ids.size(); i++) { 
     845        if (option_ids != null && option_names != null) 
     846        { 
     847            for (int i = 0; i < option_ids.size(); i++) 
     848            { 
    771849                Element e = owner.createElement(PARAM_OPTION_ELEM); 
    772                 e.setAttribute(NAME_ATT, (String)option_ids.get(i)); 
    773                 e.appendChild(createDisplayTextElement(owner, GSXML.DISPLAY_TEXT_NAME, (String)option_names.get(i))); 
     850                e.setAttribute(NAME_ATT, (String) option_ids.get(i)); 
     851                e.appendChild(createDisplayTextElement(owner, GSXML.DISPLAY_TEXT_NAME, (String) option_names.get(i))); 
    774852                p.appendChild(e); 
    775853            } 
     
    778856    } 
    779857 
    780  
    781     /** returns the element parent/node_name[@attribute_name='attribute_value'] 
    782 */ 
    783     public static Element getNamedElement(Element parent, String node_name, 
    784     String attribute_name, 
    785     String attribute_value) { 
    786          
     858    /** returns the element parent/node_name[@attribute_name='attribute_value'] */ 
     859    public static Element getNamedElement(Element parent, String node_name, String attribute_name, String attribute_value) 
     860    { 
     861 
    787862        NodeList children = parent.getChildNodes(); 
    788         for (int i=0; i<children.getLength(); i++) { 
     863        for (int i = 0; i < children.getLength(); i++) 
     864        { 
    789865            Node child = children.item(i); 
    790             if (child.getNodeName().equals(node_name)) { 
    791                 if (((Element)child).getAttribute(attribute_name).equals(attribute_value)) 
    792                 return (Element)child; 
     866            if (child.getNodeName().equals(node_name)) 
     867            { 
     868                if (((Element) child).getAttribute(attribute_name).equals(attribute_value)) 
     869                    return (Element) child; 
    793870            } 
    794871        } 
     
    796873        return null; 
    797874    } 
    798     /** returns a NodeList of elements: ancestor/node_name[@attribute_name='attribute_value'] 
    799 */ 
    800     public static NodeList getNamedElements(Element ancestor, String node_name, String attribute_name, String attribute_value) { 
     875 
     876    /** 
     877     * returns a NodeList of elements: 
     878     * ancestor/node_name[@attribute_name='attribute_value'] 
     879     */ 
     880    public static NodeList getNamedElements(Element ancestor, String node_name, String attribute_name, String attribute_value) 
     881    { 
    801882        MyNodeList node_list = new MyNodeList(); 
    802883        NodeList children = ancestor.getElementsByTagName(node_name); 
    803          
    804         if(children != null && children.getLength() > 0) { 
    805              
    806             for (int i=0; i<children.getLength(); i++) { 
     884 
     885        if (children != null && children.getLength() > 0) 
     886        { 
     887 
     888            for (int i = 0; i < children.getLength(); i++) 
     889            { 
    807890                Node child = children.item(i); 
    808                 if (child.getNodeName().equals(node_name)) { 
    809                     if (((Element)child).getAttribute(attribute_name).equals(attribute_value)) 
    810                     node_list.addNode(child); 
    811                 }            
    812             }            
     891                if (child.getNodeName().equals(node_name)) 
     892                { 
     893                    if (((Element) child).getAttribute(attribute_name).equals(attribute_value)) 
     894                        node_list.addNode(child); 
     895                } 
     896            } 
    813897        } 
    814898        return node_list; 
     
    820904 
    821905    // sort type: 
    822     public static Element insertIntoOrderedList(Element parent_node, 
    823     String node_name, 
    824     Element start_from_elem, 
    825     Element new_elem, String sort_att, 
    826     boolean descending) { 
    827         if (new_elem == null) return null; 
    828         Element cloned_elem = (Element)parent_node.getOwnerDocument().importNode(new_elem, true); 
    829         if (start_from_elem == null) { 
     906    public static Element insertIntoOrderedList(Element parent_node, String node_name, Element start_from_elem, Element new_elem, String sort_att, boolean descending) 
     907    { 
     908        if (new_elem == null) 
     909            return null; 
     910        Element cloned_elem = (Element) parent_node.getOwnerDocument().importNode(new_elem, true); 
     911        if (start_from_elem == null) 
     912        { 
    830913            parent_node.appendChild(cloned_elem); 
    831914            return cloned_elem; 
    832915        } 
    833          
     916 
    834917        Node current_node = start_from_elem; 
    835918        String insert_att = cloned_elem.getAttribute(sort_att); 
    836919        String list_att = start_from_elem.getAttribute(sort_att); 
    837         while ((!descending && list_att.compareTo(insert_att)<0) || (descending && list_att.compareTo(insert_att)>0)) { 
     920        while ((!descending && list_att.compareTo(insert_att) < 0) || (descending && list_att.compareTo(insert_att) > 0)) 
     921        { 
    838922            current_node = current_node.getNextSibling(); 
    839             if (current_node == null) break; // end of the list 
    840             if (!current_node.getNodeName().equals(node_name)) { 
     923            if (current_node == null) 
     924                break; // end of the list 
     925            if (!current_node.getNodeName().equals(node_name)) 
     926            { 
    841927                continue; // not a valid node 
    842928            } 
    843             list_att = ((Element)current_node).getAttribute(sort_att); 
    844         } 
    845          
     929            list_att = ((Element) current_node).getAttribute(sort_att); 
     930        } 
     931 
    846932        parent_node.insertBefore(cloned_elem, current_node); 
    847933        return cloned_elem; 
    848934    } 
    849935 
    850  
    851     /** Returns the appropriate language element from a display elem, 
    852 * display is the containing element, name is the name of the element to 
    853 * look for, lang is the preferred language, lang_default is the fall back 
    854 * lang if neither lang is found, will return the first one it finds*/ 
    855     public static String getDisplayText(Element display, String name, 
    856     String lang, String lang_default) { 
    857          
     936    /** 
     937     * Returns the appropriate language element from a display elem, display is 
     938     * the containing element, name is the name of the element to look for, lang 
     939     * is the preferred language, lang_default is the fall back lang if neither 
     940     * lang is found, will return the first one it finds 
     941     */ 
     942    public static String getDisplayText(Element display, String name, String lang, String lang_default) 
     943    { 
     944 
    858945        String def = null; 
    859946        String first = null; 
    860947        NodeList elems = display.getElementsByTagName(DISPLAY_TEXT_ELEM); 
    861         if (elems.getLength() == 0) return ""; 
    862         for (int i=0; i<elems.getLength(); i++) { 
    863             Element e = (Element)elems.item(i); 
     948        if (elems.getLength() == 0) 
     949            return ""; 
     950        for (int i = 0; i < elems.getLength(); i++) 
     951        { 
     952            Element e = (Element) elems.item(i); 
    864953            String n = e.getAttribute(NAME_ATT); 
    865             if (name.equals(n)) { 
     954            if (name.equals(n)) 
     955            { 
    866956                String l = e.getAttribute(LANG_ATT); 
    867                 if (lang.equals(l)) { 
     957                if (lang.equals(l)) 
     958                { 
    868959                    return getNodeText(e); 
    869                 } else if (lang_default.equals(l)) { 
     960                } 
     961                else if (lang_default.equals(l)) 
     962                { 
    870963                    def = getNodeText(e); 
    871                 } else if (first == null) { 
     964                } 
     965                else if (first == null) 
     966                { 
    872967                    first = getNodeText(e); 
    873968                } 
    874             } else { 
     969            } 
     970            else 
     971            { 
    875972                continue; 
    876973            } 
    877974        } 
    878          
    879         if (def != null) { 
     975 
     976        if (def != null) 
     977        { 
    880978            return def; 
    881979        } 
    882         if (first != null) { 
     980        if (first != null) 
     981        { 
    883982            return first; 
    884983        } 
     
    887986 
    888987    // replaces < > " ' & in the original with their entities 
    889     public static String xmlSafe(String original) { 
    890          
     988    public static String xmlSafe(String original) 
     989    { 
     990 
    891991        StringBuffer filtered = new StringBuffer(original.length()); 
    892992        char c; 
    893         for (int i=0; i<original.length(); i++) { 
     993        for (int i = 0; i < original.length(); i++) 
     994        { 
    894995            c = original.charAt(i); 
    895             if (c == '>') { 
     996            if (c == '>') 
     997            { 
    896998                filtered.append("&gt;"); 
    897             } else if (c == '<') { 
     999            } 
     1000            else if (c == '<') 
     1001            { 
    8981002                filtered.append("&lt;"); 
    899             } else if (c == '"') { 
     1003            } 
     1004            else if (c == '"') 
     1005            { 
    9001006                filtered.append("&quot;"); 
    901             } else if (c == '&') { 
     1007            } 
     1008            else if (c == '&') 
     1009            { 
    9021010                filtered.append("&amp;"); 
    903             } else if (c == '\'') { 
     1011            } 
     1012            else if (c == '\'') 
     1013            { 
    9041014                filtered.append("&apos;"); 
    905             } else { 
     1015            } 
     1016            else 
     1017            { 
    9061018                filtered.append(c); 
    9071019            } 
     
    9101022    } 
    9111023 
    912  
    9131024    // replaces < > " ' & entities with their originals 
    914     public static String unXmlSafe(String original) { 
    915          
     1025    public static String unXmlSafe(String original) 
     1026    { 
     1027 
    9161028        StringBuffer filtered = new StringBuffer(original.length()); 
    9171029        char c; 
    918         for (int i=0; i<original.length(); i++) { 
     1030        for (int i = 0; i < original.length(); i++) 
     1031        { 
    9191032            c = original.charAt(i); 
    920             if (c == '&') { 
     1033            if (c == '&') 
     1034            { 
    9211035                int pos = original.indexOf(";", i); 
    922                 String entity = original.substring(i+1, pos); 
    923                 if (entity.equals("gt")) { 
     1036                String entity = original.substring(i + 1, pos); 
     1037                if (entity.equals("gt")) 
     1038                { 
    9241039                    filtered.append(">"); 
    925                 } else if (entity.equals("lt")) { 
     1040                } 
     1041                else if (entity.equals("lt")) 
     1042                { 
    9261043                    filtered.append("<"); 
    927                 } else if (entity.equals("apos")) { 
     1044                } 
     1045                else if (entity.equals("apos")) 
     1046                { 
    9281047                    filtered.append("'"); 
    929                 } else if (entity.equals("amp")) { 
     1048                } 
     1049                else if (entity.equals("amp")) 
     1050                { 
    9301051                    filtered.append("&"); 
    931                 } else if (entity.equals("quot")) { 
     1052                } 
     1053                else if (entity.equals("quot")) 
     1054                { 
    9321055                    filtered.append("\""); 
    933                 } else { 
    934                     filtered.append("&"+entity+";"); 
     1056                } 
     1057                else 
     1058                { 
     1059                    filtered.append("&" + entity + ";"); 
    9351060                } 
    9361061                i = pos; 
    937             } else { 
     1062            } 
     1063            else 
     1064            { 
    9381065                filtered.append(c); 
    9391066            } 
     
    9421069    } 
    9431070 
    944     public static void printXMLNode(Node e, boolean printText) { 
    945         printXMLNode(e, 0, printText) ; 
    946     } 
    947  
    948     public static String xmlNodeToString(Node e){ 
     1071    public static void printXMLNode(Node e, boolean printText) 
     1072    { 
     1073        printXMLNode(e, 0, printText); 
     1074    } 
     1075 
     1076    public static String xmlNodeToString(Node e) 
     1077    { 
    9491078        StringBuffer sb = new StringBuffer(""); 
    950         xmlNodeToString(sb,e,0,true); 
     1079        xmlNodeToString(sb, e, 0, true); 
    9511080        return sb.toString(); 
    9521081    } 
    9531082 
    954     public static String xmlNodeToString(Node e, boolean printText){ 
     1083    public static String xmlNodeToString(Node e, boolean printText) 
     1084    { 
    9551085        StringBuffer sb = new StringBuffer(""); 
    956         xmlNodeToString(sb,e,0,printText); 
     1086        xmlNodeToString(sb, e, 0, printText); 
    9571087        return sb.toString(); 
    9581088    } 
    9591089 
    960     private static void xmlNodeToString(StringBuffer sb, Node e, int depth, boolean printText){ 
    961          
    962         for (int i=0 ; i<depth ; i++) 
    963         sb.append(' ') ; 
    964          
    965         if (e.getNodeType() == Node.TEXT_NODE){ 
    966             if(printText) 
     1090    private static void xmlNodeToString(StringBuffer sb, Node e, int depth, boolean printText) 
     1091    { 
     1092 
     1093        for (int i = 0; i < depth; i++) 
     1094            sb.append(' '); 
     1095 
     1096        if (e.getNodeType() == Node.TEXT_NODE) 
     1097        { 
     1098            if (printText) 
    9671099            { 
    9681100                sb.append(e.getNodeValue()); 
     
    9721104                sb.append("text"); 
    9731105            } 
    974             return ; 
    975         } 
    976          
     1106            return; 
     1107        } 
     1108 
    9771109        sb.append('<'); 
    9781110        sb.append(e.getNodeName()); 
    9791111        NamedNodeMap attrs = e.getAttributes(); 
    980         if(attrs != null) 
    981         { 
    982             for (int i = 0; i < attrs.getLength(); i++) { 
     1112        if (attrs != null) 
     1113        { 
     1114            for (int i = 0; i < attrs.getLength(); i++) 
     1115            { 
    9831116                Node attr = attrs.item(i); 
    9841117                sb.append(' '); 
     
    9891122            } 
    9901123        } 
    991          
     1124 
    9921125        NodeList children = e.getChildNodes(); 
    993          
     1126 
    9941127        if (children == null || children.getLength() == 0) 
    995         sb.append("/>\n") ; 
    996         else { 
    997              
    998             sb.append(">\n") ; 
    999              
     1128            sb.append("/>\n"); 
     1129        else 
     1130        { 
     1131 
     1132            sb.append(">\n"); 
     1133 
    10001134            int len = children.getLength(); 
    1001             for (int i = 0; i < len; i++) { 
    1002                 xmlNodeToString(sb,children.item(i), depth + 1, printText); 
    1003             } 
    1004              
    1005             for (int i=0 ; i<depth ; i++) 
    1006             sb.append(' ') ; 
    1007              
     1135            for (int i = 0; i < len; i++) 
     1136            { 
     1137                xmlNodeToString(sb, children.item(i), depth + 1, printText); 
     1138            } 
     1139 
     1140            for (int i = 0; i < depth; i++) 
     1141                sb.append(' '); 
     1142 
    10081143            sb.append("</" + e.getNodeName() + ">\n"); 
    10091144        } 
    1010          
    1011          
    1012     } 
    1013  
    1014     public static void printXMLNode(Node e, int depth, boolean printText) { //recursive method call using DOM API... 
    1015          
    1016         if(e == null){return;} 
    1017          
    1018         for (int i=0 ; i<depth ; i++) 
    1019         System.out.print(' ') ; 
    1020          
    1021         if (e.getNodeType() == Node.TEXT_NODE){ 
    1022             if(printText){ 
     1145 
     1146    } 
     1147 
     1148    public static void printXMLNode(Node e, int depth, boolean printText) 
     1149    { //recursive method call using DOM API... 
     1150 
     1151        if (e == null) 
     1152        { 
     1153            return; 
     1154        } 
     1155 
     1156        for (int i = 0; i < depth; i++) 
     1157            System.out.print(' '); 
     1158 
     1159        if (e.getNodeType() == Node.TEXT_NODE) 
     1160        { 
     1161            if (printText) 
     1162            { 
    10231163                System.out.println(e.getNodeValue()); 
    10241164            } 
    1025             else { 
     1165            else 
     1166            { 
    10261167                System.out.println("text"); 
    10271168            } 
    1028             return ; 
    1029         } 
    1030          
     1169            return; 
     1170        } 
     1171 
    10311172        System.out.print('<'); 
    10321173        System.out.print(e.getNodeName()); 
    10331174        NamedNodeMap attrs = e.getAttributes(); 
    1034          
     1175 
    10351176        if (attrs != null) 
    10361177        { 
    1037             for (int i = 0; i < attrs.getLength(); i++) { 
     1178            for (int i = 0; i < attrs.getLength(); i++) 
     1179            { 
    10381180                Node attr = attrs.item(i); 
    10391181                System.out.print(' '); 
     
    10441186            } 
    10451187        } 
    1046          
     1188 
    10471189        NodeList children = e.getChildNodes(); 
    1048          
     1190 
    10491191        if (children == null || children.getLength() == 0) 
    1050         System.out.println("/>") ; 
    1051         else { 
    1052              
    1053             System.out.println('>') ; 
    1054              
     1192            System.out.println("/>"); 
     1193        else 
     1194        { 
     1195 
     1196            System.out.println('>'); 
     1197 
    10551198            int len = children.getLength(); 
    1056             for (int i = 0; i < len; i++) { 
     1199            for (int i = 0; i < len; i++) 
     1200            { 
    10571201                printXMLNode(children.item(i), depth + 1, printText); 
    10581202            } 
    1059              
    1060             for (int i=0 ; i<depth ; i++) 
    1061             System.out.print(' ') ; 
    1062              
     1203 
     1204            for (int i = 0; i < depth; i++) 
     1205                System.out.print(' '); 
     1206 
    10631207            System.out.println("</" + e.getNodeName() + ">"); 
    1064         }    
    1065     } 
    1066  
    1067     public static void elementToLogAsString(Element e) { 
    1068         try { 
     1208        } 
     1209    } 
     1210 
     1211    public static void elementToLogAsString(Element e) 
     1212    { 
     1213        try 
     1214        { 
    10691215            TransformerFactory tf = TransformerFactory.newInstance(); 
    10701216            Transformer trans = tf.newTransformer(); 
    10711217            StringWriter sw = new StringWriter(); 
    10721218            trans.transform(new DOMSource(e), new StreamResult(sw)); 
    1073             System.err.println( sw.toString() ); 
    1074         } catch( Exception ex ) { 
    1075             System.err.println( "couldn't write " + e + " to log" ); 
     1219            System.err.println(sw.toString()); 
     1220        } 
     1221        catch (Exception ex) 
     1222        { 
     1223            System.err.println("couldn't write " + e + " to log"); 
    10761224        } 
    10771225    }