source: trunk/gli/src/org/greenstone/gatherer/gems/MetadataSet.java@ 12306

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.gems;

import java.io.*;
import java.net.*;
import java.util.*;
import org.apache.xerces.dom.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.XMLTools;
import org.w3c.dom.*;
/** An semi-data class to hold details about a loaded metadata set, it also provides some methods to manipulating the data within. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3b
 */
public class MetadataSet {
    /** The <Strong>Document</strong> of the DOM model. */
    private Document document = null;
    /** The document <strong>Element</strong> of the DOM model. */
    private Element  root     = null;
    /** The <strong>File</strong> this metadata set was loaded from. */
    public String old_filename = null;
    private File     file     = null;
    /** The list of metadata elements which are, of course, children of the root node. */
    private ArrayList elements = null;
    
    // the nmae of the collection if this set is collection-specific
    private String collection = null;
    //set_changed is check in msm(metadatasetmanager).save() and if this is true then we save
    //the collection, otherwise we leave it as is
    private boolean setChanged = false;
    private String current_language_code;
    /** The description of this metadata set. Cached as it takes more computation time. */
    private String description = null;
    /** The name of this metadata set. Cached as it takes more computation time. */
    private String name = null;
    /** An element of the tree pruning filter enumeration, that indicates all nodes in the tree should be retained. */
    static final int ALL_VALUES    = 1;
    /** An element of the tree pruning filter enumeration, that indicates only metadata Subject nodes or higher should remain after pruning. */
    static final int SUBJECTS_ONLY = 2;
    /** An element of the tree pruning filter enumeration, that indicates no value nodes i.e. the entire AssignedValues subtree, should remain after pruning. */
    static final int NO_VALUES     = 3;

    public MetadataSet(String metadata_template) {
    
    this.file = new File(metadata_template);
    this.document = XMLTools.parseXMLFile(metadata_template, true);

    init(true); // use class loader
    }

    /** Constructor.
     * @param file The file the metadata set should be loaded from. 
     */
    public MetadataSet(File file) {
    this.file = file;
    this.document = XMLTools.parseXMLFile(file);

    init(false); // don't use class loader
    }

    /** Copy constructor. 
     * @param original The original metadata set to copy from.
     */
    public MetadataSet(MetadataSet original) {
    // We have to create a new document.
    document = new DocumentImpl(original.getDocument().getDoctype());
    root = (Element) document.importNode(original.getDocument().getDocumentElement(), true);
    document.appendChild(root);
    elements = XMLTools.getChildElementsByTagName(root, "Element");
    //elements = root.getElementsByTagName("Element");
    file = original.getFile();
    }
  
    public boolean getSetChanged() {
        
        return setChanged;    
    }
    public void setSetChanged(boolean val) {
         
        setChanged = val;
    }


    public void setCollection(String coll) {
    collection = coll;

    }
    /** Add a mds level attribute.
     * @param name The name of the attribute to add as a <Strong>String</strong>.
     * @param value The value as a <strong>String</strong>.
     */
    public void addAttribute(String name, String value) {
    root.setAttribute(name, value);
    }


    /** Add a new default metadata element with the given name to this metadata set.
    This method also handles the addtion of 'subelements'
     * @param name The name of this element as a <strong>String</strong>.
     * @param parent The parent element as an <strong>GEMSNode</strong>. If null, the parent is the metadataset root.
     * @return An <strong>ElementWrapper</strong> around the newly created element or null if the element was not created.
     */
    public ElementWrapper addElement(String name, String language, GEMSNode parent)
    {
    Element parent_element = null;

    //The element that we are creating
    Element element = document.createElementNS("","Element");
    element.setAttribute("name",name);

    //Add identifier attribute. This handles if we use the new or old language identification
    MSMUtils.addElementAttribute(element, "identifier", language, name);
    
    if(parent == null) //A element
        {
        parent_element = root;
        elements.add(element); //Add the new element to the list of 'em
        }
    else //A subelement!
        {
        //Add the new subelement to the list of 'em
        parent.getElement().addSubelementToList(element);
        parent_element = parent.getElement().getElement(); //get the parent as an Element
        }

    parent_element.appendChild(element);

    return new ElementWrapper(element);
    }


    public int compare(Element e1, Element e2) {
    int result = 0;
    // Check that they're not the same element.
    if(e1 != e2) {
        int index_e1 = -1;
        int index_e2 = -1;
        // Locate the indexes for each element.
        for(int i = 0; i < elements.size(); i++) {
        Node element = (Node)elements.get(i);
        if(element == e1) {
            index_e1 = i;
        }
        if(element == e2) {
            index_e2 = i;
        }
        }
        if(index_e1 < index_e2) {
        result = -1;
        }
        else {
        result = 1;
        }
    }
    return result;
    }

