Changeset 12814


Ignore:
Timestamp:
2006-09-21T16:35:39+12:00 (18 years ago)
Author:
mdewsnip
Message:

CollectionConfiguration no longer inherits from StaticStrings.

Location:
trunk/gli/src/org/greenstone/gatherer
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/gli/src/org/greenstone/gatherer/cdm/CollectionConfiguration.java

    r12813 r12814  
    5353 */
    5454public class CollectionConfiguration
    55     extends StaticStrings {
    56    
    57     static final public String ENCODING = "UTF-8";
     55{
     56    static final private String ENCODING = "UTF-8";
     57    static final private String NEWLINE_ELEMENT = "NewLine";
    5858
    5959    static private Document document;
    … …  
    8181        ///ystem.err.println("Found matching elements.");
    8282        // Only CollectionMeta are grouped.
    83         if(target_element_name.equals(COLLECTIONMETADATA_ELEMENT)) {
     83        if(target_element_name.equals(StaticStrings.COLLECTIONMETADATA_ELEMENT)) {
    8484        ///ystem.err.println("Dealing with collection metadata");
    8585        // Special case: CollectionMeta can be added at either the start or end of a collection configuration file. However the start position is reserved for special metadata, so if no non-special metadata can be found we must append to the end.
    8686        // So if the command to be added is special add it immediately after any other special command
    87         if(target_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
     87        if(target_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
    8888            int index = 0;
    8989            Element matched_element = (Element) matching_elements.item(index);
    9090            Element sibling_element = (Element) matched_element.getNextSibling();
    91             while(sibling_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
     91            while(sibling_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
    9292            index++;
    9393            matched_element = (Element) matching_elements.item(index);
    … …  
    103103        else {
    104104            int index = 0;
    105             target_element_name = target_element.getAttribute(NAME_ATTRIBUTE);
     105            target_element_name = target_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    106106            boolean found = false;
    107107            // Skip all of the special metadata
    108108            Element matched_element = (Element) matching_elements.item(index);
    109             while(matched_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) {
     109            while(matched_element.getAttribute(StaticStrings.SPECIAL_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
    110110            index++;
    111111            matched_element = (Element) matching_elements.item(index);
    … …  
    113113            // Begin search
    114114            while(!found && matched_element != null) {
    115             if(matched_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) {
     115            if(matched_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name)) {
    116116                found = true;
    117117            }
    … …  
    126126            Element previous_sibling = matched_element;
    127127            Element sibling_element = (Element) matching_elements.item(index);
    128             while(sibling_element != null && sibling_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) {
     128            while(sibling_element != null && sibling_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(target_element_name)) {
    129129                previous_sibling = sibling_element;
    130130                index++;
    … …  
    214214    static public String toString(Element command_element, boolean show_extracted_namespace) {
    215215    String command_element_name = command_element.getNodeName();
    216     if(command_element_name.equals(CLASSIFY_ELEMENT)) {
     216    if(command_element_name.equals(StaticStrings.CLASSIFY_ELEMENT)) {
    217217        return classifyToString(command_element, show_extracted_namespace);
    218218    }
    219     else if(command_element_name.equals(FORMAT_ELEMENT)) {
     219    else if(command_element_name.equals(StaticStrings.FORMAT_ELEMENT)) {
    220220        return formatToString(command_element, show_extracted_namespace);
    221221    }
    222     else if(command_element_name.equals(INDEXES_ELEMENT)) {
     222    else if(command_element_name.equals(StaticStrings.INDEXES_ELEMENT)) {
    223223        return indexesToString(command_element, show_extracted_namespace);
    224224    }
    225     else if(command_element_name.equals(INDEX_DEFAULT_ELEMENT)) {
     225    else if(command_element_name.equals(StaticStrings.INDEX_DEFAULT_ELEMENT)) {
    226226        return indexDefaultToString(command_element, show_extracted_namespace);
    227227    }
    228     else if(command_element_name.equals(LANGUAGES_ELEMENT)) {
     228    else if(command_element_name.equals(StaticStrings.LANGUAGES_ELEMENT)) {
    229229        return languagesToString(command_element);
    230230    }
    231     else if(command_element_name.equals(LANGUAGE_DEFAULT_ELEMENT)) {
     231    else if(command_element_name.equals(StaticStrings.LANGUAGE_DEFAULT_ELEMENT)) {
    232232        return languageDefaultToString(command_element);
    233233    }
    234     else if (command_element_name.equals(LANGUAGE_METADATA_ELEMENT)) {
     234    else if (command_element_name.equals(StaticStrings.LANGUAGE_METADATA_ELEMENT)) {
    235235        return languageMetadataToString(command_element, show_extracted_namespace);
    236236    }
    237     else if(command_element_name.equals(LEVELS_ELEMENT)) {
     237    else if(command_element_name.equals(StaticStrings.LEVELS_ELEMENT)) {
    238238        return levelsToString(command_element);
    239239    }
    240     else if(command_element_name.equals(LEVEL_DEFAULT_ELEMENT)) {
     240    else if(command_element_name.equals(StaticStrings.LEVEL_DEFAULT_ELEMENT)) {
    241241        return levelDefaultToString(command_element);
    242242    }
    243     else if(command_element_name.equals(COLLECTIONMETADATA_ELEMENT)) {
     243    else if(command_element_name.equals(StaticStrings.COLLECTIONMETADATA_ELEMENT)) {
    244244        return metadataToString(command_element, show_extracted_namespace);
    245245    }
    246     else if(command_element_name.equals(COLLECTIONMETADATA_CREATOR_ELEMENT)) {
     246    else if(command_element_name.equals(StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT)) {
    247247        return metadataToString(command_element, show_extracted_namespace);
    248248    }
    249     else if(command_element_name.equals(COLLECTIONMETADATA_MAINTAINER_ELEMENT)) {
     249    else if(command_element_name.equals(StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT)) {
    250250        return metadataToString(command_element, show_extracted_namespace);
    251251    }
    252     else if(command_element_name.equals(COLLECTIONMETADATA_PUBLIC_ELEMENT)) {
     252    else if(command_element_name.equals(StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT)) {
    253253        return metadataToString(command_element, show_extracted_namespace);
    254254    }
    255     else if (command_element_name.equals(BUILDTYPE_ELEMENT)) {
     255    else if (command_element_name.equals(StaticStrings.BUILDTYPE_ELEMENT)) {
    256256        return metadataToString(command_element, show_extracted_namespace);
    257257    }
    258     else if(command_element_name.equals(PLUGIN_ELEMENT)) {
     258    else if(command_element_name.equals(StaticStrings.PLUGIN_ELEMENT)) {
    259259        return pluginToString(command_element, show_extracted_namespace);
    260260    }
    261 //  else if(command_element_name.equals(SEARCHTYPE_ELEMENT)) {
     261//  else if(command_element_name.equals(StaticStrings.SEARCHTYPE_ELEMENT)) {
    262262//      return searchtypeToString(command_element);
    263263//  }
    264     else if(command_element_name.equals(SUBCOLLECTION_ELEMENT)) {
     264    else if(command_element_name.equals(StaticStrings.SUBCOLLECTION_ELEMENT)) {
    265265        return subcollectionToString(command_element, show_extracted_namespace);
    266266    }
    267     else if(command_element_name.equals(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT)) {
     267    else if(command_element_name.equals(StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_ELEMENT)) {
    268268        return subcollectionDefaultIndexToString(command_element);
    269269    }
    270     else if(command_element_name.equals(SUBCOLLECTION_INDEXES_ELEMENT)) {
     270    else if(command_element_name.equals(StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT)) {
    271271        return subcollectionIndexesToString(command_element);
    272272    }
    273     else if(command_element_name.equals(SUPERCOLLECTION_ELEMENT)) {
     273    else if(command_element_name.equals(StaticStrings.SUPERCOLLECTION_ELEMENT)) {
    274274        return supercollectionToString(command_element);
    275275    }
    276     else if(command_element_name.equals(UNKNOWN_ELEMENT)) {
     276    else if(command_element_name.equals(StaticStrings.UNKNOWN_ELEMENT)) {
    277277        return unknownToString(command_element);
    278278    }
    … …  
    357357
    358358    public Element getCreator() {
    359     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_CREATOR_ELEMENT, null, null);
    360     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_CREATOR_STR);
    361     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     359    Element element = getOrCreateElementByTagName(StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, null, null);
     360    element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.COLLECTIONMETADATA_CREATOR_STR);
     361    element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
    362362    return element;
    363363    }
    … …  
    373373    /** Retrieve or create the languages Element. */
    374374    public Element getLanguages() {
    375     return getOrCreateElementByTagName(LANGUAGES_ELEMENT, null, null);
     375    return getOrCreateElementByTagName(StaticStrings.LANGUAGES_ELEMENT, null, null);
    376376    }
    377377
    378378    public Element getLanguageMetadata() {
    379     return getOrCreateElementByTagName(LANGUAGE_METADATA_ELEMENT, null, null);
     379    return getOrCreateElementByTagName(StaticStrings.LANGUAGE_METADATA_ELEMENT, null, null);
    380380    }
    381381   
    382382    public Element getLevels() {
    383     return getOrCreateElementByTagName(LEVELS_ELEMENT, null, null);
     383    return getOrCreateElementByTagName(StaticStrings.LEVELS_ELEMENT, null, null);
    384384    }
    385385
    386386    public Element getMaintainer() {
    387     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_MAINTAINER_ELEMENT, null, null);
    388     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_MAINTAINER_STR);
    389     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     387    Element element = getOrCreateElementByTagName(StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, null, null);
     388    element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR);
     389    element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
    390390    return element;
    391391    }
    … …  
    393393    /** Retrieve or create the indexes Element. Note that this method behaves differently from the other getBlah methods, in that it also has to keep in mind that indexes come in two flavours, MG and MGPP. */
    394394    public Element getMGIndexes() {
    395     return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, FALSE_STR);
     395    return getOrCreateElementByTagName(StaticStrings.INDEXES_ELEMENT, StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
    396396    }
    397397
    398398    public Element getMGPPIndexes() {
    399     return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, TRUE_STR);
     399    return getOrCreateElementByTagName(StaticStrings.INDEXES_ELEMENT, StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
    400400    }
    401401
    402402    public Element getPublic() {
    403     Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_PUBLIC_ELEMENT, null, null);
    404     element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_PUBLIC_STR);
    405     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     403    Element element = getOrCreateElementByTagName(StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, null, null);
     404    element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.COLLECTIONMETADATA_PUBLIC_STR);
     405    element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
    406406    return element;
    407407    }
    408408
    409409    public Element getBuildType() {
    410     Element element = getOrCreateElementByTagName(BUILDTYPE_ELEMENT, null, null);
    411     element.setAttribute(NAME_ATTRIBUTE, BUILDTYPE_STR);
    412     element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
     410    Element element = getOrCreateElementByTagName(StaticStrings.BUILDTYPE_ELEMENT, null, null);
     411    element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.BUILDTYPE_STR);
     412    element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
    413413    return element;
    414414
    … …  
    417417    /** Retrieve or create the subindexes Element. */
    418418    public Element getSubIndexes() {
    419     return getOrCreateElementByTagName(SUBCOLLECTION_INDEXES_ELEMENT, null, null);
     419    return getOrCreateElementByTagName(StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT, null, null);
    420420    }
    421421
    422422    /** Retrieve or create the supercollections Element. */
    423423    public Element getSuperCollection() {
    424     return getOrCreateElementByTagName(SUPERCOLLECTION_ELEMENT, null, null);
     424    return getOrCreateElementByTagName(StaticStrings.SUPERCOLLECTION_ELEMENT, null, null);
    425425    }
    426426
    … …  
    452452        // Anything else we write to file, but only if it has been assigned, except for index and level commands
    453453        // (which just get commented out if unassigned -- a side effect of MG & MGPP compatibility)
    454         else if (!command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR) || command_element.getNodeName().equals(INDEXES_ELEMENT) || command_element.getNodeName().equals(INDEX_DEFAULT_ELEMENT) || command_element.getNodeName().equals(LEVELS_ELEMENT) || command_element.getNodeName().equals(LEVEL_DEFAULT_ELEMENT)) {
     454        else if (!command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR) || command_element.getNodeName().equals(StaticStrings.INDEXES_ELEMENT) || command_element.getNodeName().equals(StaticStrings.INDEX_DEFAULT_ELEMENT) || command_element.getNodeName().equals(StaticStrings.LEVELS_ELEMENT) || command_element.getNodeName().equals(StaticStrings.LEVEL_DEFAULT_ELEMENT)) {
    455455        String command;
    456         if (command_element.getNodeName().equals(FORMAT_ELEMENT)) {
     456        if (command_element.getNodeName().equals(StaticStrings.FORMAT_ELEMENT)) {
    457457            // Format statements we write out with ex. still present
    458458            command = toString(command_element, true);
    … …  
    489489    // Make a backup of the collect.cfg file
    490490    if (collect_cfg_file.exists()) {
    491         File original_file = new File(collect_cfg_file.getParentFile(), COLLECT_CFG);
     491        File original_file = new File(collect_cfg_file.getParentFile(), StaticStrings.COLLECT_CFG);
    492492        File backup_file = new File(collect_cfg_file.getParentFile(), "collect.bak");
    493493        if (backup_file.exists()) {
    … …  
    529529    static private String classifyToString(Element command_element, boolean show_extracted_namespace)
    530530    {
    531     StringBuffer text = new StringBuffer(CLASSIFY_STR);
    532     text.append(TAB_CHARACTER);
    533     text.append(command_element.getAttribute(TYPE_ATTRIBUTE));
    534     NodeList option_elements = command_element.getElementsByTagName(OPTION_ELEMENT);
     531    StringBuffer text = new StringBuffer(StaticStrings.CLASSIFY_STR);
     532    text.append(StaticStrings.TAB_CHARACTER);
     533    text.append(command_element.getAttribute(StaticStrings.TYPE_ATTRIBUTE));
     534    NodeList option_elements = command_element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
    535535    int option_elements_length = option_elements.getLength();
    536536    for(int j = 0; j < option_elements_length; j++) {
    537537        Element option_element = (Element) option_elements.item(j);
    538         if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
    539         text.append(SPACE_CHARACTER);
     538        if(option_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
     539        text.append(StaticStrings.SPACE_CHARACTER);
    540540        text.append(StaticStrings.MINUS_CHARACTER);
    541         text.append(option_element.getAttribute(NAME_ATTRIBUTE));
     541        text.append(option_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    542542        String value_str = XMLTools.getValue(option_element);
    543543
    … …  
    565565        }
    566566
    567         text.append(SPACE_CHARACTER);
    568         if (value_str.indexOf(SPACE_CHARACTER) == -1) {
     567        text.append(StaticStrings.SPACE_CHARACTER);
     568        if (value_str.indexOf(StaticStrings.SPACE_CHARACTER) == -1) {
    569569            text.append(value_str);
    570570        }
    571571        else {
    572             text.append(SPEECH_CHARACTER);
     572            text.append(StaticStrings.SPEECH_CHARACTER);
    573573            text.append(value_str);
    574             text.append(SPEECH_CHARACTER);
     574            text.append(StaticStrings.SPEECH_CHARACTER);
    575575        }
    576576        value_str = null;
    … …  
    583583
    584584    static private String formatToString(Element command_element, boolean show_extracted_namespace) {
    585     StringBuffer text = new StringBuffer(FORMAT_STR);
    586     text.append(SPACE_CHARACTER);
    587     text.append(command_element.getAttribute(NAME_ATTRIBUTE));
    588     text.append(SPACE_CHARACTER);
    589     String value_str = command_element.getAttribute(VALUE_ATTRIBUTE);
     585    StringBuffer text = new StringBuffer(StaticStrings.FORMAT_STR);
     586    text.append(StaticStrings.SPACE_CHARACTER);
     587    text.append(command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
     588    text.append(StaticStrings.SPACE_CHARACTER);
     589    String value_str = command_element.getAttribute(StaticStrings.VALUE_ATTRIBUTE);
    590590    if(value_str.length() != 0) {
    591591        text.append(value_str);
    … …  
    600600        }
    601601
    602         text.append(SPEECH_CHARACTER);
     602        text.append(StaticStrings.SPEECH_CHARACTER);
    603603        text.append(value_str);
    604         text.append(SPEECH_CHARACTER);
     604        text.append(StaticStrings.SPEECH_CHARACTER);
    605605    }
    606606    value_str = null;
    … …  
    649649    boolean comment_only = false;
    650650    StringBuffer text = new StringBuffer("");
    651     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
     651    if(command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR)) {
    652652        text.append("#");
    653653        comment_only = true;
    654654    }
    655     text.append(INDEX_STR);
    656     text.append(TAB_CHARACTER);
     655    text.append(StaticStrings.INDEX_STR);
     656    text.append(StaticStrings.TAB_CHARACTER);
    657657    if(!comment_only) {
    658         text.append(TAB_CHARACTER);
    659     }
    660     NodeList index_elements = command_element.getElementsByTagName(INDEX_ELEMENT);
     658        text.append(StaticStrings.TAB_CHARACTER);
     659    }
     660    NodeList index_elements = command_element.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
    661661    if (index_elements.getLength() == 0) { // no indexes
    662662        return "";
    … …  
    666666    for(int j = 0; j < index_elements_length; j++) {
    667667        Element index_element = (Element) index_elements.item(j);
    668         String level_str = index_element.getAttribute(LEVEL_ATTRIBUTE);
     668        String level_str = index_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE);
    669669        if(level_str.length() > 0) {
    670670        text.append(level_str);
    671671        text.append(StaticStrings.COLON_CHARACTER);
    672672        }
    673         NodeList content_elements = index_element.getElementsByTagName(CONTENT_ELEMENT);
     673        NodeList content_elements = index_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
    674674        int content_elements_length = content_elements.getLength();
    675675        // Don't output anything if no indexes are set
    … …  
    679679        for(int k = 0; k < content_elements_length; k++) {
    680680        Element content_element = (Element) content_elements.item(k);
    681         String name_str = content_element.getAttribute(NAME_ATTRIBUTE);
     681        String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    682682        if(!show_extracted_namespace && name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
    683683            name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
    … …  
    691691        }
    692692        if(j < index_elements_length - 1) {
    693         text.append(SPACE_CHARACTER);
     693        text.append(StaticStrings.SPACE_CHARACTER);
    694694        }
    695695        content_elements = null;
    … …  
    702702    static private String indexDefaultToString(Element command_element, boolean show_extracted_namespace) {
    703703    StringBuffer text = new StringBuffer("");
    704     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
     704    if(command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR)) {
    705705        text.append("#");
    706706    }
    707     text.append(INDEX_DEFAULT_STR);
    708     text.append(TAB_CHARACTER);
    709     if (!command_element.getAttribute(LEVEL_ATTRIBUTE).equals("")) {
    710         text.append(command_element.getAttribute(LEVEL_ATTRIBUTE));
     707    text.append(StaticStrings.INDEX_DEFAULT_STR);
     708    text.append(StaticStrings.TAB_CHARACTER);
     709    if (!command_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE).equals("")) {
     710        text.append(command_element.getAttribute(StaticStrings.LEVEL_ATTRIBUTE));
    711711        text.append(StaticStrings.COLON_CHARACTER);
    712712    }
    713     NodeList content_elements = command_element.getElementsByTagName(CONTENT_ELEMENT);
     713    NodeList content_elements = command_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
    714714    int content_elements_length = content_elements.getLength();
    715715    for(int j = 0; j < content_elements_length; j++) {
    716716        Element content_element = (Element) content_elements.item(j);
    717         String name_str = content_element.getAttribute(NAME_ATTRIBUTE);
     717        String name_str = content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    718718        if(!show_extracted_namespace && name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
    719719        name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
    … …  
    731731
    732732    static private String languagesToString(Element command_element) {
    733     StringBuffer text = new StringBuffer(LANGUAGES_STR);
    734     text.append(TAB_CHARACTER);
     733    StringBuffer text = new StringBuffer(StaticStrings.LANGUAGES_STR);
     734    text.append(StaticStrings.TAB_CHARACTER);
    735735    // Retrieve all the languages and write them out in a space separated list
    736     NodeList language_elements = command_element.getElementsByTagName(LANGUAGE_ELEMENT);
     736    NodeList language_elements = command_element.getElementsByTagName(StaticStrings.LANGUAGE_ELEMENT);
    737737    int language_elements_length = language_elements.getLength();
    738738    if(language_elements_length == 0) {
    … …  
    741741    for(int j = 0; j < language_elements_length; j++) {
    742742        Element language_element = (Element) language_elements.item(j);
    743         text.append(language_element.getAttribute(NAME_ATTRIBUTE));
     743        text.append(language_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    744744        if(j < language_elements_length - 1) {
    745         text.append(SPACE_CHARACTER);
     745        text.append(StaticStrings.SPACE_CHARACTER);
    746746        }
    747747    }
    … …  
    750750
    751751    static private String languageDefaultToString(Element command_element) {
    752     StringBuffer text = new StringBuffer(LANGUAGE_DEFAULT_STR);
    753     text.append(TAB_CHARACTER);
    754     text.append(command_element.getAttribute(NAME_ATTRIBUTE));
     752    StringBuffer text = new StringBuffer(StaticStrings.LANGUAGE_DEFAULT_STR);
     753    text.append(StaticStrings.TAB_CHARACTER);
     754    text.append(command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    755755    return text.toString();
    756756    }
    757757
    758758    static private String languageMetadataToString(Element command_element, boolean show_extracted_namespace) {
    759     if (!command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
     759    if (!command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
    760760        return "";
    761761    }
    762     StringBuffer text = new StringBuffer(LANGUAGE_METADATA_STR);
    763     text.append(TAB_CHARACTER);
    764     String name_str = command_element.getAttribute(NAME_ATTRIBUTE);
     762    StringBuffer text = new StringBuffer(StaticStrings.LANGUAGE_METADATA_STR);
     763    text.append(StaticStrings.TAB_CHARACTER);
     764    String name_str = command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    765765    if(!show_extracted_namespace && name_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
    766766        name_str = name_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
    … …  
    772772    static private String levelsToString(Element command_element) {
    773773    StringBuffer text = new StringBuffer("");
    774     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
     774    if(command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR)) {
    775775        text.append("#");
    776776    }
    777     text.append(LEVELS_STR);
    778     text.append(TAB_CHARACTER);
    779     text.append(TAB_CHARACTER);
    780     NodeList content_elements = command_element.getElementsByTagName(LEVEL_ELEMENT);
     777    text.append(StaticStrings.LEVELS_STR);
     778    text.append(StaticStrings.TAB_CHARACTER);
     779    text.append(StaticStrings.TAB_CHARACTER);
     780    NodeList content_elements = command_element.getElementsByTagName(StaticStrings.LEVEL_ELEMENT);
    781781    int content_elements_length = content_elements.getLength();
    782782    // Don't output anything if no levels are set.
    … …  
    786786    for(int i = 0; i < content_elements_length; i++) {
    787787        Element content_element = (Element) content_elements.item(i);
    788         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
    789         text.append(SPACE_CHARACTER);
     788        text.append(content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
     789        text.append(StaticStrings.SPACE_CHARACTER);
    790790    }
    791791    return text.substring(0, text.length() - 1);
    … …  
    794794    static private String levelDefaultToString(Element command_element) {
    795795    StringBuffer text = new StringBuffer("");
    796     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) {
     796    if(command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR)) {
    797797        text.append("#");
    798798    }
    799     text.append(LEVEL_DEFAULT_STR);
    800     text.append(TAB_CHARACTER);
    801     text.append(command_element.getAttribute(NAME_ATTRIBUTE));
     799    text.append(StaticStrings.LEVEL_DEFAULT_STR);
     800    text.append(StaticStrings.TAB_CHARACTER);
     801    text.append(command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    802802    return text.toString();
    803803    }
    … …  
    814814   
    815815    StringBuffer text = new StringBuffer("");
    816     String name_str = command_element.getAttribute(NAME_ATTRIBUTE);
     816    String name_str = command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    817817    // If the name is one of the special four, we don't write the collectionmeta first. Note maintainer and buildtype are singled out for 'prittying' reasons.
    818     if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)|| name_str.equals(BUILDTYPE_STR) ) {
     818    if(name_str.equals(StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR)|| name_str.equals(StaticStrings.BUILDTYPE_STR) ) {
    819819        text.append(name_str);
    820         text.append(TAB_CHARACTER);
     820        text.append(StaticStrings.TAB_CHARACTER);
    821821        special = true;
    822822    }
    823     else if (name_str.equals(COLLECTIONMETADATA_CREATOR_STR) || name_str.equals(COLLECTIONMETADATA_PUBLIC_STR) ) {
     823    else if (name_str.equals(StaticStrings.COLLECTIONMETADATA_CREATOR_STR) || name_str.equals(StaticStrings.COLLECTIONMETADATA_PUBLIC_STR) ) {
    824824        text.append(name_str);
    825         text.append(TAB_CHARACTER);
    826         text.append(TAB_CHARACTER);
     825        text.append(StaticStrings.TAB_CHARACTER);
     826        text.append(StaticStrings.TAB_CHARACTER);
    827827        special = true;
    828828    }
    829829    else {
    830         text.append(COLLECTIONMETADATA_STR);
    831         text.append(TAB_CHARACTER);
     830        text.append(StaticStrings.COLLECTIONMETADATA_STR);
     831        text.append(StaticStrings.TAB_CHARACTER);
    832832        text.append(name_str);
    833         text.append(SPACE_CHARACTER);
    834         String language_str = command_element.getAttribute(LANGUAGE_ATTRIBUTE);
    835         text.append(LBRACKET_CHARACTER);
    836         text.append(LANGUAGE_ARGUMENT);
     833        text.append(StaticStrings.SPACE_CHARACTER);
     834        String language_str = command_element.getAttribute(StaticStrings.LANGUAGE_ATTRIBUTE);
     835        text.append(StaticStrings.LBRACKET_CHARACTER);
     836        text.append(StaticStrings.LANGUAGE_ARGUMENT);
    837837        text.append(language_str);
    838         text.append(RBRACKET_CHARACTER);
    839         text.append(SPACE_CHARACTER);
     838        text.append(StaticStrings.RBRACKET_CHARACTER);
     839        text.append(StaticStrings.SPACE_CHARACTER);
    840840    }
    841841    name_str = null;
    … …  
    854854    }
    855855    else {
    856         text.append(SPEECH_CHARACTER);
     856        text.append(StaticStrings.SPEECH_CHARACTER);
    857857        text.append(value_str);
    858         text.append(SPEECH_CHARACTER);
     858        text.append(StaticStrings.SPEECH_CHARACTER);
    859859    }
    860860    value_str = null;
    … …  
    886886        command_str = command_str.trim();
    887887        boolean eof = false;
    888         while(!eof && command_str.endsWith(NEWLINE_CHARACTER)) {
     888        while(!eof && command_str.endsWith(StaticStrings.NEWLINE_CHARACTER)) {
    889889            String next_line = in.readLine();
    890890            if(next_line != null) {
    … …  
    892892            if(next_line.length() > 0) {
    893893                // Remove the new line character
    894                 command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
     894                command_str = command_str.substring(0, command_str.lastIndexOf(StaticStrings.NEWLINE_CHARACTER));
    895895                // And append the next line, which due to the test above must be non-zero length
    896896                command_str = command_str + next_line;
    … …  
    904904        }
    905905        // If there is still a new line character, then we remove it and hope for the best
    906         if(command_str.endsWith(NEWLINE_CHARACTER)) {
    907             command_str = command_str.substring(0, command_str.lastIndexOf(NEWLINE_CHARACTER));
     906        if(command_str.endsWith(StaticStrings.NEWLINE_CHARACTER)) {
     907            command_str = command_str.substring(0, command_str.lastIndexOf(StaticStrings.NEWLINE_CHARACTER));
    908908        }
    909909        // Now we've either got a command to parse...
    … …  
    915915            String command_type = tokenizer.nextToken().toLowerCase();
    916916            // Why can't you switch on strings eh? We pass it to the various subparsers who each have a bash at parsing the command. If none can parse the command, an unknown element is created
    917             if(command_element == null && command_type.equals(CLASSIFY_STR)) {
     917            if(command_element == null && command_type.equals(StaticStrings.CLASSIFY_STR)) {
    918918            command_element = parseClassify(command_str);
    919919            }
    920             if(command_element == null && command_type.equals(FORMAT_STR)) {
     920            if(command_element == null && command_type.equals(StaticStrings.FORMAT_STR)) {
    921921            command_element = parseFormat(tokenizer); // Revised to handle multiple lines
    922922            }
    923             if(command_element == null && (command_type.equals(INDEX_STR)  || command_type.equals(COMMENTED_INDEXES_STR))) {
     923            if(command_element == null && (command_type.equals(StaticStrings.INDEX_STR)  || command_type.equals(StaticStrings.COMMENTED_INDEXES_STR))) {
    924924            command_element = parseIndex(command_str);
    925925            }
    926             if(command_element == null && (command_type.equals(INDEX_DEFAULT_STR) || command_type.equals(COMMENTED_INDEX_DEFAULT_STR))) {
     926            if(command_element == null && (command_type.equals(StaticStrings.INDEX_DEFAULT_STR) || command_type.equals(StaticStrings.COMMENTED_INDEX_DEFAULT_STR))) {
    927927           
    928928            command_element = parseIndexDefault(command_str);
    929929            }
    930             if(command_element == null && command_type.equals(LANGUAGES_STR)) {
     930            if(command_element == null && command_type.equals(StaticStrings.LANGUAGES_STR)) {
    931931            command_element = parseLanguage(command_str);
    932932            }
    933             if(command_element == null && command_type.equals(LANGUAGE_DEFAULT_STR)) {
     933            if(command_element == null && command_type.equals(StaticStrings.LANGUAGE_DEFAULT_STR)) {
    934934            command_element = parseLanguageDefault(command_str);
    935935            }
    936             if (command_element == null && command_type.equals(LANGUAGE_METADATA_STR)) {
     936            if (command_element == null && command_type.equals(StaticStrings.LANGUAGE_METADATA_STR)) {
    937937            command_element = parseLanguageMetadata(command_str);
    938938            }
    939             if(command_element == null && (command_type.equals(LEVELS_STR) || command_type.equals(COMMENTED_LEVELS_STR))) {
     939            if(command_element == null && (command_type.equals(StaticStrings.LEVELS_STR) || command_type.equals(StaticStrings.COMMENTED_LEVELS_STR))) {
    940940            command_element = parseLevels(command_str);
    941941            }
    942             if(command_element == null && (command_type.equals(LEVEL_DEFAULT_STR) || command_type.equals(COMMENTED_LEVEL_DEFAULT_STR))) {
     942            if(command_element == null && (command_type.equals(StaticStrings.LEVEL_DEFAULT_STR) || command_type.equals(StaticStrings.COMMENTED_LEVEL_DEFAULT_STR))) {
    943943           
    944944            command_element = parseLevelDefault(command_str);
    945945            }
    946946
    947             if(command_element == null && command_type.equals(COLLECTIONMETADATA_STR)) {
     947            if(command_element == null && command_type.equals(StaticStrings.COLLECTIONMETADATA_STR)) {
    948948            command_element = parseMetadata(tokenizer); // Revised to handle multiple lines
    949949            }
    950             if(command_element == null && (command_type.equals(COLLECTIONMETADATA_PUBLIC_STR) || command_type.equals(COLLECTIONMETADATA_CREATOR_STR) || command_type.equals(COLLECTIONMETADATA_MAINTAINER_STR) || command_type.equals(BUILDTYPE_STR))) {
     950            if(command_element == null && (command_type.equals(StaticStrings.COLLECTIONMETADATA_PUBLIC_STR) || command_type.equals(StaticStrings.COLLECTIONMETADATA_CREATOR_STR) || command_type.equals(StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR) || command_type.equals(StaticStrings.BUILDTYPE_STR))) {
    951951            command_element = parseMetadataSpecial(command_str);
    952952            // pre 2.71 hack
    953             if (command_type.equals(BUILDTYPE_STR)) {
     953            if (command_type.equals(StaticStrings.BUILDTYPE_STR)) {
    954954                build_types_parsed = true;
    955955            }
    956956            }
    957             if(command_element == null && command_type.equals(PLUGIN_STR)) {
     957            if(command_element == null && command_type.equals(StaticStrings.PLUGIN_STR)) {
    958958            command_element = parsePlugin(command_str);
    959959            }
    960960            // leave here for backwards compatibility
    961             if(command_element == null && command_type.equals(SEARCHTYPE_STR)) {
     961            if(command_element == null && command_type.equals(StaticStrings.SEARCHTYPE_STR)) {
    962962            command_element = parseSearchType(command_str);
    963963            // pre 2.71 hack
    … …  
    965965           
    966966            }
    967             if(command_element == null && command_type.equals(SUBCOLLECTION_STR)) {
     967            if(command_element == null && command_type.equals(StaticStrings.SUBCOLLECTION_STR)) {
    968968            command_element = parseSubCollection(command_str);
    969969            }
    970             if(command_element == null && command_type.equals(SUBCOLLECTION_DEFAULT_INDEX_STR)) {
     970            if(command_element == null && command_type.equals(StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_STR)) {
    971971            command_element = parseSubCollectionDefaultIndex(command_str);
    972972            }
    973             if(command_element == null && command_type.equals(SUBCOLLECTION_INDEX_STR)) {
     973            if(command_element == null && command_type.equals(StaticStrings.SUBCOLLECTION_INDEX_STR)) {
    974974            command_element = parseSubCollectionIndex(command_str);
    975975            }
    976             if(command_element == null && (command_type.equals(SUPERCOLLECTION_STR) || command_type.equals(CCS_STR))) {
     976            if(command_element == null && (command_type.equals(StaticStrings.SUPERCOLLECTION_STR) || command_type.equals(StaticStrings.CCS_STR))) {
    977977            command_element = parseSuperCollection(command_str);
    978978            }
    … …  
    981981            if(command_element == null) {
    982982            // No-one knows what to do with this command, so we create an Unknown command element
    983             command_element = document.createElement(UNKNOWN_ELEMENT);
     983            command_element = document.createElement(StaticStrings.UNKNOWN_ELEMENT);
    984984            XMLTools.setValue(command_element, command_str);
    985985            }
    … …  
    999999            buildtype_type = BuildTypeManager.BUILD_TYPE_MGPP;
    10001000        }
    1001         Element command_element = parseMetadataSpecial(BUILDTYPE_STR+"  "+buildtype_type);
     1001        Element command_element = parseMetadataSpecial(StaticStrings.BUILDTYPE_STR+"  "+buildtype_type);
    10021002        Node target_node = findInsertionPoint(command_element);
    10031003        if(target_node != null) {
    … …  
    10231023        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
    10241024        if(tokenizer.countTokens() >= 2) {  // Must support "classify Phind" (no args)
    1025         command_element = document.createElement(CLASSIFY_ELEMENT);
     1025        command_element = document.createElement(StaticStrings.CLASSIFY_ELEMENT);
    10261026        // First token is classify
    10271027        tokenizer.nextToken();
    10281028        // The next token is the classifier type
    1029         command_element.setAttribute(TYPE_ATTRIBUTE, tokenizer.nextToken());
     1029        command_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, tokenizer.nextToken());
    10301030        // Now we parse out the remaining arguments into a hashmapping from name to value
    10311031        HashMap arguments = parseArguments(tokenizer);
    … …  
    10361036            String value = (String) arguments.get(name); // Can be null
    10371037            // The metadata argument gets added as the content attribute
    1038             if (name.equals(METADATA_ARGUMENT) && value != null) {
     1038            if (name.equals(StaticStrings.METADATA_ARGUMENT) && value != null) {
    10391039            // Add the extracted namespace onto un-namespaced metadata names
    10401040            StringTokenizer string_tokenizer = new StringTokenizer(value, ",");
    … …  
    10601060            }
    10611061            // Everything else is an Option Element
    1062             Element option_element = document.createElement(OPTION_ELEMENT);
    1063             option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
     1062            Element option_element = document.createElement(StaticStrings.OPTION_ELEMENT);
     1063            option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name.substring(1));
    10641064            if(value != null) {
    10651065            // Remove any speech marks appended in strings containing whitespace
    1066             if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) {
     1066            if(value.startsWith(StaticStrings.SPEECH_CHARACTER) && value.endsWith(StaticStrings.SPEECH_CHARACTER)) {
    10671067                value = value.substring(1, value.length() - 1);
    10681068            }
    10691069            XMLTools.setValue(option_element, value);
    10701070            }
    1071             option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
     1071            option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    10721072            command_element.appendChild(option_element);
    10731073            option_element = null;
    … …  
    10881088    Element command_element = null;
    10891089    try {
    1090         command_element = document.createElement(FORMAT_ELEMENT);
     1090        command_element = document.createElement(StaticStrings.FORMAT_ELEMENT);
    10911091        String name_str = tokenizer.nextToken();
    10921092        String value_str = tokenizer.nextToken();
    10931093        if(name_str != null && value_str != null) {
    1094         command_element.setAttribute(NAME_ATTRIBUTE, name_str);
     1094        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
    10951095        // If the value is true or false we add it as an attribute
    1096         if(value_str.equalsIgnoreCase(TRUE_STR) || value_str.equalsIgnoreCase(FALSE_STR)) {
    1097             command_element.setAttribute(VALUE_ATTRIBUTE, value_str.toLowerCase());
     1096        if(value_str.equalsIgnoreCase(StaticStrings.TRUE_STR) || value_str.equalsIgnoreCase(StaticStrings.FALSE_STR)) {
     1097            command_element.setAttribute(StaticStrings.VALUE_ATTRIBUTE, value_str.toLowerCase());
    10981098        }
    10991099        // Otherwise it gets added as a text node
    … …  
    11221122        StringTokenizer tokenizer = new StringTokenizer(command_str);
    11231123        String command = tokenizer.nextToken();
    1124         command_element = document.createElement(INDEXES_ELEMENT);
    1125         command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(INDEX_STR) ? TRUE_STR : FALSE_STR));
     1124        command_element = document.createElement(StaticStrings.INDEXES_ELEMENT);
     1125        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (command.equals(StaticStrings.INDEX_STR) ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
    11261126        command = null;
    11271127        if(!tokenizer.hasMoreTokens()) {
    11281128
    11291129        // there are no indexes
    1130         command_element.setAttribute(ASSIGNED_ATTRIBUTE, FALSE_STR);
    1131         command_element.setAttribute(MGPP_ATTRIBUTE, FALSE_STR); // for now
     1130        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
     1131        command_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR); // for now
    11321132        tokenizer = null;
    11331133        return command_element;
    … …  
    11351135
    11361136        while(tokenizer.hasMoreTokens()) {
    1137         Element index_element = document.createElement(INDEX_ELEMENT);
     1137        Element index_element = document.createElement(StaticStrings.INDEX_ELEMENT);
    11381138        String index_str = tokenizer.nextToken();
    11391139        // There are two types of index we have to consider. Old G2.38 and earlier use level:source tuplets while G2.39+ have just a single, non-comma separated list where order is important.
    11401140        boolean old_index;
    1141         if(index_str.indexOf(COLON_CHARACTER) != -1) {
     1141        if(index_str.indexOf(StaticStrings.COLON_CHARACTER) != -1) {
    11421142            old_index = true;
    1143             index_element.setAttribute(LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
     1143            index_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER)));
    11441144            index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1);
    1145             command_element.setAttribute(MGPP_ATTRIBUTE, FALSE_STR);
     1145            command_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.FALSE_STR);
    11461146        }
    11471147        else {
    1148             command_element.setAttribute(MGPP_ATTRIBUTE, TRUE_STR);
     1148            command_element.setAttribute(StaticStrings.MGPP_ATTRIBUTE, StaticStrings.TRUE_STR);
    11491149            old_index = false;
    11501150        }
    11511151        StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER);
    11521152        while(content_tokenizer.hasMoreTokens()) {
    1153             Element content_element = document.createElement(CONTENT_ELEMENT);
     1153            Element content_element = document.createElement(StaticStrings.CONTENT_ELEMENT);
    11541154            String content_str = content_tokenizer.nextToken();
    11551155            // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
    … …  
    11621162            }
    11631163            }
    1164             content_element.setAttribute(NAME_ATTRIBUTE, content_str);
     1164            content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_str);
    11651165            index_element.appendChild(content_element);
    11661166            content_element = null;
    … …  
    11841184        StringTokenizer tokenizer = new StringTokenizer(command_str);
    11851185        if(tokenizer.countTokens() >= 2) {
    1186         command_element = document.createElement(INDEX_DEFAULT_ELEMENT);                 
    1187         command_element.setAttribute(ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(INDEX_DEFAULT_STR) ? TRUE_STR : FALSE_STR));
     1186        command_element = document.createElement(StaticStrings.INDEX_DEFAULT_ELEMENT);                 
     1187        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(StaticStrings.INDEX_DEFAULT_STR) ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
    11881188        String index_str = tokenizer.nextToken();
    11891189                String level="";
    … …  
    11921192        }
    11931193   
    1194         command_element.setAttribute(LEVEL_ATTRIBUTE,level);
     1194        command_element.setAttribute(StaticStrings.LEVEL_ATTRIBUTE,level);
    11951195                 
    11961196        String content_str = index_str;
    … …  
    12021202        StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
    12031203        while(content_tokenizer.hasMoreTokens()) {
    1204             Element content_element = document.createElement(CONTENT_ELEMENT);
    1205             content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
     1204            Element content_element = document.createElement(StaticStrings.CONTENT_ELEMENT);
     1205            content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_tokenizer.nextToken());
    12061206            command_element.appendChild(content_element);
    12071207            content_element = null;
    … …  
    12251225        tokenizer.nextToken();
    12261226        if(tokenizer.hasMoreTokens()) {
    1227         command_element = document.createElement(LANGUAGES_ELEMENT);
     1227        command_element = document.createElement(StaticStrings.LANGUAGES_ELEMENT);
    12281228        while(tokenizer.hasMoreTokens()) {
    1229             Element language_element = document.createElement(LANGUAGE_ELEMENT);
    1230             language_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
     1229            Element language_element = document.createElement(StaticStrings.LANGUAGE_ELEMENT);
     1230            language_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, tokenizer.nextToken());
    12311231            command_element.appendChild(language_element);
    12321232            language_element = null;
    … …  
    12451245        StringTokenizer tokenizer = new StringTokenizer(command_str);
    12461246        if(tokenizer.countTokens() >= 2) {
    1247         command_element = document.createElement(LANGUAGE_DEFAULT_ELEMENT);
     1247        command_element = document.createElement(StaticStrings.LANGUAGE_DEFAULT_ELEMENT);
    12481248        tokenizer.nextToken();
    12491249        String default_language_str = tokenizer.nextToken();
    1250         command_element.setAttribute(NAME_ATTRIBUTE, default_language_str);
    1251         command_element.setAttribute(ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
     1250        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, default_language_str);
     1251        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    12521252        default_language_str = null;
    12531253        }
    … …  
    12641264        StringTokenizer tokenizer = new StringTokenizer(command_str);
    12651265        if(tokenizer.countTokens() >= 2) {
    1266         command_element = document.createElement(LANGUAGE_METADATA_ELEMENT);
     1266        command_element = document.createElement(StaticStrings.LANGUAGE_METADATA_ELEMENT);
    12671267        tokenizer.nextToken();
    12681268        String language_metadata_str = tokenizer.nextToken();
    … …  
    12701270            language_metadata_str = StaticStrings.EXTRACTED_NAMESPACE + language_metadata_str;
    12711271        }
    1272         command_element.setAttribute(NAME_ATTRIBUTE, language_metadata_str);
    1273         command_element.setAttribute(ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
     1272        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, language_metadata_str);
     1273        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    12741274        language_metadata_str = null;
    12751275        }
    … …  
    12891289        String command = tokenizer.nextToken();
    12901290        if(tokenizer.hasMoreTokens()) {
    1291         command_element = document.createElement(LEVELS_ELEMENT);
    1292         command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(LEVELS_STR) ? TRUE_STR : FALSE_STR));
     1291        command_element = document.createElement(StaticStrings.LEVELS_ELEMENT);
     1292        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (command.equals(StaticStrings.LEVELS_STR) ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
    12931293        while(tokenizer.hasMoreTokens()) {
    1294             Element level_element = document.createElement(LEVEL_ELEMENT);
    1295             level_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
     1294            Element level_element = document.createElement(StaticStrings.LEVEL_ELEMENT);
     1295            level_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, tokenizer.nextToken());
    12961296            command_element.appendChild(level_element);
    12971297            level_element = null;
    … …  
    13101310        StringTokenizer tokenizer = new StringTokenizer(command_str);
    13111311        if(tokenizer.countTokens() >= 2) {
    1312         command_element = document.createElement(LEVEL_DEFAULT_ELEMENT);
    1313         command_element.setAttribute(ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(LEVEL_DEFAULT_STR) ? TRUE_STR : FALSE_STR)); // is it commented out or not?
    1314         command_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
     1312        command_element = document.createElement(StaticStrings.LEVEL_DEFAULT_ELEMENT);
     1313        command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(StaticStrings.LEVEL_DEFAULT_STR) ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR)); // is it commented out or not?
     1314        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, tokenizer.nextToken());
    13151315        }
    13161316       
    … …  
    13251325    Element command_element = null;
    13261326    try {
    1327         command_element = document.createElement(COLLECTIONMETADATA_ELEMENT);
     1327        command_element = document.createElement(StaticStrings.COLLECTIONMETADATA_ELEMENT);
    13281328        String name_str = tokenizer.nextToken();
    13291329        String value_str = tokenizer.nextToken();
    … …  
    13311331        String language_str = Configuration.getLanguage();
    13321332        // Check if the value string is actually a language string
    1333         if(value_str.startsWith(LBRACKET_CHARACTER) && value_str.endsWith(RBRACKET_CHARACTER)) {
    1334             language_str = value_str.substring(value_str.indexOf(LANGUAGE_ARGUMENT) + 2, value_str.length() - 1);
     1333        if(value_str.startsWith(StaticStrings.LBRACKET_CHARACTER) && value_str.endsWith(StaticStrings.RBRACKET_CHARACTER)) {
     1334            language_str = value_str.substring(value_str.indexOf(StaticStrings.LANGUAGE_ARGUMENT) + 2, value_str.length() - 1);
    13351335            value_str = tokenizer.nextToken();
    13361336        }
    … …  
    13381338            // Ready the value str (which can contain all sorts of funky characters) for writing as a DOM value
    13391339            value_str = Codec.transform(value_str, Codec.GREENSTONE_TO_DOM);
    1340             command_element.setAttribute(NAME_ATTRIBUTE, name_str);
    1341             command_element.setAttribute(LANGUAGE_ATTRIBUTE, language_str);
    1342             command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
     1340            command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
     1341            command_element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, language_str);
     1342            command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    13431343            XMLTools.setValue(command_element, value_str);
    13441344        }
    … …  
    13681368        String name_str = tokenizer.nextToken();
    13691369        String value_str = tokenizer.nextToken();
    1370         if (name_str.equals(COLLECTIONMETADATA_CREATOR_STR)) {
    1371             command_element = document.createElement(COLLECTIONMETADATA_CREATOR_ELEMENT);
    1372         }
    1373         else if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)) {
    1374             command_element = document.createElement(COLLECTIONMETADATA_MAINTAINER_ELEMENT);
    1375         }
    1376         else if(name_str.equals(COLLECTIONMETADATA_PUBLIC_STR)) {
    1377             command_element = document.createElement(COLLECTIONMETADATA_PUBLIC_ELEMENT);
    1378         }
    1379         else if (name_str.equals(BUILDTYPE_STR)) {
    1380             command_element = document.createElement(BUILDTYPE_ELEMENT);
     1370        if (name_str.equals(StaticStrings.COLLECTIONMETADATA_CREATOR_STR)) {
     1371            command_element = document.createElement(StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT);
     1372        }
     1373        else if(name_str.equals(StaticStrings.COLLECTIONMETADATA_MAINTAINER_STR)) {
     1374            command_element = document.createElement(StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT);
     1375        }
     1376        else if(name_str.equals(StaticStrings.COLLECTIONMETADATA_PUBLIC_STR)) {
     1377            command_element = document.createElement(StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT);
     1378        }
     1379        else if (name_str.equals(StaticStrings.BUILDTYPE_STR)) {
     1380            command_element = document.createElement(StaticStrings.BUILDTYPE_ELEMENT);
    13811381        }
    13821382        if(command_element != null) {
    1383             command_element.setAttribute(NAME_ATTRIBUTE, name_str);
    1384             command_element.setAttribute(LANGUAGE_ATTRIBUTE, ENGLISH_LANGUAGE_STR);
    1385             command_element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR);
    1386             command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
    1387             if(value_str.startsWith(SPEECH_CHARACTER) && value_str.endsWith(SPEECH_CHARACTER)) {
     1383            command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name_str);
     1384            command_element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, StaticStrings.ENGLISH_LANGUAGE_STR);
     1385            command_element.setAttribute(StaticStrings.SPECIAL_ATTRIBUTE, StaticStrings.TRUE_STR);
     1386            command_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
     1387            if(value_str.startsWith(StaticStrings.SPEECH_CHARACTER) && value_str.endsWith(StaticStrings.SPEECH_CHARACTER)) {
    13881388            value_str = value_str.substring(1, value_str.length() - 1);
    13891389            }
    … …  
    14071407        // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument).
    14081408        if(tokenizer.countTokens() >= 2) {
    1409         command_element = document.createElement(PLUGIN_ELEMENT);
     1409        command_element = document.createElement(StaticStrings.PLUGIN_ELEMENT);
    14101410        // First token is plugin
    14111411        tokenizer.nextToken();
    14121412        // The next token is the type
    14131413        String type = tokenizer.nextToken();
    1414         command_element.setAttribute(TYPE_ATTRIBUTE, type);
     1414        command_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, type);
    14151415        // Now we parse out the remaining arguments into a hashmapping from name to value
    14161416        HashMap arguments = parseArguments(tokenizer);
    … …  
    14201420            String name = (String) names.next();
    14211421            String value = (String) arguments.get(name); // Can be null
    1422             Element option_element = document.createElement(OPTION_ELEMENT);
    1423             if(name.substring(1).equals(USE_METADATA_FILES_ARGUMENT)) {
     1422            Element option_element = document.createElement(StaticStrings.OPTION_ELEMENT);
     1423            if(name.substring(1).equals(StaticStrings.USE_METADATA_FILES_ARGUMENT)) {
    14241424            use_metadata_files = true;
    14251425            }
    1426             option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1));
    1427             option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
     1426            option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name.substring(1));
     1427            option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    14281428            if(value != null) {
    14291429            // Remove any speech marks appended in strings containing whitespace
    1430             if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) {
     1430            if(value.startsWith(StaticStrings.SPEECH_CHARACTER) && value.endsWith(StaticStrings.SPEECH_CHARACTER)) {
    14311431                value = value.substring(1, value.length() - 1);
    14321432            }
    1433             if(name.equals(METADATA_ARGUMENT)) {
     1433            if(name.equals(StaticStrings.METADATA_ARGUMENT)) {
    14341434                // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace.
    14351435                if(value.indexOf(StaticStrings.NS_SEP) == -1) {
    … …  
    14461446
    14471447        // We must have some RecPlug options: use_metadata_files
    1448         if (type.equals(RECPLUG_STR)) {
     1448        if (type.equals(StaticStrings.RECPLUG_STR)) {
    14491449            if (!use_metadata_files) {
    1450             Element option_element = document.createElement(OPTION_ELEMENT);
    1451             option_element.setAttribute(NAME_ATTRIBUTE, USE_METADATA_FILES_ARGUMENT);
    1452             option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR);
     1450            Element option_element = document.createElement(StaticStrings.OPTION_ELEMENT);
     1451            option_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, StaticStrings.USE_METADATA_FILES_ARGUMENT);
     1452            option_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR);
    14531453            command_element.appendChild(option_element);
    14541454            option_element = null;
    … …  
    14741474        tokenizer.nextToken();
    14751475        if(tokenizer.hasMoreTokens()) {
    1476         command_element = document.createElement(FORMAT_ELEMENT);
    1477         command_element.setAttribute(NAME_ATTRIBUTE, "SearchTypes");
     1476        command_element = document.createElement(StaticStrings.FORMAT_ELEMENT);
     1477        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, "SearchTypes");
    14781478        String value = tokenizer.nextToken();
    14791479        while(tokenizer.hasMoreTokens()) {
    … …  
    14941494        CommandTokenizer tokenizer = new CommandTokenizer(command_str);
    14951495        if(tokenizer.countTokens() >= 3) {
    1496         command_element = document.createElement(SUBCOLLECTION_ELEMENT);
     1496        command_element = document.createElement(StaticStrings.SUBCOLLECTION_ELEMENT);
    14971497        // First token is command type
    14981498        tokenizer.nextToken();
    14991499        // Then subcollection identifier
    1500         command_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
     1500        command_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, tokenizer.nextToken());
    15011501        // Then finally the pattern used to build the subcollection partition
    15021502        String full_pattern_str = tokenizer.nextToken();
    15031503        // Set inclusion/exclusion flag and remove any exclamation mark
    1504         boolean exclusion = full_pattern_str.startsWith(EXCLAMATION_CHARACTER);
     1504        boolean exclusion = full_pattern_str.startsWith(StaticStrings.EXCLAMATION_CHARACTER);
    15051505        if (exclusion) {
    15061506            full_pattern_str = full_pattern_str.substring(1, full_pattern_str.length());
    1507             command_element.setAttribute(TYPE_ATTRIBUTE, EXCLUDE_STR);
     1507            command_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, StaticStrings.EXCLUDE_STR);
    15081508        }
    15091509        else {
    1510             command_element.setAttribute(TYPE_ATTRIBUTE, INCLUDE_STR);
    1511         }
    1512         StringTokenizer pattern_tokenizer = new StringTokenizer(full_pattern_str, SEPARATOR_CHARACTER);
     1510            command_element.setAttribute(StaticStrings.TYPE_ATTRIBUTE, StaticStrings.INCLUDE_STR);
     1511        }
     1512        StringTokenizer pattern_tokenizer = new StringTokenizer(full_pattern_str, StaticStrings.SEPARATOR_CHARACTER);
    15131513        if(pattern_tokenizer.countTokens() >= 2) {
    15141514            String content_str = pattern_tokenizer.nextToken();
    … …  
    15171517            content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
    15181518            }
    1519             command_element.setAttribute(CONTENT_ATTRIBUTE, content_str);
     1519            command_element.setAttribute(StaticStrings.CONTENT_ATTRIBUTE, content_str);
    15201520            XMLTools.setValue(command_element, pattern_tokenizer.nextToken());
    15211521            if(pattern_tokenizer.hasMoreTokens()) {
    1522             command_element.setAttribute(OPTIONS_ATTRIBUTE, pattern_tokenizer.nextToken());
     1522            command_element.setAttribute(StaticStrings.OPTIONS_ATTRIBUTE, pattern_tokenizer.nextToken());
    15231523            }
    15241524        }
    … …  
    15371537        StringTokenizer tokenizer = new StringTokenizer(command_str);
    15381538        if(tokenizer.countTokens() == 2) {
    1539         command_element = document.createElement(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT);
     1539        command_element = document.createElement(StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_ELEMENT);
    15401540        tokenizer.nextToken();
    15411541        //command_element.setAttribute(CONTENT_ATTRIBUTE, tokenizer.nextToken());
    … …  
    15431543        StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
    15441544        while(content_tokenizer.hasMoreTokens()) {
    1545             Element content_element = document.createElement(CONTENT_ELEMENT);
    1546             content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
     1545            Element content_element = document.createElement(StaticStrings.CONTENT_ELEMENT);
     1546            content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_tokenizer.nextToken());
    15471547            command_element.appendChild(content_element);
    15481548            content_element = null;
    … …  
    15641564        tokenizer.nextToken();
    15651565        if(tokenizer.hasMoreTokens()) {
    1566         command_element = document.createElement(SUBCOLLECTION_INDEXES_ELEMENT);
     1566        command_element = document.createElement(StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT);
    15671567        }
    15681568        while(tokenizer.hasMoreTokens()) {
    1569         Element subcollectionindex_element = document.createElement(INDEX_ELEMENT);
     1569        Element subcollectionindex_element = document.createElement(StaticStrings.INDEX_ELEMENT);
    15701570        //command_element.setAttribute(CONTENT_ATTRIBUTE, tokenizer.nextToken());
    15711571        String content_str = tokenizer.nextToken();
    15721572        StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER);
    15731573        while(content_tokenizer.hasMoreTokens()) {
    1574             Element content_element = document.createElement(CONTENT_ELEMENT);
    1575             content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken());
     1574            Element content_element = document.createElement(StaticStrings.CONTENT_ELEMENT);
     1575            content_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, content_tokenizer.nextToken());
    15761576            subcollectionindex_element.appendChild(content_element);
    15771577            content_element = null;
    … …  
    15941594        StringTokenizer tokenizer = new StringTokenizer(command_str);
    15951595        if(tokenizer.countTokens() >= 3) {
    1596         command_element = document.createElement(SUPERCOLLECTION_ELEMENT);
     1596        command_element = document.createElement(StaticStrings.SUPERCOLLECTION_ELEMENT);
    15971597        tokenizer.nextToken();
    15981598        while(tokenizer.hasMoreTokens()) {
    1599             Element collection_element = document.createElement(COLLECTION_ELEMENT);
    1600             collection_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken());
     1599            Element collection_element = document.createElement(StaticStrings.COLLECTION_ELEMENT);
     1600            collection_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, tokenizer.nextToken());
    16011601            command_element.appendChild(collection_element);
    16021602            collection_element = null;
    … …  
    16121612    static private String pluginToString(Element command_element, boolean show_extracted_namespace) {
    16131613    StringBuffer text = new StringBuffer();
    1614     if(!command_element.getAttribute(SEPARATOR_ATTRIBUTE).equals(TRUE_STR)) {
    1615         text.append(PLUGIN_STR);
    1616         text.append(TAB_CHARACTER);
    1617         text.append(TAB_CHARACTER);
    1618         text.append(command_element.getAttribute(TYPE_ATTRIBUTE));
     1614    if(!command_element.getAttribute(StaticStrings.SEPARATOR_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
     1615        text.append(StaticStrings.PLUGIN_STR);
     1616        text.append(StaticStrings.TAB_CHARACTER);
     1617        text.append(StaticStrings.TAB_CHARACTER);
     1618        text.append(command_element.getAttribute(StaticStrings.TYPE_ATTRIBUTE));
    16191619        // Retrieve, and output, the arguments
    1620         NodeList option_elements = command_element.getElementsByTagName(OPTION_ELEMENT);
     1620        NodeList option_elements = command_element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
    16211621        int option_elements_length = option_elements.getLength();
    16221622        if(option_elements_length > 0) {
    16231623        for(int j = 0; j < option_elements_length; j++) {
    16241624            Element option_element = (Element) option_elements.item(j);
    1625             if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
    1626             text.append(SPACE_CHARACTER);
     1625            if(option_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
     1626            text.append(StaticStrings.SPACE_CHARACTER);
    16271627            text.append(StaticStrings.MINUS_CHARACTER);
    1628             text.append(option_element.getAttribute(NAME_ATTRIBUTE));
     1628            text.append(option_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    16291629            String value_str = XMLTools.getValue(option_element);
    16301630            if(!show_extracted_namespace && value_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
    … …  
    16321632            }
    16331633            if(value_str.length() > 0) {
    1634                 text.append(SPACE_CHARACTER);
    1635                 if(value_str.indexOf(SPACE_CHARACTER) == -1) {
     1634                text.append(StaticStrings.SPACE_CHARACTER);
     1635                if(value_str.indexOf(StaticStrings.SPACE_CHARACTER) == -1) {
    16361636                text.append(value_str);
    16371637                }
    16381638                else {
    1639                 text.append(SPEECH_CHARACTER);
     1639                text.append(StaticStrings.SPEECH_CHARACTER);
    16401640                text.append(value_str);
    1641                 text.append(SPEECH_CHARACTER);
     1641                text.append(StaticStrings.SPEECH_CHARACTER);
    16421642                }
    16431643            }
    … …  
    16531653
    16541654    static private String searchtypeToString(Element command_element) {
    1655     if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) {
    1656         StringBuffer text = new StringBuffer(SEARCHTYPE_STR);
    1657         text.append(TAB_CHARACTER);
    1658         NodeList search_elements = command_element.getElementsByTagName(CONTENT_ELEMENT);
     1655    if(command_element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR)) {
     1656        StringBuffer text = new StringBuffer(StaticStrings.SEARCHTYPE_STR);
     1657        text.append(StaticStrings.TAB_CHARACTER);
     1658        NodeList search_elements = command_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
    16591659        int search_elements_length = search_elements.getLength();
    16601660        for(int i = 0; i < search_elements_length; i++) {
    16611661        Element search_element = (Element) search_elements.item(i);
    1662         text.append(search_element.getAttribute(NAME_ATTRIBUTE));
    1663         text.append(SPACE_CHARACTER);
     1662        text.append(search_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
     1663        text.append(StaticStrings.SPACE_CHARACTER);
    16641664        }
    16651665        return text.substring(0, text.length() - 1);
    … …  
    16711671
    16721672    static private String subcollectionToString(Element command_element, boolean show_extracted_namespace) {
    1673     StringBuffer text = new StringBuffer(SUBCOLLECTION_STR);
    1674     text.append(SPACE_CHARACTER);
    1675     text.append(command_element.getAttribute(NAME_ATTRIBUTE));
    1676     text.append(SPACE_CHARACTER);
    1677     text.append(TAB_CHARACTER);
    1678     text.append(SPEECH_CHARACTER);
    1679     if(command_element.getAttribute(TYPE_ATTRIBUTE).equals(EXCLUDE_STR)) {
    1680         text.append(EXCLAMATION_CHARACTER);
    1681     }
    1682     String content_str = command_element.getAttribute(CONTENT_ATTRIBUTE);
     1673    StringBuffer text = new StringBuffer(StaticStrings.SUBCOLLECTION_STR);
     1674    text.append(StaticStrings.SPACE_CHARACTER);
     1675    text.append(command_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
     1676    text.append(StaticStrings.SPACE_CHARACTER);
     1677    text.append(StaticStrings.TAB_CHARACTER);
     1678    text.append(StaticStrings.SPEECH_CHARACTER);
     1679    if(command_element.getAttribute(StaticStrings.TYPE_ATTRIBUTE).equals(StaticStrings.EXCLUDE_STR)) {
     1680        text.append(StaticStrings.EXCLAMATION_CHARACTER);
     1681    }
     1682    String content_str = command_element.getAttribute(StaticStrings.CONTENT_ATTRIBUTE);
    16831683    if(!show_extracted_namespace && content_str.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
    16841684        content_str = content_str.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
    … …  
    16861686    text.append(content_str);
    16871687    content_str = null;
    1688     text.append(SEPARATOR_CHARACTER);
     1688    text.append(StaticStrings.SEPARATOR_CHARACTER);
    16891689    text.append(XMLTools.getValue(command_element));
    1690     text.append(SEPARATOR_CHARACTER);
    1691     String options_str = command_element.getAttribute(OPTIONS_ATTRIBUTE);
     1690    text.append(StaticStrings.SEPARATOR_CHARACTER);
     1691    String options_str = command_element.getAttribute(StaticStrings.OPTIONS_ATTRIBUTE);
    16921692    if(options_str.length() > 0) {
    16931693        text.append(options_str);
    16941694    }
    16951695    options_str = null;
    1696     text.append(SPEECH_CHARACTER);
     1696    text.append(StaticStrings.SPEECH_CHARACTER);
    16971697    return text.toString();
    16981698    }
    16991699
    17001700    static private String subcollectionDefaultIndexToString(Element command_element) {
    1701     StringBuffer text = new StringBuffer(SUBCOLLECTION_DEFAULT_INDEX_STR);
    1702     text.append(TAB_CHARACTER);
    1703     NodeList content_elements = command_element.getElementsByTagName(CONTENT_ELEMENT);
     1701    StringBuffer text = new StringBuffer(StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_STR);
     1702    text.append(StaticStrings.TAB_CHARACTER);
     1703    NodeList content_elements = command_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
    17041704    int content_elements_length = content_elements.getLength();
    17051705    for(int j = 0; j < content_elements_length; j++) {
    17061706        Element content_element = (Element) content_elements.item(j);
    1707         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
     1707        text.append(content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    17081708        if(j < content_elements_length - 1) {
    17091709        text.append(StaticStrings.COMMA_CHARACTER);
    … …  
    17141714
    17151715    static private String subcollectionIndexesToString(Element command_element) {
    1716     StringBuffer text = new StringBuffer(SUBCOLLECTION_INDEX_STR);
    1717     text.append(TAB_CHARACTER);
     1716    StringBuffer text = new StringBuffer(StaticStrings.SUBCOLLECTION_INDEX_STR);
     1717    text.append(StaticStrings.TAB_CHARACTER);
    17181718    // Retrieve all of the subcollection index partitions
    1719     NodeList subcollectionindex_elements = command_element.getElementsByTagName(INDEX_ELEMENT);
     1719    NodeList subcollectionindex_elements = command_element.getElementsByTagName(StaticStrings.INDEX_ELEMENT);
    17201720    int subcollectionindex_elements_length = subcollectionindex_elements.getLength();
    17211721    if(subcollectionindex_elements_length == 0) {
    … …  
    17241724    for(int j = 0; j < subcollectionindex_elements_length; j++) {
    17251725        Element subcollectionindex_element = (Element) subcollectionindex_elements.item(j);
    1726         NodeList content_elements = subcollectionindex_element.getElementsByTagName(CONTENT_ELEMENT);
     1726        NodeList content_elements = subcollectionindex_element.getElementsByTagName(StaticStrings.CONTENT_ELEMENT);
    17271727        int content_elements_length = content_elements.getLength();
    17281728        for(int k = 0; k < content_elements_length; k++) {
    17291729        Element content_element = (Element) content_elements.item(k);
    1730         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
     1730        text.append(content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    17311731        if(k < content_elements_length - 1) {
    17321732            text.append(StaticStrings.COMMA_CHARACTER);
    … …  
    17341734        }
    17351735        if(j < subcollectionindex_elements_length - 1) {
    1736         text.append(SPACE_CHARACTER);
     1736        text.append(StaticStrings.SPACE_CHARACTER);
    17371737        }
    17381738    }
    … …  
    17411741
    17421742    static private String supercollectionToString(Element command_element) {
    1743     NodeList content_elements = command_element.getElementsByTagName(COLLECTION_ELEMENT);
     1743    NodeList content_elements = command_element.getElementsByTagName(StaticStrings.COLLECTION_ELEMENT);
    17441744    int content_elements_length = content_elements.getLength();
    17451745    if(content_elements_length > 1) {
    1746         StringBuffer text = new StringBuffer(SUPERCOLLECTION_STR);
    1747         text.append(TAB_CHARACTER);
     1746        StringBuffer text = new StringBuffer(StaticStrings.SUPERCOLLECTION_STR);
     1747        text.append(StaticStrings.TAB_CHARACTER);
    17481748        for(int j = 0; j < content_elements_length; j++) {
    17491749        Element content_element = (Element) content_elements.item(j);
    1750         text.append(content_element.getAttribute(NAME_ATTRIBUTE));
     1750        text.append(content_element.getAttribute(StaticStrings.NAME_ATTRIBUTE));
    17511751        if(j < content_elements_length - 1) {
    1752             text.append(SPACE_CHARACTER);
     1752            text.append(StaticStrings.SPACE_CHARACTER);
    17531753        }
    17541754        }

  • trunk/gli/src/org/greenstone/gatherer/util/StaticStrings.java

    r12726 r12814  
    157157    static final public String NAME_ELEMENT = "Name";
    158158    static final public String NEWLINE_CHARACTER = "\\";
    159     static final public String NEWLINE_ELEMENT = "NewLine";
    160159    static final public String NO_LOAD_ARGUMENT = "-no_load";
    161160    static final public String NO_WGET_STR = "NoWGet";
Note: See TracChangeset for help on using the changeset viewer.