source: trunk/gli/src/org/greenstone/gatherer/msm/MetadataXMLFile.java@ 8236

/**
 *#########################################################################
 *
 * 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.
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * 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.
 *
 * 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.
 *
 * 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.msm;

import java.io.*;
import java.util.*;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.msm.MetadataXMLFileManager;
import org.greenstone.gatherer.msm.MSMUtils;
import org.greenstone.gatherer.util.Codec;
import org.greenstone.gatherer.util.HashMap3D;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.valuetree.GValueModel;
import org.greenstone.gatherer.valuetree.GValueNode;
import org.w3c.dom.*;

/** This class wraps around a DOM Document providing methods for accessing the data within. In this case the DOM represents a Greenstone Directory metadata file. It provides the necessary functionality to create a new metadata.xml file.
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3b
 */
public class MetadataXMLFile {
    /** Record if the document this object is based on is up to date. */
    private boolean up_to_date = true;
    /** The document this class sources its data from. */
    private Document base_document;
    static final private String ACCUMULATE = "accumulate";
    /** The pattern to match when searching for directory level assignments. */
    static final private String DIRECTORY_FILENAME = ".*";
    static final private String DESCRIPTION_ELEMENT = "Description";
    static final public String FILENAME_ELEMENT = "FileName";
    static final public String FILESET_ELEMENT = "FileSet";
    static final private String HVALUE_ATTRIBUTE = "hvalue";
    static final private String MODE_ATTRIBUTE = "mode";
    static final private String OVERWRITE = "overwrite";
    static final private String[] ALL_METADATA_TYPES = {StaticStrings.METADATA_ELEMENT, StaticStrings.EXTRACTED_METADATA_ELEMENT};

    /** Constructor which creates a brand new metadata.xml document. */
    public MetadataXMLFile() {
    // Create new document. We do this by loading a copy of the template. */
    this.base_document = Utility.parse(Utility.GREENSTONEDIRECTORYMETADATA_TEMPLATE, true);
    }

    /** Constructor which parses an existing metadata.xml document. */
    public MetadataXMLFile(File file) {
    try {
        this.base_document = Utility.parse(file.getAbsolutePath(), false);
    }
    catch (Exception error) {
        // Poorly formed, or completely invalid metadata.xml file!
    }
    }

    /** Constructor which wraps around an existing metadata.xml document. */
    public MetadataXMLFile(Document base_document) {
    this.base_document = base_document;
    }

