Changeset 10479


Ignore:
Timestamp:
2005-08-11T11:19:11+12:00 (19 years ago)
Author:
mdewsnip
Message:

Changed MetadataXMLFile.addMetadata and MetadataXMLFile.removeMetadata to take a list of metadata values to remove. This makes things a bit faster when a lot of metadata is added/removed, such as when files are deleted or moved.

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

Legend:

Unmodified
Added
Removed

  • trunk/gli/src/org/greenstone/gatherer/file/FileQueue.java

    r10249 r10479  
    446446                    ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToFile(source_file);
    447447                    // ...and remove it from the original node and assign it to the new folder
    448                     for (int i = 0; i < assigned_metadata.size(); i++) {
    449                         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(i);
    450                         MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, metadata_value);
    451                         MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, metadata_value);
    452                     }
     448                    MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, assigned_metadata);
     449                    MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, assigned_metadata);
    453450                    }
    454451                    // If it came from the workspace search for metadata assigned to the file
    455452                    else if (job.source.toString().equals("Workspace")) {
    456453                    ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToExternalFile(origin_node.getFile());
    457                     for (int i = 0; i < assigned_metadata.size(); i++) {
    458                         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(i);
    459                         MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, metadata_value);
    460                     }
     454                    MetadataXMLFileManager.addMetadata((CollectionTreeNode) new_node, assigned_metadata);
    461455                    }
    462456
    … …  
    491485                // Remove the metadata assigned directly to the file
    492486                ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedDirectlyToFile(origin_node.getFile());
    493                 for (int i = 0; i < assigned_metadata.size(); i++) {
    494                 MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(i);
    495                 MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, metadata_value);
    496                 }
     487                MetadataXMLFileManager.removeMetadata((CollectionTreeNode) origin_node, assigned_metadata);
    497488
    498489                // Remove from model

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataXMLFile.java

    r9856 r10479  
    5252
    5353
    54     public void addMetadata(File file, MetadataValue metadata_value)
     54    public void addMetadata(File file, ArrayList metadata_values)
    5555    {
    5656    // Parse the metadata.xml file
    … …  
    6262
    6363    // Determine the file's path relative to the location of the metadata.xml file
    64     File metadata_xml_file_directory = getParentFile();
    65     String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     64    String metadata_xml_file_directory_path = getParentFile().getAbsolutePath();
     65    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory_path.length());
    6666    if (file_relative_path.startsWith(File.separator)) {
    6767        file_relative_path = file_relative_path.substring(File.separator.length());
    … …  
    7979    }
    8080
    81     // Remove any characters that are invalid in XML
    82     String metadata_value_string = XMLTools.removeInvalidCharacters(metadata_value.getFullValue());
    83 
    84     // Square brackets need to be escaped because they are a special character in Greenstone
    85     metadata_value_string = metadata_value_string.replaceAll("\\[", "&#091;");
    86     metadata_value_string = metadata_value_string.replaceAll("\\]", "&#093;");
    87 
    88     // Create a new Metadata element to record this metadata
    89     Element new_metadata_element = document.createElement(METADATA_ELEMENT);
    90     new_metadata_element.setAttribute("name", metadata_value.getMetadataElement().getFullName());
    91     new_metadata_element.setAttribute("mode", (metadata_value.isAccumulatingMetadata() ? "accumulate" : "override"));
    92     new_metadata_element.appendChild(document.createTextNode(metadata_value_string));
    93     boolean must_add_new_fileset_for_metadata = true;
     81    // Find the appropriate FileSet element for this file
     82    Element appropriate_fileset_element = null;
    9483
    9584    // Read all the FileSet elements in the file
    96     String metadata_element_name_full = metadata_value.getMetadataElement().getFullName();
    9785    NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
    9886    for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
    … …  
    10795        // Only exact matches can be extended with new metadata
    10896        if (current_filename_element_value.equals(file_path_regexp)) {
    109             Element description_element = (Element) current_fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT).item(0);
    110             boolean metadata_already_assigned = false;
    111 
    112             // Check if this piece of metadata has already been assigned to this FileSet element
    113             NodeList metadata_elements_nodelist = description_element.getElementsByTagName(METADATA_ELEMENT);
    114             for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
    115             Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
    116 
    117             // Check the metadata element name matches
    118             String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
    119             if (!current_metadata_element_name_full.equals(metadata_element_name_full)) {
    120                 continue;
    121             }
    122 
    123             // Check the metadata element value matches
    124             String current_metadata_value_string = XMLTools.getElementTextValue(current_metadata_element);
    125             if (!current_metadata_value_string.equals(metadata_value_string)) {
    126                 continue;
    127             }
    128 
     97            appropriate_fileset_element = current_fileset_element;
     98            break;
     99        }
     100        }
     101    }
     102
     103    // If no appropriate FileSet element exists create a new one for this file
     104    if (appropriate_fileset_element == null) {
     105        System.err.println("No appropriate fileset element found...");
     106        appropriate_fileset_element = document.createElement(FILESET_ELEMENT);
     107
     108        Element new_filename_element = document.createElement(FILENAME_ELEMENT);
     109        new_filename_element.appendChild(document.createTextNode(file_path_regexp));
     110        appropriate_fileset_element.appendChild(new_filename_element);
     111
     112        Element new_description_element = document.createElement(DESCRIPTION_ELEMENT);
     113        appropriate_fileset_element.appendChild(new_description_element);
     114
     115        document.getDocumentElement().appendChild(appropriate_fileset_element);
     116    }
     117
     118    // Add each of the metadata values to the FileSet's Description element
     119    Element description_element = (Element) appropriate_fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT).item(0);
     120    for (int i = 0; i < metadata_values.size(); i++) {
     121        MetadataValue metadata_value = (MetadataValue) metadata_values.get(i);
     122        String metadata_element_name_full = metadata_value.getMetadataElement().getFullName();
     123
     124        // Remove any characters that are invalid in XML
     125        String metadata_value_string = XMLTools.removeInvalidCharacters(metadata_value.getFullValue());
     126
     127        // Square brackets need to be escaped because they are a special character in Greenstone
     128        metadata_value_string = metadata_value_string.replaceAll("\\[", "&#091;");
     129        metadata_value_string = metadata_value_string.replaceAll("\\]", "&#093;");
     130
     131        // Check if this piece of metadata has already been assigned to this FileSet element
     132        boolean metadata_already_assigned = false;
     133        NodeList metadata_elements_nodelist = description_element.getElementsByTagName(METADATA_ELEMENT);
     134        for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
     135        Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
     136
     137        // Check if the metadata element name matches
     138        String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
     139        if (current_metadata_element_name_full.equals(metadata_element_name_full)) {
     140            // Check if the metadata element value matches
     141            String current_metadata_value_string = XMLTools.getElementTextValue(current_metadata_element);
     142            if (current_metadata_value_string.equals(metadata_value_string)) {
    129143            // Metadata already assigned
    130144            metadata_already_assigned = true;
    131145            break;
    132146            }
    133 
    134             // If the metadata has already been assigned to this FileSet, move onto the next
    135             if (metadata_already_assigned) {
    136             must_add_new_fileset_for_metadata = false;
    137             break;
    138             }
    139 
    140             // Accumulating metadata: add at the end
    141             if (metadata_value.isAccumulatingMetadata()) {
    142             description_element.appendChild(new_metadata_element);
    143             }
    144             // Override metadata: add at the start (so it overrides inherited metadata without affecting other assigned metadata)
    145             else {
    146             description_element.insertBefore(new_metadata_element, description_element.getFirstChild());
    147             }
    148 
    149             must_add_new_fileset_for_metadata = false;
    150             break;
    151         }
    152         }
    153     }
    154 
    155     // If the metadata didn't apply to an existing FileSet, add a new FileSet element for this metadata
    156     if (must_add_new_fileset_for_metadata) {
    157         Element new_fileset_element = document.createElement(FILESET_ELEMENT);
    158 
    159         Element new_filename_element = document.createElement(FILENAME_ELEMENT);
    160         new_filename_element.appendChild(document.createTextNode(file_path_regexp));
    161         new_fileset_element.appendChild(new_filename_element);
    162 
    163         // Append the new Metadata element to the Description element of this FileSet
    164         Element new_description_element = document.createElement(DESCRIPTION_ELEMENT);
    165         new_description_element.appendChild(new_metadata_element);
    166         new_fileset_element.appendChild(new_description_element);
    167 
    168         document.getDocumentElement().appendChild(new_fileset_element);
     147        }
     148        }
     149
     150        // If the piece of metadata hasn't already been assigned, add it now
     151        if (!metadata_already_assigned) {
     152        // Create a new Metadata element to record this metadata
     153        Element new_metadata_element = document.createElement(METADATA_ELEMENT);
     154        new_metadata_element.setAttribute("name", metadata_value.getMetadataElement().getFullName());
     155        new_metadata_element.setAttribute("mode", (metadata_value.isAccumulatingMetadata() ? "accumulate" : "override"));
     156        new_metadata_element.appendChild(document.createTextNode(metadata_value_string));
     157
     158        // Accumulating metadata: add at the end
     159        if (metadata_value.isAccumulatingMetadata()) {
     160            description_element.appendChild(new_metadata_element);
     161        }
     162        // Override metadata: add at the start (so it overrides inherited metadata without affecting other assigned metadata)
     163        else {
     164            description_element.insertBefore(new_metadata_element, description_element.getFirstChild());
     165        }
     166        }
    169167    }
    170168
    … …  
    292290
    293291
    294     public void removeMetadata(File file, MetadataValue metadata_value)
     292    public void removeMetadata(File file, ArrayList metadata_values)
    295293    {
    296294    // Parse the metadata.xml file
    … …  
    302300
    303301    // Determine the file's path relative to the location of the metadata.xml file
    304     File metadata_xml_file_directory = getParentFile();
    305     String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     302    String metadata_xml_file_directory_path = getParentFile().getAbsolutePath();
     303    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory_path.length());
    306304    if (file_relative_path.startsWith(File.separator)) {
    307305        file_relative_path = file_relative_path.substring(File.separator.length());
    … …  
    319317    }
    320318
    321     // Remove any characters that are invalid in XML
    322     String metadata_value_string = XMLTools.removeInvalidCharacters(metadata_value.getFullValue());
    323 
    324     // Square brackets need to be escaped because they are a special character in Greenstone
    325     metadata_value_string = metadata_value_string.replaceAll("\\[", "&#091;");
    326     metadata_value_string = metadata_value_string.replaceAll("\\]", "&#093;");
     319    // Find the appropriate FileSet element for this file
     320    Element appropriate_fileset_element = null;
    327321
    328322    // Read all the FileSet elements in the file
    … …  
    330324    for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
    331325        Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
    332         boolean current_fileset_matches = false;
    333326
    334327        // Check the FileName elements of the FileSet to see if we have a match
    … …  
    338331        String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
    339332
    340         // Only exact matches can be edited
     333        // Only exact matches can be extended with new metadata
    341334        if (current_filename_element_value.equals(file_path_regexp)) {
    342             current_fileset_matches = true;
     335            appropriate_fileset_element = current_fileset_element;
    343336            break;
    344337        }
    345338        }
    346 
    347         // The FileSet doesn't apply, so move onto the next one
    348         if (current_fileset_matches == false) {
    349         continue;
    350         }
     339    }
     340
     341    // If no appropriate FileSet element exists we have no idea where the metadata is
     342    if (appropriate_fileset_element == null) {
     343        System.err.println("Error: No appropriate FileSet element found when removing metadata...");
     344        return;
     345    }
     346
     347    // Remove each of the metadata values from the FileSet's Description element
     348    Element description_element = (Element) appropriate_fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT).item(0);
     349    for (int i = 0; i < metadata_values.size(); i++) {
     350        MetadataValue metadata_value = (MetadataValue) metadata_values.get(i);
     351
     352        // Remove any characters that are invalid in XML
     353        String metadata_value_string = XMLTools.removeInvalidCharacters(metadata_value.getFullValue());
     354
     355        // Square brackets need to be escaped because they are a special character in Greenstone
     356        metadata_value_string = metadata_value_string.replaceAll("\\[", "&#091;");
     357        metadata_value_string = metadata_value_string.replaceAll("\\]", "&#093;");
    351358
    352359        // Find the Metadata element to delete from the fileset
    353360        String metadata_element_name_full = metadata_value.getMetadataElement().getFullName();
    354         NodeList metadata_elements_nodelist = current_fileset_element.getElementsByTagName(METADATA_ELEMENT);
     361        NodeList metadata_elements_nodelist = appropriate_fileset_element.getElementsByTagName(METADATA_ELEMENT);
    355362        for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
    356363        Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
    … …  
    358365        // Check the metadata element name matches
    359366        String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
    360         if (!current_metadata_element_name_full.equals(metadata_element_name_full)) {
    361             continue;
    362         }
    363 
    364         // Check the metadata element value matches
    365         String current_metadata_value_string = XMLTools.getElementTextValue(current_metadata_element);
    366         if (!current_metadata_value_string.equals(metadata_value_string)) {
    367             continue;
    368         }
    369 
    370         // Remove this Metadata element
    371         current_metadata_element.getParentNode().removeChild(current_metadata_element);
     367        if (current_metadata_element_name_full.equals(metadata_element_name_full)) {
     368            // Check the metadata element value matches
     369            String current_metadata_value_string = XMLTools.getElementTextValue(current_metadata_element);
     370            if (current_metadata_value_string.equals(metadata_value_string)) {
     371            // Remove this Metadata element
     372            current_metadata_element.getParentNode().removeChild(current_metadata_element);
     373            break;
     374            }
     375        }
    372376        }
    373377    }
    … …  
    388392
    389393    // Determine the file's path relative to the location of the metadata.xml file
    390     File metadata_xml_file_directory = getParentFile();
    391     String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     394    String metadata_xml_file_directory_path = getParentFile().getAbsolutePath();
     395    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory_path.length());
    392396    if (file_relative_path.startsWith(File.separator)) {
    393397        file_relative_path = file_relative_path.substring(File.separator.length());

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataXMLFileManager.java

    r10392 r10479  
    4747
    4848
    49     static public void addMetadata(CollectionTreeNode file_node, MetadataValue metadata_value)
    50     {
    51     addMetadata(new CollectionTreeNode[] { file_node }, metadata_value);
     49    static public void addMetadata(CollectionTreeNode file_node, ArrayList metadata_values)
     50    {
     51    addMetadata(new CollectionTreeNode[] { file_node }, metadata_values);
    5252    }
    5353
    … …  
    5555    static public void addMetadata(CollectionTreeNode[] file_nodes, MetadataValue metadata_value)
    5656    {
     57    ArrayList metadata_values = new ArrayList();
     58    metadata_values.add(metadata_value);
     59    addMetadata(file_nodes, metadata_values);
     60    }
     61
     62
     63    static public void addMetadata(CollectionTreeNode[] file_nodes, ArrayList metadata_values)
     64    {
     65    // Check the list of metadata values is non-empty
     66    if (metadata_values.isEmpty()) {
     67        return;
     68    }
     69
    5770    // Add the metadata to each file node in turn
    5871    for (int i = 0; i < file_nodes.length; i++) {
    … …  
    6982        if (current_file_directory.getAbsolutePath().equals(metadata_xml_file.getParentFile().getAbsolutePath())) {
    7083            applicable_metadata_xml_file_found = true;
    71             metadata_xml_file.addMetadata(current_file, metadata_value);
     84            metadata_xml_file.addMetadata(current_file, metadata_values);
    7285            if (!modified_metadata_xml_files.contains(metadata_xml_file)) {
    7386            modified_metadata_xml_files.add(metadata_xml_file);
    … …  
    8699
    87100        // ...and add the metadata
    88         new_metadata_xml_file.addMetadata(current_file, metadata_value);
     101        new_metadata_xml_file.addMetadata(current_file, metadata_values);
    89102        if (!modified_metadata_xml_files.contains(new_metadata_xml_file)) {
    90103            modified_metadata_xml_files.add(new_metadata_xml_file);
    … …  
    258271
    259272
    260     static public void removeMetadata(CollectionTreeNode file_node, MetadataValue metadata_value)
    261     {
    262     removeMetadata(new CollectionTreeNode[] { file_node }, metadata_value);
     273    static public void removeMetadata(CollectionTreeNode file_node, ArrayList metadata_values)
     274    {
     275    removeMetadata(new CollectionTreeNode[] { file_node }, metadata_values);
    263276    }
    264277
    … …  
    266279    static public void removeMetadata(CollectionTreeNode[] file_nodes, MetadataValue metadata_value)
    267280    {
     281    ArrayList metadata_values = new ArrayList();
     282    metadata_values.add(metadata_value);
     283    removeMetadata(file_nodes, metadata_values);
     284    }
     285
     286
     287    static public void removeMetadata(CollectionTreeNode[] file_nodes, ArrayList metadata_values)
     288    {
     289    // Check the list of metadata values is non-empty
     290    if (metadata_values.isEmpty()) {
     291        return;
     292    }
     293
    268294    // Remove the metadata from each file node in turn
    269295    for (int i = 0; i < file_nodes.length; i++) {
    … …  
    278304        // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
    279305        if (current_file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
    280             metadata_xml_file.removeMetadata(current_file, metadata_value);
     306            metadata_xml_file.removeMetadata(current_file, metadata_values);
    281307            if (!modified_metadata_xml_files.contains(metadata_xml_file)) {
    282308            modified_metadata_xml_files.add(metadata_xml_file);
Note: See TracChangeset for help on using the changeset viewer.