    /** A method to determine if this metadata set contains an element with a certain name (case sensitive).
     * @param name A <strong>String</strong> which is the name of the element whose presence we are checking.
     * @return A <i>boolean</i> which is <i>true</i> if the named element exists, <i>false</i> otherwise.
     */
    public boolean containsElement(String name) {
    for(int i = 0; i < elements.size(); i++) {
        Element sibling = (Element) elements.get(i);
        String sibling_name = sibling.getAttribute("name");
        if(sibling_name.equals(name)) {
        return true;
        }
    }
    return false;
    }

    public NamedNodeMap getAttributes() {
    return root.getAttributes();
    }

    /** Method to retrieve the contact address of the metadata set creator.
     * @return A <strong>String</strong> containing the address. 
     */
    /* private String getContact() {
    return root.getAttribute("contact");
    } */
    /** Method to retrieve the name of the creator of this metadata set. 
     * @return A <strong>String</strong> containing the name.
     */
    public String getCreator() {
    return root.getAttribute("creator");
    }
    /** Method to retrieve the description of this metadata set. Note that this is language specific, so we determine the desired language from the Dictionary. If no such entry exists, first try returning the english version and failing that the first description found.
     * @return The description as a <strong>String</strong>.
     */
    public String getDescription() {
    if(current_language_code != null && !Configuration.getLanguage().equals(current_language_code)) {
        description = null;
    }
    if(description == null) {
        description = getAttribute(StaticStrings.DESCRIPTION_ELEMENT, Dictionary.get("GEMS.No_Description"));
    }
    return description;
    }

    /** Method to retrieve the <strong>Document</strong> associated with this metadata set.
     * @return The <strong>Document</strong> representing this metadata set.
     */
    public Document getDocument() {
    return document;
    }
    /** Method to retrieve the metadata element indicated by an index.
     * @param index An <i>int</i> specifying the required element.
     * @return The <strong>Element</strong> at the index.
     */
    public Element getElement(int index) {
    return (Element)elements.get(index);
    }
    /** This method is used to acquire a reference to the element which matches the given metadata. Note that this is not the same as <i>metadata.getElement()</i> as the reference returned by it may now be obsolete.
     * @param metadata A <strong>Metadata</strong> object representing an element and value assignment.
     * @return A 'live' reference to an <strong>Element</strong> which is the same as that referenced by the given metadata, or <i>null</i> if there is no such element.
     */
//     public Element getElement(Metadata metadata) {
//  return metadata.getElement().getElement();
//     }
    /** This method is used to acquire a reference to the element which has the name specified. Note that this is not the same as <i>metadata.getElement()</i> as the reference returned by it may now be obsolete.
     * @param name A <strong>String</strong> stating the desired objects name.
     * @return A 'live' reference to an <strong>Element</strong> which is the same as that referenced by the given metadata, or <i>null</i> if there is no such element.
     */
    public Element getElement(String name) {
    // Strip any namespace.
    while(name.indexOf(".") != -1 && !name.equals(".")) {
        name = name.substring(name.indexOf(".") + 1);
    }
    ///ystem.err.println("Get element named " + name);
    for(int i = 0; i < elements.size(); i++) {
        Element element = (Element) elements.get(i);
        ///ystem.err.println("Compare to: " + element.getAttribute("name"));
        if(element.getAttribute("name").equals(name)) {
        return element;
        }
    }
    return null;
    }

    public Element getElement(Element parent_element, String name) {
    DebugStream.println("Get element named " + name + " from " + parent_element.getAttribute("name"));
    ArrayList elements = XMLTools.getChildElementsByTagName(parent_element, "Element");
    for(int i = 0; i < elements.size(); i++) {
        Element element = (Element) elements.get(i);
        if(element.getAttribute("name").equals(name) && element.getParentNode() == parent_element) {
        elements = null;
        return element;
        }
    }
    elements = null;
    return null;
    }
    /** Method to acquire a list of all the elements in this metadata set. 
     * @return A <strong>NodeList</strong> containing all of this sets elements.
     */
    public ArrayList getElements() {
    return elements;
    }

