source: trunk/gli/src/org/greenstone/gatherer/gems/MetadataSetManager.java@ 8270

/**
 *#########################################################################
 *
 * 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.util.*;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.tree.TreePath;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.util.Utility;
import org.apache.xerces.parsers.*;
import org.apache.xml.serialize.*;
import org.w3c.dom.*;
import org.xml.sax.*;

/** This class is responsible for managing all the metadata sets in the collection and for providing methods for manipulating the aforementioned sets contents. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3b
 */
public class MetadataSetManager {

    /** The character used to separate name space from metadata element. */
    static public char NS_SEP= '.';
    /** The character used to separate subfields from metadata element. */
    static public String SF_SEP= "#";

    /** The name of the hidden, or system, metadata set. */
    static final public String HIDDEN = "hidden";

    /** A mapping from metadata namespace to metadata set. */
    static private Hashtable mds_hashtable = new Hashtable();

    /** The profiler is responsible for remembering what actions a user has requested when importing metadata, so as to prevent the user needlessly re-entering this information for each import. */
    // public MSMProfiler profiler = null;


    /** Constructor. */
    public MetadataSetManager() {
    }


    public MetadataSet addSet(String namespace, String name) {
    MetadataSet mds = new MetadataSet(Utility.METADATA_SET_TEMPLATE);
    mds.setAttribute("creator", "The Greenstone Librarian Interface");
    // Calculate lastchanged to right now on this machine by this user
    String user_name = System.getProperty("user.name");
    String machine_name = Utility.getMachineName();
    mds.setAttribute("lastchanged", Utility.getDateString() + " - " + user_name + " on " + machine_name);
    // And the remaining attributes.
    //mds.setAttribute("name", name);
    mds.setAttribute("namespace", namespace);
    mds_hashtable.put(namespace, mds);
    // Add the name element.
    mds.setName(name);
    // fireSetChanged(mds);
    return mds;
    }

    /** Add a value tree to a given metadata element represented as a GValueModel
     * @param model The <strong>GValueTree</strong> model
     */
    public void addValueTree(GValueModel model) {
    ElementWrapper element = model.getElement();
    String namespace = element.getNamespace();
    MetadataSet mds = (MetadataSet) mds_hashtable.get(namespace);
    if(mds != null) {
        mds.addValueTree(element, model);
    }
    }


    /** Destructor. 
     */
    public void destroy() {
    mds_hashtable.clear();
    }