    /** Add this metadata to the named file. There is one tricky thing to consider. Whenever a metadata entry is added it is taken to be accumulating except if it is the first added, in which case it overwrites! Actually this gets worse, as we could have been told to append this metadata to a document which already inherits metadata. Thus we need a new argument to determine whether this add was triggered by an append or a replace. */
    public void addMetadata(String filename, Metadata metadata, boolean force_accumulate)
    {
    ///ystem.err.println("Add '" + metadata + "' to " + (filename != null ? filename : "directory."));
    try {
        // Retrieve the document element
        Element gdm_element = base_document.getDocumentElement();

        // Find the fileset element for the filename
        Element fileset_element = findFileSetElementForFile(gdm_element, filename);

        // If there is no existing fileset, then create one
        if (fileset_element == null) {
        fileset_element = base_document.createElement(FILESET_ELEMENT);
        Element filename_element = base_document.createElement(FILENAME_ELEMENT);
        Element description_element = base_document.createElement(DESCRIPTION_ELEMENT);
        fileset_element.appendChild(filename_element);
        fileset_element.appendChild(description_element);
        Text filename_text = null;
        // If the filename is null then we add a directory metadata set as gdm_element's first child
        if (filename == null) {
            filename_text = base_document.createTextNode(DIRECTORY_FILENAME);
            if (gdm_element.hasChildNodes()) {
            gdm_element.insertBefore(fileset_element, gdm_element.getFirstChild());
            }
            else {
            gdm_element.appendChild(fileset_element);
            }
        }
        // Otherwise we append the new fileset to gdm_element's children
        else {
            ///ystem.err.println("New fileset for " + filename);
            filename = Codec.transform(filename, Codec.TEXT_TO_REGEXP);
            ///ystem.err.println("After transform: " + filename);
            filename_text = base_document.createTextNode(filename);
            gdm_element.appendChild(fileset_element);
        }
        filename_element.appendChild(filename_text);
        filename_text = null;
        description_element = null;
        filename_element = null;
        }
        // Now, finally, we can add the metadata.
        Element metadata_element = null;
        String name = metadata.getElement().getName();
        // If this is extracted metadata, we use a special element name that won't be recognized by greenstone
        String current_metadata_type = StaticStrings.METADATA_ELEMENT;
        if(name.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
        current_metadata_type = StaticStrings.EXTRACTED_METADATA_ELEMENT;
        name = name.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
        }
        
        metadata_element = base_document.createElement(current_metadata_type);
        metadata_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name);

        // To determine if this metadata entry should overwrite or accumulate we check if there are other entries with the same element in this fileset.
        // also we are checking for the existence of exactly the same metadata cos sometimes we can be asked to add the same metadata twice.
        boolean will_accumulate = false;
        // only look through Metadata or XMetadata depending on which type we are trying to add
        NodeList sibling_metadata_elements = fileset_element.getElementsByTagName(current_metadata_type);
        for (int i=0; i<sibling_metadata_elements.getLength(); i++) {
        Element sib_meta = (Element) sibling_metadata_elements.item(i);
        if(name.equals(sib_meta.getAttribute(StaticStrings.NAME_ATTRIBUTE))) {
            // found one with the same name - the new metadata will accumulate
            will_accumulate = true;
            // check for the same value
            if(metadata.getAbsoluteValue().equals(MSMUtils.getValue(sib_meta))) {
            return;
            }
            
        }
        sib_meta = null;
        }
        sibling_metadata_elements = null;
        
        if(will_accumulate || force_accumulate) { //mode.equals(ACCUMULATE)) {
        metadata_element.setAttribute(MODE_ATTRIBUTE, ACCUMULATE);
        }
        // As we can't possibly store all the metadata in memory, nor can we ensure that the indexes written to file remain the same until the new time we look at this file, and to avoid having to open a rewrite every collection document whenever any value tree changes, I'm writing the value out as a full path string
        // getAbsoluteValue now does return the full path
        String node_value = metadata.getAbsoluteValue();
        //GValueModel model = Gatherer.c_man.getCollection().msm.getValueTree(metadata.getElement());
        //String node_value = null;
        //if(model != null && model.isHierarchy()) {
        //node_value = /odec.transform(metadata.getValueNode().getFullPath(false), /odec.TEXT_TO_DOM);
        //node_value = metadata.getValueNode().getFullPath(false);
        //}
        //else {
        //node_value = metadata.getAbsoluteValue();
        // }
        ///ystem.err.println("Creating node in MetadataXMLFile: '" + node_value + "'");
        metadata_element.appendChild(base_document.createTextNode(node_value));
        // Retrieve the first description element for this fileset (there should only be one, but I'll play it safe).
        NodeList description_elements = fileset_element.getElementsByTagName("Description");
        Element description_element = (Element) description_elements.item(0);
        description_element.appendChild(metadata_element);
        description_element = null;
        metadata_element = null;
        fileset_element = null;
        gdm_element = null;
        up_to_date = false;
    }
    catch (Exception error) {
        DebugStream.printStackTrace(error);
    }
    }

    /** this is used to 'purge' the metadata - I've taken the purge code out of getMetadata and put it in to here, cos its only called from one place and we dont want to retrieve the metadata, just update it */
    public void cleanUpMetadataRefs() {
    //DebugStream.println("clean up metadata refs!");

    String file_relative_path = "";
    try {
        // Retrieve the document element.
        Element directorymetadata_element = base_document.getDocumentElement();
        // Iterate through all the metadata
        // We have to do this for each type of metadata - do we need it for extracted metadata - will this only affect hierarchical metadata in which case only need to do normal metadata ?
        for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
        NodeList metadata_elements = directorymetadata_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
        for(int l = 0; l < metadata_elements.getLength(); l++) {
            Element metadata_element = (Element) metadata_elements.item(l);
            String raw_element = metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
            String raw_value = MSMUtils.getValue(metadata_element);
            // 
            // ***** LEGACY SUPPORT *****
            // If this raw_value contains a '\' character, but no '\\', '[' or ']' characters, then replace the '\' with a '\\'
            if(raw_value.indexOf(StaticStrings.ESCAPE_STR) != -1) {
            DebugStream.println("Detected Legacy Path: " + raw_value);
            raw_value = raw_value.replaceAll(StaticStrings.ESCAPE_PATTERN, StaticStrings.PIPE_STR);
            MSMUtils.setValue(metadata_element, raw_value);
            }

            ElementWrapper element = Gatherer.c_man.getCollection().msm.getElement(raw_element);
            if (element != null) {
            GValueNode value = Metadata.getDefaultValueNode(element, raw_value);
            String current_value = value.getFullPath(false);
            if(!raw_value.equals(current_value)) {
                // set the new value
                MSMUtils.setValue(metadata_element, current_value);
            }
            value = null;
            current_value = null;
            }
            element = null;
            metadata_element = null;
            raw_element = null;
            raw_value = null;
        } // for each metadata element
        metadata_elements = null;
        } // for each metadata type
    } catch (Exception exception) {
        DebugStream.printStackTrace(exception);
    }
    }


    private Element findFileSetElementForFile(Element gdm_element, String filename)
    {
    // Iterate through the filesets looking for one that matches the given filename
    NodeList fileset_elements = gdm_element.getElementsByTagName(FILESET_ELEMENT);
    for (int i = 0; i < fileset_elements.getLength(); i++) {
        Element fileset_element = (Element) fileset_elements.item(i);

        NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
        for (int j = 0; j < filename_elements.getLength(); j++) {
        Element filename_element = (Element) filename_elements.item(j);
        String filename_pattern = MSMUtils.getValue(filename_element);

        // System.err.println("Checking " + filename + " against " + filename_pattern);

        // Is this a file match?
        if (filename != null && filename.matches(filename_pattern) &&
            !filename_pattern.equals(DIRECTORY_FILENAME)) {
            // System.err.println("Existing file fileset!");
            return fileset_element;
        }
        // Is this a folder match?
        else if (filename == null && filename_pattern.equals(DIRECTORY_FILENAME)) {
            // System.err.println("Existing folder fileset!");
            return fileset_element;
        }
        }
    }

    // No match found
    return null;
    }


    /** Retrieve the document this class is wrapping. */
    public Document getDocument() {
    return base_document;
    }

    /** Retrieve the metadata associated with the given filename. Keep track of what metadata should be overwritten and what should be accumulated. Also make note of the source file, and remove the metadata if required. */
    // !! Michael has written a much nicer version of this function !!
    // Kath has cleaned up this version a bit
    public ArrayList getMetadata(String filename, boolean remove, ArrayList metadatum_so_far, File file, boolean append_folder_level) {
    DebugStream.println("Get metadata for " + filename);
    DebugStream.println("remove = " + remove + ", metadata_so_far = " + (metadatum_so_far != null ? String.valueOf(metadatum_so_far.size()) : "null") + ", file = " + file + ", append_folder_level = " + append_folder_level);

    // Determine the file's path relative to the location of the metadata.xml file
    String file_relative_path = ((filename != null) ? filename : "");
    if (file_relative_path.endsWith(File.separator)) {
        file_relative_path = file_relative_path.substring(0, file_relative_path.length() - File.separator.length());
    }

    ArrayList metadatum = null;
    ArrayList queued_for_removal = new ArrayList();
    if(metadatum_so_far == null) {
        metadatum = new ArrayList();
    }
    else {
        metadatum = metadatum_so_far;
    }
    try {
        // Retrieve the document element.
        Element directorymetadata_element = base_document.getDocumentElement();
        // Iterate through the filesets, checking the FileName child element against the target file's name using regular expression matching.
        NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
        for(int i = 0; i < fileset_elements.getLength(); i++) {
        Element fileset_element = (Element) fileset_elements.item(i);
        boolean fileset_matches = false;
        // look through the filename elements of this and see if we have a match
        NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
        String filename_text = "";
        for(int j = 0; j < filename_elements.getLength(); j++) {
            Element filename_element = (Element) filename_elements.item(j);
            filename_text = MSMUtils.getValue(filename_element);
            if((filename != null && (filename.matches(filename_text) || (append_folder_level && filename.indexOf(File.separator) != -1 && filename_text.equals(filename.substring(0, filename.indexOf(File.separator)))))) || ((filename == null || append_folder_level) && filename_text.equals(DIRECTORY_FILENAME))) {
            fileset_matches = true;
            filename_element = null;
            break;
            }
            filename_element = null;
        }
        
        if (!fileset_matches) {
            // go to teh next fileset
            fileset_element = null;
            continue;
        }
        // If this fileset matches add all of the metadata found in the fileset, remembering to abide by desired mode (accumulate vs. overwrite).
        // We have to do this for each type of metadata
        for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
            NodeList metadata_elements = fileset_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
            for(int l = 0; l < metadata_elements.getLength(); l++) {
            Element metadata_element = (Element) metadata_elements.item(l);
            String raw_element = metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
            String mode = metadata_element.getAttribute(MODE_ATTRIBUTE);
            String raw_value = MSMUtils.getValue(metadata_element);
            // ***** LEGACY SUPPORT *****
            // If this raw_value contains a '\' character, but no '\\', '[' or ']' characters, then replace the '\' with a '\\'
            if(raw_value.indexOf(StaticStrings.ESCAPE_STR) != -1) {
                DebugStream.println("Detected Legacy Path: " + raw_value);
                raw_value = raw_value.replaceAll(StaticStrings.ESCAPE_PATTERN, StaticStrings.PIPE_STR);
                DebugStream.println("Updated Path To: " + raw_value);
                MSMUtils.setValue(metadata_element, raw_value);
            }
            // **************************
            // Using the element string and value, retrieve a matching Metadata object from the cache
            Metadata metadata = null;
            // If this element has hierarchy values then we must ensure the raw value is a full path, not an index.
            // Try to retrieve an already comstructed piece of metadata from file - but not if we are purging, as this will stuff up anything that is still using that metadata - such as the GTable
            if(MetadataXMLFileManager.metadata_cache.contains(raw_element, raw_value)) {
                ///ystem.err.println("HIT! Retrieve metadata from cache: " + raw_element + " -> " + raw_value + "\n");
                metadata = (Metadata) MetadataXMLFileManager.metadata_cache.get(raw_element, raw_value);
            }
            else {
                ElementWrapper element = Gatherer.c_man.getCollection().msm.getElement(raw_element);
                if (element != null) {
                GValueNode value = Metadata.getDefaultValueNode(element, raw_value);
                ///ystem.err.println("Miss. Create new metadata: " + raw_element + " -> " + raw_value + "\n");
                metadata = new Metadata(element, value);
                MetadataXMLFileManager.metadata_cache.put(raw_element, raw_value, metadata);
                
                ///ystem.err.println("Added metadata to cache: " + raw_element + " -> " + raw_value + "\n");
                value = null;
                element = null;
                }
            }
            
            // Determine whether this metadata is file or folder level
            if (metadata != null) {
                // System.err.println("File relative path: " + file_relative_path + " Filename text: " + filename_text);
                // Direct match to regular expression
                if (file_relative_path.matches(filename_text)) {
                boolean is_folder_level = filename_text.equals(".*") && !file_relative_path.equals("");
                metadata.setFile(file);
                metadata.setFileLevel(!is_folder_level);
                }
                // Indirect match to regular expression (always folder level)
                else if (file_relative_path.startsWith(filename_text + File.separator)) {
                metadata.setFile(new File(file, filename_text));
                metadata.setFileLevel(false);
                }
                
                // If mode is overwrite, then remove any previous values for this metadata element.
                if(mode.equals("accumulate")) {
                metadata.setAccumulate(true);
                }
                else {
                metadata.setAccumulate(false);
                ///ystem.err.println("Metadata overwrites: " + metadata);
                for(int m = metadatum.size() - 1; m >= 0; m--) {
                    Metadata old_metadata = (Metadata) metadatum.get(m);
                    if(old_metadata.getElement().equals(metadata.getElement())) {
                    metadatum.remove(m);
                    ///ystem.err.println("Removing overridden metadata: " + old_metadata);
                    }
                    old_metadata = null;
                }
                }
                mode = null;
                // Add the completed metadata and clean up
                ///ystem.err.println("Adding metadata: " + metadata);
                metadatum.add(metadata);
                // Having found our metadata check if the value from the xml matches the one from the gvaluenode. If not update it. This happens whenever hierarchy information is involved (indexes rapidly become obsolete).
                // If remove was set, remove it. We can only remove pure file level metadata, or folder level iff we were asked for folder level.
                ///atherer.println("Have we been asked to remove the metadata: " + metadata);
                ///atherer.println("Given:");
                ///atherer.println("\tremove = " + remove);
                ///atherer.println("\tfilename = " + filename);
                ///atherer.println("\tfilename_text = " + filename_text + "?");
                if(remove && ((filename != null && filename.matches(filename_text) && !filename_text.equals(DIRECTORY_FILENAME)) || (filename == null && filename_text.equals(DIRECTORY_FILENAME)))) {
                ///atherer.println("Yes! Queuing for Removal.");
                queued_for_removal.add(metadata_element);
                }
                else {
                ///atherer.println("No. Updating.");
                String current_value = metadata.getValueNode().getFullPath(false);
                ///ystem.err.println("Checking the current mdv path: " + current_value);
                ///ystem.err.println("Against whats in the metadata file: " + raw_value);
                if(!raw_value.equals(current_value)) {
                    MSMUtils.setValue(metadata_element, current_value);
                }
                }
            }
            metadata = null;
            raw_value = null;
            raw_element = null;
            metadata_element = null;
            } // for all metadata elements
            metadata_elements = null;
        } // for all metadata types
      
        // Now we remove any elements that have been queued for deletion
        for(int a = 0; queued_for_removal != null && a < queued_for_removal.size(); a++) {
            Element metadata_element = (Element) queued_for_removal.get(a);
            Element parent = (Element) metadata_element.getParentNode();
            parent.removeChild(metadata_element);
            
            up_to_date = false; 
        }
        queued_for_removal.clear();
            
        // If the fileset no longer has any metadata remove it
        NodeList metadata_elements = fileset_element.getElementsByTagName(StaticStrings.METADATA_ELEMENT);
        if (metadata_elements.getLength()==0) {
            metadata_elements = fileset_element.getElementsByTagName(StaticStrings.EXTRACTED_METADATA_ELEMENT);
            if (metadata_elements.getLength()==0) {
            directorymetadata_element.removeChild(fileset_element);
            up_to_date = false;
            }
        }
        metadata_elements = null;
        fileset_element = null;
        filename_text = null;
        } // for each fileset element
        
        fileset_elements = null;
        directorymetadata_element = null;
    }
    catch (Exception exception) {
        DebugStream.printStackTrace(exception);
    }
    ///ystem.err.println("Found " + metadatum.size() + " pieces of metadata.");
    queued_for_removal = null;
    return metadatum;
    }
    
    /** returns true if the document has at least one Metadata or XMetadata element */
    public boolean hasMetadata() {
    boolean has_meta = true;
    try {
        // Retrieve the document element.
        Element directory_metadata_element = base_document.getDocumentElement(); 
        NodeList metadata_nodes = directory_metadata_element.getElementsByTagName(StaticStrings.METADATA_ELEMENT);
        if (metadata_nodes.getLength()==0) {
        // try extracted metadata
        metadata_nodes = directory_metadata_element.getElementsByTagName(StaticStrings.EXTRACTED_METADATA_ELEMENT);
        if (metadata_nodes.getLength()==0) {
            has_meta = false;
        }
        }
        directory_metadata_element=null;
        metadata_nodes=null;
    }
    catch (Exception error) {
        DebugStream.printStackTrace(error);
    }
    return has_meta;
    }

    /** Determine if this document has been saved recently, and thus xml file version is up to date. */
    public boolean isUpToDate() {
    return false;
    }

    /** Determine is this is a valid Greenstone Directory Metadata file. It may of course just be some xml file with the name metadata.xml. */
    public boolean isValid() {
    // Just determine if the doctype is GreenstoneDirectoryMetadata and root node is called DirectoryMetadata.
    String doctype_name = base_document.getDoctype().getName();
    String root_name = base_document.getDocumentElement().getTagName();
    return ((doctype_name.equals("GreenstoneDirectoryMetadata") && root_name.equals("GreenstoneDirectoryMetadata")) || (doctype_name.equals("DirectoryMetadata") && root_name.equals("DirectoryMetadata")));
    }

    /** Remove all of the extracted metadata (XMetadata) from this document. */
    public void removeExtractedMetadata() {
    try {
        Element document_element = base_document.getDocumentElement();
        NodeList extracted_metadata_elements = document_element.getElementsByTagName(StaticStrings.EXTRACTED_METADATA_ELEMENT);
        document_element = null;
        for(int i = extracted_metadata_elements.getLength(); i != 0; i--) {
        Element extracted_metadata_element = (Element) extracted_metadata_elements.item(i - 1);
        String element_name = extracted_metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
        ElementWrapper element = Gatherer.c_man.getCollection().msm.getElement(element_name);
        if(element != null) {
            element.dec();
        }
        element = null;
        ///ystem.err.println("Removing extracted metadata: " + element_name + "=" + MSMUtils.getValue(extracted_metadata_element));
        element_name = null;
        Node parent_node = extracted_metadata_element.getParentNode();
        parent_node.removeChild(extracted_metadata_element);
        parent_node = null;
        extracted_metadata_element = null;
        }
        extracted_metadata_elements = null;
        up_to_date = false;
    }
    catch(Exception exception) {
        DebugStream.println("Exception in MetadataXMLFile.removeExtractedMetadata() - unexpected");
        DebugStream.printStackTrace(exception);
    }
    }

    /** Remove the given metadata from this document.If filename is null, then removes directory level metadata, otherwise just removes it from the specified file. All directory level metadata is available under the FileSet with filename '.*'. There is at least one nasty case to consider, where the first overwriting metadata entry, of several with the same element, is removed. In this case the next entry must become overwrite to ensure proper inheritance. */
    public void removeMetadata(String filename, Metadata metadata) {
    DebugStream.println("Remove metadata: " + metadata + "\nFrom filename: " + filename);
    try {
        boolean found = false;
        boolean first_metadata_element_found = true;
        boolean make_next_metadata_element_overwrite = false;
        boolean remove_fileset = false;
        // is this extracted or normal metadata?
        String removing_metadata_name = metadata.getElement().getName();
        // If this is extracted metadata, we use a special element name that won't be recognized by greenstone
        String current_metadata_type = StaticStrings.METADATA_ELEMENT;
        if(removing_metadata_name.startsWith(StaticStrings.EXTRACTED_NAMESPACE)) {
        current_metadata_type = StaticStrings.EXTRACTED_METADATA_ELEMENT;
        removing_metadata_name = removing_metadata_name.substring(StaticStrings.EXTRACTED_NAMESPACE.length());
        }

        // Retrieve the document element.
        Element directorymetadata_element = base_document.getDocumentElement();
        // Iterate through the filesets looking for the appropriate one.
        NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
        for(int i = 0; !found && i < fileset_elements.getLength(); i++) {
        Element fileset_element = (Element) fileset_elements.item(i);
        NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
        for(int j = 0; !found && j < filename_elements.getLength(); j++) {
            Element filename_element = (Element) filename_elements.item(j);
            String filename_text = MSMUtils.getValue(filename_element);
            if((filename != null && filename.matches(filename_text) && !filename.equals(DIRECTORY_FILENAME)) || (filename == null && filename_text.equals(DIRECTORY_FILENAME))) {
            // Retrieve the Metadata Elements for this fileset, and iterate through them looking for the one which we are to remove.
            NodeList metadata_elements = fileset_element.getElementsByTagName(current_metadata_type);
            for(int l = 0; (!found || !make_next_metadata_element_overwrite) && l < metadata_elements.getLength(); l++) {
                Element metadata_element = (Element) metadata_elements.item(l);
                String element = metadata_element.getAttribute("name");
                String value = MSMUtils.getValue(metadata_element);
                // See if this is the metadata we wish to remove
                if(element.equals(removing_metadata_name)) {
                if(value.equals(metadata.getValueNode().getFullPath(false))) {
                    // Remove it
                    ///ystem.err.println("Remove " + element + "-" + value);
                    Element parent_elem = (Element)metadata_element.getParentNode();
                    parent_elem.removeChild(metadata_element);
                    
                    //description_element.removeChild(metadata_element);
                    found = true;
                    // If this was the first metadata with this element found, and it was set to overwrite, then we have to ensure that the next metadata with this element found (if any) is changed to be overwrite now.
                    if(first_metadata_element_found && !metadata.accumulates()) {
                    ///ystem.err.println("First of this element found!");
                    make_next_metadata_element_overwrite = true;
                    }
                }
                // If this was the first metadata we've found with the element of the one to be removed set first found to false.
                else if(first_metadata_element_found) {
                    ///ystem.err.println("Found a matching element: " + element + "=" + value);
                    first_metadata_element_found = false;
                }
                // Otherwise we should make this metadata overwrite as requested.
                else if(make_next_metadata_element_overwrite) {
                    ///ystem.err.println("Changing to overwrite: " + element + "=" + value);
                    metadata_element.setAttribute(MODE_ATTRIBUTE, "");
                }
                }
                value = null;
                element = null;
                metadata_element = null;
            } // for each metadata
            metadata_elements = null;
            } // if the filename matches

            if (found) {
            // if we found an element and removed it, we now want to check whether the fileset is empty or not
            NodeList metadata_elements = fileset_element.getElementsByTagName(StaticStrings.METADATA_ELEMENT);
            if (metadata_elements.getLength() ==0) {
                metadata_elements = fileset_element.getElementsByTagName(StaticStrings.EXTRACTED_METADATA_ELEMENT);
                if (metadata_elements.getLength() ==0) {
                // remove the fileset
                directorymetadata_element.removeChild(fileset_element);
                }
            }
            metadata_elements = null;
            }
            filename_text = null;
            filename_element = null;
        } // for each filename element
        filename_elements = null;
        fileset_element = null;
        } // for each fileset element
        fileset_elements = null;
        directorymetadata_element = null;
        up_to_date = false;
    }
    catch (Exception error) {
        DebugStream.printStackTrace(error);
    }
    }

    /** Change the up to date flag. 
     * @param up_to_date true if the document on the filesystem is the same as the one in memory, false otherwise
     */
    public void setUpToDate(boolean up_to_date) {
    this.up_to_date = up_to_date;
    }
}