    /** Method to retrieve a list of all the elements in this metadata set, sorted.
     * @return A <strong>Vector</strong> containing all of the elements of this sets, sorted.
     */
//     public Vector getElementsSorted() {
//  Vector elements_list = new Vector();
//  for (int i = 0; i < elements.size(); i++) {
//      elements_list.add(new ElementWrapper((Element) elements.get(i)));
//  }
//  Collections.sort(elements_list, MSMUtils.METADATA_COMPARATOR);
//  return elements_list;
//     }

    /** Method to retrieve the original file this metadata set was created from.
     * @return A <strong>File</strong>.
     */
    public File getFile() {
    return file;
    }
    /** Get the last changed attribute.
     * @return Last changed as a <strong>String</strong>.
     */
    public String getLastChanged() {
    return root.getAttribute("lastchanged");
    }

    /** Method to get this metadata sets name. Note that this is language specific, so we determine the desired language from the Dictionary.
    If no such entry exists, first try returning the english version and failing that the first name found.
     * @return A <strong>String</strong> which contains its name.
     */
    public String getName() {
    if(current_language_code != null && !Configuration.getLanguage().equals(current_language_code)) {
       // name = null;
            return null;
    }
    if(name == null) {
            
        //name = getAttribute(StaticStrings.NAME_ELEMENT, Dictionary.get("MSM.No_Name"));
       return getAttribute(StaticStrings.NAME_ELEMENT, Dictionary.get("GEMS.No_Name"));
    
        }
     
    return name;
    }
    /** Method to retrieve this metadata sets namespace.
     * @return The namespace as a <strong>String</strong>.
     */
    public String getNamespace() {
    return root.getAttribute("namespace");
    }

    /**
       Method to change this metadata set's namespace
       @param: The new namespace as a <strong>String</strong>
     */
    public void setNamespace(String new_namespace)
    {
    root.setAttribute("namespace", new_namespace);
    }

    /** Method to retrieve the root element, i.e. the Document Element, of the DOM model behind this metadata set.
     * @return An <strong>Element</strong> which is at the root of the modal.
     */ 
    public Element getRoot() {
    return root;
    }

    /** Remove a mds level attribute.
     * @param name The name of the attribute to remove.
     */
    public void removeAttribute(String name) {
    root.removeAttribute(name);
    }

    /** Method to remove the given element from this metadata set.
     * @param element The <strong>Element</strong> to be removed.
     * @param parent The parent element (wrapped, so can access its subelement list), as an <strong>ElementWrapper</strong>. If null, the parent is root.
     */
    public void removeElement(Element element, ElementWrapper parent) {
    try {
        ElementWrapper element_wrapped = new ElementWrapper(element);

        if(parent == null)
        {
            elements.remove(element);
            root.removeChild(element);
        }
        else
        {
            parent.removeSubelementFromList(element);
            parent.getElement().removeChild(element);
        }
        
    } catch(Exception DOMException) { //The element does not exist!
        System.err.println("Exception: '"+ DOMException + "' occured. Cannot remove element because it does not exist.");
    }
    }

 /**
       Rename the metadata element.
       @param oldElement An <strong>Element</strong> we wish to rename
       @param newName A <strong>String</strong> which contains the new name of the element.
       @return An <strong>ElementWrapper</strong> around the newly named element
    */
    public void renameElement(Element oldElement, String newName)
    {
    oldElement.setAttribute("name", newName); //Rename the element
    }
    

    /** Set one of the mds level attributes.
     * @param name The attribute to change.
     * @param value its new value.
     */
    public void setAttribute(String name, String value) {
    root.setAttribute(name, value);
    }
    /** Once the metadata set has been saved to a different location, this is used to update the file parameter.
     * @param file The new location of this metadata set <strong>File</strong>.
     */
    public void setFile(File file) {
    this.file = file;
    }

    public void setName(String name) {
    // Retrieve the name element. We look for the first english one.
    boolean found_it = false;
    Element name_element = null;
    Element metadataset_element = document.getDocumentElement();
    NodeList name_elements = metadataset_element.getElementsByTagName(StaticStrings.NAME_ELEMENT);
    for(int i = 0; (i < name_elements.getLength() && !found_it); i++) {
        Element possible_name_element = (Element) name_elements.item(i);
        if(possible_name_element.getAttribute(StaticStrings.LANGUAGE_ATTRIBUTE).equals("en")) {
        // Found it.
        found_it = true;
        name_element = possible_name_element;
        //System.out.println("Found english name: " + name_element); //debug
        }
    }
    // If there is none add one. Note that we can only add english metadata sets. Although others can edit them to add further names as necessary.
    if(name_element == null) {
        name_element = document.createElement(StaticStrings.NAME_ELEMENT);
        name_element.setAttribute(StaticStrings.LANGUAGE_ATTRIBUTE, "en");
        metadataset_element.insertBefore(name_element, metadataset_element.getFirstChild());
    }
    // Replace the text node
    while(name_element.hasChildNodes()) {
        name_element.removeChild(name_element.getFirstChild());
    }
    name_element.appendChild(document.createTextNode(name));
    }

