Changeset 4358

Timestamp:

2003-05-27T15:24:55+12:00 (21 years ago)

Author:

jmt12

Message:

Bug fix to prevent accumulating metadata at file level accidently being overwritten by subsequently added file level metadata - John

File:

• trunk/gli/src/org/greenstone/gatherer/msm/GDMDocument.java (modified) (6 diffs)

trunk/gli/src/org/greenstone/gatherer/msm/GDMDocument.java

@@ -74 +74 @@
           this.base_document = base_document;
      }
-     /** Add this metadata to the named file. */
+     /** 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! */
      public void addMetadata(String filename, Metadata metadata) {
-          ///ystem.err.println("Add '" + metadata + "' to " + (filename != null ? filename : "directory."));
+          System.err.println("Add '" + metadata + "' to " + (filename != null ? filename : "directory."));
           try {
                 // Retrieve the document element.
@@ -92 +92 @@
                           // Have we found a match. If so break out of for loop.
                           if(filename != null && filename.matches(filename_pattern) && !filename_pattern.equals(DIRECTORY_FILENAME)) {
-                                ///ystem.err.println("Adding to file!");
+                                System.err.println("Adding to existing file fileset!");
                                 found = true;
                           }
                           else if(filename == null && filename_pattern.equals(DIRECTORY_FILENAME)) {
-                                ///ystem.err.println("Adding to folder!");
+                                System.err.println("Adding to existing folder fileset!");
                                 ///ystem.err.println("filename_pattern = '" + filename_pattern + "'");
                                 found = true;
@@ -111 +111 @@
                 // If we still haven't found an existing fileset, then its time to create one.
                 if(fileset_element == null) {
+                     System.err.println("Creating a new fileset.");
                      fileset_element = base_document.createElement(FILESET_ELEMENT);
                      Element filename_element = base_document.createElement(FILENAME_ELEMENT);
@@ -140 +141 @@
                 Element metadata_element = base_document.createElement(METADATA_ELEMENT);
                 metadata_element.setAttribute(NAME_ATTRIBUTE, metadata.getElement().getName());
-                if(metadata.accumulates()) { //mode.equals(ACCUMULATE)) {
+
+                // To determine if this metadata entry should overwrite or accumulate we check if there are other entries with the same element in this fileset.
+                boolean will_accumulate = false;
+                NodeList sibling_description_elements = fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT);
+                for(int k = 0; !will_accumulate && k < sibling_description_elements.getLength(); k++) {
+                     Element sibling_description_element = (Element) sibling_description_elements.item(k);
+                     NodeList sibling_metadata_elements = sibling_description_element.getElementsByTagName(METADATA_ELEMENT);
+                     for(int l = 0; !will_accumulate && l < sibling_metadata_elements.getLength(); l++) {
+                          Element sibling_metadata_element = (Element) sibling_metadata_elements.item(l);
+                          will_accumulate = sibling_metadata_element.getAttribute(NAME_ATTRIBUTE).equals(metadata_element.getAttribute(NAME_ATTRIBUTE));
+                          sibling_metadata_element = null;
+                     }
+                     sibling_metadata_elements = null;
+                     sibling_description_element = null;
+                }
+                sibling_description_elements = null;
+                if(will_accumulate) { //mode.equals(ACCUMULATE)) {
                      metadata_element.setAttribute(MODE_ATTRIBUTE, ACCUMULATE);
                 }
@@ -334 +351 @@
           return ((doctype_name.equals("GreenstoneDirectoryMetadata") && root_name.equals("GreenstoneDirectoryMetadata")) || (doctype_name.equals("DirectoryMetadata") && root_name.equals("DirectoryMetadata")));
      }
-     /** Remove the given directory level metadata from this document. All directory level metadata is available under the FileSet with filename '.*' */
+     /** Remove the given directory level metadata from this document. 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) {
           try {
+                boolean found = false;
+                boolean first_metadata_element_found = true;
+                boolean make_next_metadata_element_overwrite = false;
                 // Retrieve the document element.
                 Element directorymetadata_element = base_document.getDocumentElement();
@@ -353 +373 @@
                                      Element description_element = (Element) description_elements.item(k);
                                      NodeList metadata_elements = description_element.getElementsByTagName("Metadata");
-                                     for(int l = 0; l < metadata_elements.getLength(); l++) {       
+                                     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(metadata.getElement().getName()) && value.equals(metadata.getAbsoluteValue())) {
-                                          // Remove it
-                                                description_element.removeChild(metadata_element);
+                                          if(element.equals(metadata.getElement().getName())) {
+                                                if(value.equals(metadata.getAbsoluteValue())) {
+                                                  // Remove it
+                                                     System.err.println("Remove " + element + "-" + value);
+                                                     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()) {
+                                                          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) {
+                                                     first_metadata_element_found = false;
+                                                }
+                                                // Otherwise we should make this metadata overwrite as requested.
+                                                else if(make_next_metadata_element_overwrite) {
+                                                     metadata_element.setAttribute(MODE_ATTRIBUTE, "");
+                                                }
                                           }
                                           value = null;