    /** Used to get all the (non-hidden) elements in this manager.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements() {
    return getElements(false);
    }

    public Vector getElements(boolean all) {
    return getElements(all, false);
    }

    /** Used to get all the elements in this manager.
     * @param all <i>true</i> if all elements, including hidden, should be returned.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements(boolean all, boolean force_extracted) {
    Vector all_elements = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet mds = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if((!mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && !mds.getNamespace().equals(HIDDEN)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && (Configuration.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) || force_extracted)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && mds.getNamespace().equals(HIDDEN) && all)) {
        NodeList set_elements = mds.getElements();
        ///ystem.err.println("The set " + mds + " has " + set_elements.getLength() + " elements.");
        for(int i = 0; i < set_elements.getLength(); i++) {
            Element raw_element = (Element)set_elements.item(i);
            ElementWrapper element = new ElementWrapper(raw_element);
            // For now we do not add subfield elements and their parents, just the subfields.
            NodeList child_elements = raw_element.getElementsByTagName("Element");
            if(child_elements.getLength() == 0) {
            all_elements.add(element);
            }
        }
        }
    }
    Collections.sort(all_elements);
    return all_elements;
    }

    /** Retrieve a metadata element by its index.
     * @param index The specified index as an int.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(int index) {
    Vector elements = getElements(false);
    ElementWrapper result = null;
    if(0 <= index && index < elements.size()) {
        result = (ElementWrapper) elements.get(index);
    }
    return result;
    }
    /** Retrieve a metadata element by looking at the current metadata element. Note that this 'index' element may now be disconnected from the DOM model, so we have to reload the target element by the string method.
     * @param element The possibly out-of-data MetadataElement.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(ElementWrapper element) {
    return getElement(element.toString());
    }
    /** Retrieve a metadata element by its fully qualified name.
     * @param name The elements name as a String.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(String name) {
    return getElement(name, false);
    }

    public ElementWrapper getElement(String name, boolean perfect) {
    ///ystem.err.println("Retrieve element " + name);
    if(name == null) {
        ///ystem.err.println("No name!");
        return null;
    }
    ElementWrapper result = null;
    MetadataSet set = null;
    String element = null;
    // First we seperate off what set it is in, where we have '<set><namespace_separator><element>'.
    if(name.indexOf(NS_SEP) != -1) {
        String namespace = name.substring(0, name.indexOf(NS_SEP));
        // Retrieve the correct set if possible.
        set = (MetadataSet)mds_hashtable.get(namespace);
        namespace = null;
        // Now retrieve the element name.
        element = name.substring(name.indexOf(NS_SEP) + 1);
    }
    // If we are looking for a perfect match, we can assume that no namespace means extracted metadata
    else if(!perfect) {
        // No namespace so assume that its extracted metadata.
        set = (MetadataSet)mds_hashtable.get(Utility.EXTRACTED_METADATA_NAMESPACE);
        element = name;
    }
    if(set != null) {
        // Now we have a set we are ready to locate the requested element. Break the remaining element name down by the subfield separator, attempting to retrieve the element indicated by each step.
        if(element.indexOf(SF_SEP) != -1) {
        StringTokenizer tokenizer = new StringTokenizer(element, SF_SEP);
        // Has to be at least two tokens
        if(tokenizer.countTokens() >= 2) {
            Element current_element = set.getElement(tokenizer.nextToken());
            while(current_element != null && tokenizer.hasMoreTokens()) {
            current_element = set.getElement(current_element, tokenizer.nextToken());
            }
            if(current_element != null) {
            result = new ElementWrapper(current_element);
            current_element = null;
            }
        }
        tokenizer = null;
        }
        // No subfields - much easier.
        if(result == null) {
        ///ystem.err.print("Trying to match element " + element +"?");
        Element temp = set.getElement(element);
        if(temp != null) {
            result = new ElementWrapper(temp);
        }
        temp = null;
        }
        set = null;
    }
    element = null;
    return result;
    }
    /** Retrieve a certain named element from a certain named set.
     * @param set The metadata set whose element you want.
     * @param name The name of the element.
     * @return An ElementWrapper around the requested element, or null if no such set or element.
     */
    public ElementWrapper getElement(String set, String name) {
    if(mds_hashtable.containsKey(set)) {
        MetadataSet temp = (MetadataSet)mds_hashtable.get(set);
        return new ElementWrapper(temp.getElement(name));
    }
    return null;
    }

    /** Retrieve the named metadata set.
     * @param name The sets name as a String.
     * @return The MetadataSet as named, or null if no such set.
     */
    public MetadataSet getSet(String name) {
    if(mds_hashtable.containsKey(name)) {
        return (MetadataSet) mds_hashtable.get(name);
    }
//  else if(name.equals(HIDDEN)) {
//      return createHidden();
//  }
    return null;
    }

    /** Method to retrieve all of the metadata sets loaded in this collection. 
     * @return A Vector of metadata sets.
     */
    public Vector getSets() {
    return getSets(true);
    }

    public Vector getSets(boolean include_greenstone_extracted) {
    Vector result = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet set = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if(!set.getNamespace().equals(HIDDEN) && (include_greenstone_extracted || !set.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE))) {
        result.add(set);
        }
    }
    return result;
    }


    /** Get the value tree that matches the given element.
     * @param element The ElementWrapper representing the element.
     * @return The GValueModel representing the value tree or null.
     */
    public GValueModel getValueTree(ElementWrapper element) {
    GValueModel value_tree = null;
    if(element != null) {
        String namespace = element.getNamespace();
        if(namespace.length() > 0) {
        MetadataSet mds = (MetadataSet) mds_hashtable.get(namespace);
        if(mds != null) {
            value_tree = mds.getValueTree(element);
        }
        }
    }
    return value_tree;
    }


    public MetadataSet loadMetadataSet(File metadata_set_file)
    {
    System.err.println("Loading metadata set file " + metadata_set_file + "...");
    MetadataSet metadata_set = new MetadataSet(metadata_set_file);
    mds_hashtable.put(metadata_set.getNamespace(), metadata_set);
    return metadata_set;
    }


    public void removeElement(ElementWrapper element) {
    // Retrieve the metadata set this element belongs to.
    String namespace = element.getNamespace();
    MetadataSet set = (MetadataSet) mds_hashtable.get(namespace);
    if(set != null) {
        // Bugger. Get the old name -before- we remove the element from the set.
        String old_name = element.toString();
        // Remove the element.
        set.removeElement(element.getElement());
    }
    else {
        ///ystem.err.println("no such set " + namespace);
    }
    // No such set. No such element.
    }


    public void removeSet(MetadataSet set) {
    mds_hashtable.remove(set.getNamespace());
    // fireSetChanged(set);
    }
}