    /** Method to determine the number of elements in this set.
     * @return An <i>int</i> specifying the element count.
     */
    public int size() {
    return elements.size();
    }
    /** Method to translate this class into a meaningful string, which in this case is the metadata sets name.
     * @return The metadata sets name as a <strong>String</strong>.
     */
    public String toString() {
       
    String name = getName();
    // If there is no given name, then use the namespace as there is garaunteed to be one of them.
    if(name == null || name.length() == 0) {
        name = root.getAttribute("namespace");
    }
    // Append namespace
    String namespace = root.getAttribute("namespace");
    if(namespace == null || namespace.equals("")) {
        namespace = MetadataSetManager.EXTRACTED_METADATA_NAMESPACE;
    }
    name = name + " (" + namespace + ")";
    if (collection == null) 
        return name;
    return "["+collection+"] "+name;
    }

    /** This method retrieves the required attribute from the Metadata Set, typically it's name or it's description. Note that this method is language dependent, and moreover supports both legacy metadata sets and the new sets optimized for multiple languages.
     * @param element_name the name of the type of element the required information is in as a String
     * @param default_string the value to return if no such element is found also as a String
     * @see org.greenstone.gatherer.Configuration#getLanguage()
     * @see org.greenstone.gatherer.msm.MSMUtils#getValue(Node)
     * @see org.greenstone.gatherer.util.StaticStrings#CODE_ATTRIBUTE
     * @see org.greenstone.gatherer.util.StaticStrings#SETLANGUAGE_ELEMENT
     */
    private String getAttribute(String element_name, String default_string) {
    String result = null;

    // Determine the language code.
    current_language_code = Configuration.getLanguage();

    ///ystem.err.println("Searching for the " + element_name + " in " + current_language_code);

    // New Metadata Set Format makes use of deferred-node-expansion to save memory - rather than create nodes for a name and description in each language, nodes which have potentially huge strings, we instead create simplier SETLANGUAGE nodes, and then only expand the one in the desired language. Of course if a user happens to change to every available language slightly more memory will be used than in the old method. For instance consider the DLS with 25 languages, each with a name node of 50 bytes and an descriptions of 500. Thus old style > 13750 bytes while new style < 600.
    NodeList set_language_elements = document.getElementsByTagName(StaticStrings.SETLANGUAGE_ELEMENT);
    for(int b = 0; b < set_language_elements.getLength(); b++) {
        Element set_language_element = (Element) set_language_elements.item(b);
        String code = set_language_element.getAttribute(StaticStrings.CODE_ATTRIBUTE).toLowerCase();
        if(code.equals(current_language_code)) {
        NodeList specific_elements = set_language_element.getElementsByTagName(element_name);
        if(specific_elements.getLength() > 0) {
            Element specific_element = (Element) specific_elements.item(0);
            result = MSMUtils.getValue(specific_element);
            specific_element = null;
        }
        specific_elements = null;
        }
        code = null;
        set_language_element = null;
    }
    set_language_elements = null;
    // And we may be all done
    if(result != null) {
        return result;
    }

    // Failing that we move on to an older style search - start by recovering all Name elements
    NodeList possible_elements = document.getElementsByTagName(element_name);
    // Iterate through the available names looking for the appropriate one. Also make note of the first name, then overwrite it with any english one.
    boolean found = false;
    for(int i = 0; !found && i < possible_elements.getLength(); i++) {
        Element possible_element = (Element) possible_elements.item(i);
        String possible_element_code = possible_element.getAttribute("language").toLowerCase();
        if(possible_element_code.equals(current_language_code) || name == null) {
        result = MSMUtils.getValue(possible_element);
        found = true;
        }
        possible_element_code = null;
        possible_element = null;
    }
    possible_elements = null;
    // Failing all that set an error message
    if(result == null) {
        result = default_string;
    }
    return result;
    }

    private void init(boolean use_classloader) {

    if(this.document != null) {
        this.root = document.getDocumentElement();
        this.elements = XMLTools.getChildElementsByTagName(root, "Element");
    }
    else {
        DebugStream.println("Error! Missing mds file: " + file.getAbsolutePath());
    }
    }
}