Changeset 7978


Ignore:
Timestamp:
2004-08-18T11:01:56+12:00 (20 years ago)
Author:
mdewsnip
Message:

Fixed code indenting.

Location:
trunk/gli/src/org/greenstone/gatherer/metadata
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r7827 r7978  
    1111/** This class represents one doc.xml file */
    1212public class DocXMLFile
    13    extends File
     13    extends File
    1414{
    15    static final private String ARCHIVE_ELEMENT = "Archive";
    16    static final private String DESCRIPTION_ELEMENT = "Description";
    17    static final private String METADATA_ELEMENT = "Metadata";
    18    static final private String SECTION_ELEMENT = "Section";
     15    static final private String ARCHIVE_ELEMENT = "Archive";
     16    static final private String DESCRIPTION_ELEMENT = "Description";
     17    static final private String METADATA_ELEMENT = "Metadata";
     18    static final private String SECTION_ELEMENT = "Section";
    1919
    20    private ArrayList files_in_doc_xml_file = new ArrayList();
     20    private ArrayList files_in_doc_xml_file = new ArrayList();
    2121
    2222
    23    public DocXMLFile(String doc_xml_file_path)
    24    {
    25       super(doc_xml_file_path);
     23    public DocXMLFile(String doc_xml_file_path)
     24    {
     25    super(doc_xml_file_path);
    2626
    27       // Parse the doc.xml file
    28       Document document = XMLTools.parseXMLFile(this);
    29       if (document == null) {
    30      System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
    31      return;
    32       }
     27    // Parse the doc.xml file
     28    Document document = XMLTools.parseXMLFile(this);
     29    if (document == null) {
     30        System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
     31        return;
     32    }
    3333
    34       // Read all the Archive elements in the file
    35       NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
    36       for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
    37      Element current_archive_element = (Element) archive_elements_nodelist.item(i);
     34    // Read all the Archive elements in the file
     35    NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
     36    for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
     37        Element current_archive_element = (Element) archive_elements_nodelist.item(i);
    3838
    39      // Read the child Section elements of the archive (but not all descendants)
    40      ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
    41      for (int j = 0; j < child_section_elements.size(); j++) {
    42         Element current_section_element = (Element) child_section_elements.get(j);
     39        // Read the child Section elements of the archive (but not all descendants)
     40        ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
     41        for (int j = 0; j < child_section_elements.size(); j++) {
     42        Element current_section_element = (Element) child_section_elements.get(j);
    4343
    44         // Read the Description elements of this section only (not child sections as well)
    45         ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
    46         for (int k = 0; k < child_description_elements.size(); k++) {
    47            Element current_description_element = (Element) child_description_elements.get(k);
     44        // Read the Description elements of this section only (not child sections as well)
     45        ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
     46        for (int k = 0; k < child_description_elements.size(); k++) {
     47            Element current_description_element = (Element) child_description_elements.get(k);
    4848
    49            String gsdlsourcefilename_value = null;
    50            boolean bibliographic_data = false;
     49            String gsdlsourcefilename_value = null;
     50            boolean bibliographic_data = false;
    5151
    52            // Read all the Metadata elements in this description element
    53            NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
    54            for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
    55           Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
    56           String metadata_element_name_full = current_metadata_element.getAttribute("name");
     52            // Read all the Metadata elements in this description element
     53            NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
     54            for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
     55            Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
     56            String metadata_element_name_full = current_metadata_element.getAttribute("name");
    5757
    58           // Note which file this Section is for
    59           if (metadata_element_name_full.equals("gsdlsourcefilename")) {
    60              gsdlsourcefilename_value = XMLTools.getElementTextValue(current_metadata_element);
    61              boolean is_unix_path = gsdlsourcefilename_value.startsWith("/");
     58            // Note which file this Section is for
     59            if (metadata_element_name_full.equals("gsdlsourcefilename")) {
     60                gsdlsourcefilename_value = XMLTools.getElementTextValue(current_metadata_element);
     61                boolean is_unix_path = gsdlsourcefilename_value.startsWith("/");
    6262
    63              // We're only interested in the path relative to the import folder
    64              int import_index = gsdlsourcefilename_value.indexOf("import");
    65              if (import_index != -1) {
    66             gsdlsourcefilename_value = gsdlsourcefilename_value.substring(import_index + "import".length() + 1);
    67              }
     63                // We're only interested in the path relative to the import folder
     64                int import_index = gsdlsourcefilename_value.indexOf("import");
     65                if (import_index != -1) {
     66                gsdlsourcefilename_value = gsdlsourcefilename_value.substring(import_index + "import".length() + 1);
     67                }
    6868
    69              // Make sure the path matches the OS that is running
    70              if (is_unix_path && Utility.isWindows()) {
    71             // Convert path from Unix to Windows
    72             gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("/", File.separator);
    73              }
    74              if (!is_unix_path && !Utility.isWindows()) {
    75             // Convert path from Windows to Unix
    76             gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("\\", File.separator);
    77              }
     69                // Make sure the path matches the OS that is running
     70                if (is_unix_path && Utility.isWindows()) {
     71                // Convert path from Unix to Windows
     72                gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("/", File.separator);
     73                }
     74                if (!is_unix_path && !Utility.isWindows()) {
     75                // Convert path from Windows to Unix
     76                gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("\\", File.separator);
     77                }
    7878
    79              System.err.println("gsdlsourcefilename: " + gsdlsourcefilename_value);
    80           }
     79                System.err.println("gsdlsourcefilename: " + gsdlsourcefilename_value);
     80            }
    8181
    82           // We don't deal with bibliographic data
    83           if (metadata_element_name_full.equals("SourceSegment")) {
    84              bibliographic_data = true;
    85              break;
    86           }
    87            }
     82            // We don't deal with bibliographic data
     83            if (metadata_element_name_full.equals("SourceSegment")) {
     84                bibliographic_data = true;
     85                break;
     86            }
     87            }
    8888
    89            // Remember this for quick access later
    90            if (gsdlsourcefilename_value != null && !bibliographic_data) {
    91           files_in_doc_xml_file.add(gsdlsourcefilename_value);
    92            }
     89            // Remember this for quick access later
     90            if (gsdlsourcefilename_value != null && !bibliographic_data) {
     91            files_in_doc_xml_file.add(gsdlsourcefilename_value);
     92            }
     93        }
    9394        }
    94      }
    95       }
    96    }
     95    }
     96    }
    9797
    9898
    99    public ArrayList getMetadataExtractedFromFile(File file)
    100    {
    101       // Build up a list of metadata extracted from this file
    102       ArrayList metadata_values = new ArrayList();
     99    public ArrayList getMetadataExtractedFromFile(File file)
     100    {
     101    // Build up a list of metadata extracted from this file
     102    ArrayList metadata_values = new ArrayList();
    103103
    104       String file_relative_path = file.getAbsolutePath();
    105       int import_index = file_relative_path.indexOf("import");
    106       if (import_index != -1) {
    107      file_relative_path = file_relative_path.substring(import_index + "import".length() + 1);
    108       }
     104    String file_relative_path = file.getAbsolutePath();
     105    int import_index = file_relative_path.indexOf("import");
     106    if (import_index != -1) {
     107        file_relative_path = file_relative_path.substring(import_index + "import".length() + 1);
     108    }
    109109
    110       // Check whether this doc.xml file contains extracted metadata for the specified file
    111       boolean contains_extracted_metadata_for_file = false;
    112       for (int i = 0; i < files_in_doc_xml_file.size(); i++) {
    113      if (file_relative_path.equals(files_in_doc_xml_file.get(i))) {
    114         contains_extracted_metadata_for_file = true;
    115         // System.err.println("Found extracted metadata in file " + getAbsolutePath());
    116         break;
    117      }
    118       }
     110    // Check whether this doc.xml file contains extracted metadata for the specified file
     111    boolean contains_extracted_metadata_for_file = false;
     112    for (int i = 0; i < files_in_doc_xml_file.size(); i++) {
     113        if (file_relative_path.equals(files_in_doc_xml_file.get(i))) {
     114        contains_extracted_metadata_for_file = true;
     115        // System.err.println("Found extracted metadata in file " + getAbsolutePath());
     116        break;
     117        }
     118    }
    119119
    120       // ...it doesn't
    121       if (!contains_extracted_metadata_for_file) {
    122      return metadata_values;
    123       }
     120    // ...it doesn't
     121    if (!contains_extracted_metadata_for_file) {
     122        return metadata_values;
     123    }
    124124
    125       // Parse the doc.xml file
    126       Document document = XMLTools.parseXMLFile(this);
    127       if (document == null) {
    128      System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
    129      return metadata_values;
    130       }
     125    // Parse the doc.xml file
     126    Document document = XMLTools.parseXMLFile(this);
     127    if (document == null) {
     128        System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
     129        return metadata_values;
     130    }
    131131
    132       MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
     132    MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
    133133
    134       // Read all the Archive elements in the file
    135       NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
    136       for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
    137      Element current_archive_element = (Element) archive_elements_nodelist.item(i);
     134    // Read all the Archive elements in the file
     135    NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
     136    for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
     137        Element current_archive_element = (Element) archive_elements_nodelist.item(i);
    138138
    139      // Read the child Section elements of the archive (but not all descendants)
    140      ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
    141      for (int j = 0; j < child_section_elements.size(); j++) {
    142         Element current_section_element = (Element) child_section_elements.get(j);
     139        // Read the child Section elements of the archive (but not all descendants)
     140        ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
     141        for (int j = 0; j < child_section_elements.size(); j++) {
     142        Element current_section_element = (Element) child_section_elements.get(j);
    143143
    144         // Read the Description elements of this section only (not child sections as well)
    145         ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
    146         for (int k = 0; k < child_description_elements.size(); k++) {
    147            Element current_description_element = (Element) child_description_elements.get(k);
     144        // Read the Description elements of this section only (not child sections as well)
     145        ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
     146        for (int k = 0; k < child_description_elements.size(); k++) {
     147            Element current_description_element = (Element) child_description_elements.get(k);
    148148
    149            // Read all the Metadata elements in this description element
    150            NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
    151            for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
    152           Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
    153           String metadata_element_name_full = current_metadata_element.getAttribute("name");
     149            // Read all the Metadata elements in this description element
     150            NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
     151            for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
     152            Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
     153            String metadata_element_name_full = current_metadata_element.getAttribute("name");
    154154
    155           // If the metadata has no namespace, it is extracted metadata
    156           String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    157           if (metadata_set_namespace.equals("")) {
    158              metadata_set_namespace = MetadataSetManager.EXTRACTED_METADATA_NAMESPACE;
     155            // If the metadata has no namespace, it is extracted metadata
     156            String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     157            if (metadata_set_namespace.equals("")) {
     158                metadata_set_namespace = MetadataSetManager.EXTRACTED_METADATA_NAMESPACE;
    159159
    160              // We're not interested in lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
    161              if (Character.isLowerCase(metadata_element_name_full.charAt(0))) {
    162             continue;
    163              }
     160                // We're not interested in lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
     161                if (Character.isLowerCase(metadata_element_name_full.charAt(0))) {
     162                continue;
     163                }
    164164
    165              MetadataElement metadata_element = extracted_metadata_set.getMetadataElement(metadata_element_name_full);
    166              if (metadata_element == null) {
    167             metadata_element_name_full = metadata_set_namespace + MetadataTools.NAMESPACE_SEPARATOR + metadata_element_name_full;
    168             metadata_element = new MetadataElement(metadata_element_name_full, null);
    169              }
     165                MetadataElement metadata_element = extracted_metadata_set.getMetadataElement(metadata_element_name_full);
     166                if (metadata_element == null) {
     167                metadata_element_name_full = metadata_set_namespace + MetadataTools.NAMESPACE_SEPARATOR + metadata_element_name_full;
     168                metadata_element = new MetadataElement(metadata_element_name_full, null);
     169                }
    170170
    171              // Value trees are not stored for extracted metadata, so create a new value tree node now
    172              String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    173              metadata_element.addMetadataValue(current_metadata_element_value);
    174              MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
     171                // Value trees are not stored for extracted metadata, so create a new value tree node now
     172                String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     173                metadata_element.addMetadataValue(current_metadata_element_value);
     174                MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
    175175
    176              // Add the new metadata value to the list
    177              MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
    178              metadata_values.add(metadata_value);
    179           }
    180            }
     176                // Add the new metadata value to the list
     177                MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
     178                metadata_values.add(metadata_value);
     179            }
     180            }
     181        }
    181182        }
    182      }
    183       }
     183    }
    184184
    185       return metadata_values;
    186    }
     185    return metadata_values;
     186    }
    187187}

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

    r7822 r7978  
    99public class DocXMLFileManager
    1010{
    11    static private ArrayList doc_xml_files = new ArrayList();
     11    static private ArrayList doc_xml_files = new ArrayList();
    1212
    1313
    14    static public void clearDocXMLFiles()
    15    {
    16       doc_xml_files.clear();
    17    }
     14    static public void clearDocXMLFiles()
     15    {
     16    doc_xml_files.clear();
     17    }
    1818
    1919
    20    static public ArrayList getMetadataExtractedFromFile(File file)
    21    {
    22       // Build up a list of metadata values extracted from this file
    23       ArrayList metadata_values = new ArrayList();
     20    static public ArrayList getMetadataExtractedFromFile(File file)
     21    {
     22    // Build up a list of metadata values extracted from this file
     23    ArrayList metadata_values = new ArrayList();
    2424
    25       // Look at each loaded doc.xml file to see if any have extracted metadata for this file
    26       for (int i = 0; i < doc_xml_files.size(); i++) {
    27      DocXMLFile doc_xml_file = (DocXMLFile) doc_xml_files.get(i);
    28      metadata_values.addAll(doc_xml_file.getMetadataExtractedFromFile(file));
    29       }
     25    // Look at each loaded doc.xml file to see if any have extracted metadata for this file
     26    for (int i = 0; i < doc_xml_files.size(); i++) {
     27        DocXMLFile doc_xml_file = (DocXMLFile) doc_xml_files.get(i);
     28        metadata_values.addAll(doc_xml_file.getMetadataExtractedFromFile(file));
     29    }
    3030
    31       return metadata_values;
    32    }
     31    return metadata_values;
     32    }
    3333
    3434
    35    static public void loadDocXMLFiles(File directory)
    36    {
    37       // Look recursively at each subfile of the directory for doc.xml files
    38       File[] directory_files = directory.listFiles();
    39       for (int i = 0; i < directory_files.length; i++) {
    40      File child_file = directory_files[i];
    41      if (child_file.isDirectory()) {
    42         loadDocXMLFiles(child_file);
    43      }
    44      else if (child_file.getName().equals("doc.xml")) {
    45         loadDocXMLFile(child_file);
    46      }
    47       }
    48    }
     35    static public void loadDocXMLFiles(File directory)
     36    {
     37    // Look recursively at each subfile of the directory for doc.xml files
     38    File[] directory_files = directory.listFiles();
     39    for (int i = 0; i < directory_files.length; i++) {
     40        File child_file = directory_files[i];
     41        if (child_file.isDirectory()) {
     42        loadDocXMLFiles(child_file);
     43        }
     44        else if (child_file.getName().equals("doc.xml")) {
     45        loadDocXMLFile(child_file);
     46        }
     47    }
     48    }
    4949
    5050
    51    static private void loadDocXMLFile(File doc_xml_file_file)
    52    {
    53       DocXMLFile doc_xml_file = new DocXMLFile(doc_xml_file_file.getAbsolutePath());
    54       doc_xml_files.add(doc_xml_file);
    55    }
     51    static private void loadDocXMLFile(File doc_xml_file_file)
     52    {
     53    DocXMLFile doc_xml_file = new DocXMLFile(doc_xml_file_file.getAbsolutePath());
     54    doc_xml_files.add(doc_xml_file);
     55    }
    5656}

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

    r7827 r7978  
    1414
    1515public class MetadataAuditTableModel
    16    extends AbstractTableModel
     16    extends AbstractTableModel
    1717{
    18    /** The FileNodes this model is built for */
    19    private FileNode[] file_nodes = null;
    20    private ArrayList metadata_values = null;
     18    /** The FileNodes this model is built for */
     19    private FileNode[] file_nodes = null;
     20    private ArrayList metadata_values = null;
    2121
    2222
    23    /** Returns the number of columns in this table. */
    24    public int getColumnCount()
    25    {
    26       return 1;  // !!! TO DO
    27    }
     23    /** Returns the number of columns in this table. */
     24    public int getColumnCount()
     25    {
     26    return 1;  // !!! TO DO
     27    }
    2828
    2929
    30 //    /** Retrieves the name of the specified column. */
    31 //    public String getColumnName(int col)
    32 //    {
    33 //       return COLUMN_NAMES[col];
    34 //    }
     30    //    /** Retrieves the name of the specified column. */
     31    //    public String getColumnName(int col)
     32    //    {
     33    //       return COLUMN_NAMES[col];
     34    //    }
    3535
    3636
    … …  
    4747
    4848   /** Returns the number of rows in this table. */
    49    public int getRowCount()
    50    {
    51       return metadata_values.size();
    52    }
     49    public int getRowCount()
     50    {
     51    return metadata_values.size();
     52    }
    5353
    5454
    55    /** Returns the cell value at a given row and column as an Object. */
    56    public Object getValueAt(int row, int col)
    57    {
    58       // Check values are reasonable
    59       if (row < 0 || row >= metadata_values.size() || col < 0 || col >= getColumnCount()) {
    60     return null;
    61       }
     55    /** Returns the cell value at a given row and column as an Object. */
     56    public Object getValueAt(int row, int col)
     57    {
     58    // Check values are reasonable
     59    if (row < 0 || row >= metadata_values.size() || col < 0 || col >= getColumnCount()) {
     60        return null;
     61    }
    6262
    63       return null;
    64    }
     63    return null;
     64    }
    6565
    6666
    67 //    public void rebuild(FileNode[] file_nodes)
    68 //    {
    69 //       metadata_value_table_entries.clear();
     67    public void rebuild(FileNode[] file_nodes)
     68    {
     69    metadata_values.clear();
    7070
    71 //       if (!Gatherer.c_man.ready()) {
    72 //   Gatherer.println("Not ready!");
    73 //   return;
    74 //       }
    75 
    76 //       this.file_nodes = file_nodes;
    77 //       if (file_nodes != null && file_nodes.length > 0) {
    78 //   // Create model builder
    79 //   MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
    80 //   builder.run();
    81 //       }
    82 //    }
     71    this.file_nodes = file_nodes;
     72    }
    8373
    8474
    85 //    private class MetadataValueTableModelBuilder
    86 //    {
    87 //       public void run()
    88 //       {
    89 //   // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
    90 //   boolean hid_extracted_metadata = false;
    91 //   boolean has_inherited_metadata = false;
    92 //   ArrayList metadata_elements_seen = new ArrayList();
     75    //    public void rebuild(FileNode[] file_nodes)
     76    //    {
     77    //       metadata_value_table_entries.clear();
    9378
    94 //   // Process each of the selected files in turn
    95 //   for (int i = 0; i < file_nodes.length; i++) {
    96 //      File current_file = file_nodes[i].getFile();
     79    //       if (!Gatherer.c_man.ready()) {
     80    //   Gatherer.println("Not ready!");
     81    //   return;
     82    //       }
    9783
    98 //      // Get the metadata assigned to this file
    99 //      ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
    100 //      for (int j = 0; j < assigned_metadata.size(); j++) {
    101 //         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
    102 //         MetadataElement metadata_element = metadata_value.getMetadataElement();
    103 
    104 //         // Note if there is inherited (folder-level) metadata in the table
    105 //         has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
    106 
    107 //         // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    108 //         insertMetadataValueIntoTable(metadata_value);
    109 
    110 //         // Remember we have seen this metadata element
    111 //         if (metadata_elements_seen.contains(metadata_element) == false) {
    112 //        metadata_elements_seen.add(metadata_element);
    113 //         }
    114 //      }
    115 
    116 //      // Get the extracted metadata for this file, if desired
    117 //      if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
    118 //         ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
    119 //         for (int k = 0; k < extracted_metadata.size(); k++) {
    120 //        MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
    121 
    122 //        // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    123 //        insertMetadataValueIntoTable(metadata_value);
    124 //         }
    125 //      }
    126 //   }
    127 
    128 //   // Make sure each non-extracted metadata element appears in the table (even if blank)
    129 //   ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
    130 //   for (int i = 0; i < every_metadata_set_element.size(); i++) {
    131 //      MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
    132 
    133 //      // If we haven't seen this metadata element and it isn't extracted, add it now
    134 //      if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
    135 //         MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
    136 
    137 //         // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
    138 //         metadata_value_table_entry.setOccurrences(file_nodes.length);
    139 
    140 //         // Add it to the table
    141 //         insertMetadataValueIntoTable(metadata_value_table_entry);
    142 //      }
    143 //   }
    144 
    145 //   // If extracted metadata was hidden, display the warning
    146 //   if (hid_extracted_metadata) {
    147 //      showExtractedMetadataWarning();
    148 //   }
    149 
    150 //   // If there is inherited metadata, display the warning
    151 //   if (has_inherited_metadata) {
    152 //      showInheritedMetadataWarning();
    153 //   }
    154 //       }
     84    //       this.file_nodes = file_nodes;
     85    //       if (file_nodes != null && file_nodes.length > 0) {
     86    //   // Create model builder
     87    //   MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
     88    //   builder.run();
     89    //       }
     90    //    }
    15591
    15692
    157 //       /** Alphabetically inserts the new metadata value into the table */
    158 //       private void insertMetadataValueIntoTable(MetadataValue metadata_value)
    159 //       {
    160 //   for (int i = 0; i < metadata_value_table_entries.size(); i++) {
    161 //      MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
    162 //      int c = current_metadata_value_table_entry.compareTo(metadata_value);
     93    //    private class MetadataValueTableModelBuilder
     94    //    {
     95    //       public void run()
     96    //       {
     97    //   // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
     98    //   boolean hid_extracted_metadata = false;
     99    //   boolean has_inherited_metadata = false;
     100    //   ArrayList metadata_elements_seen = new ArrayList();
    163101
    164 //      // Insert value before existing entry
    165 //      if (c > 0) {
    166 //         metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
    167 //         fireTableRowsInserted(i, i);
    168 //         return;
    169 //      }
     102    //   // Process each of the selected files in turn
     103    //   for (int i = 0; i < file_nodes.length; i++) {
     104    //      File current_file = file_nodes[i].getFile();
    170105
    171 //      // Entry already exists (increment existing count)
    172 //      if (c == 0) {
    173 //         current_metadata_value_table_entry.anotherOccurrence();
    174 //         return;
    175 //      }
    176 //   }
     106    //      // Get the metadata assigned to this file
     107    //      ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
     108    //      for (int j = 0; j < assigned_metadata.size(); j++) {
     109    //         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
     110    //         MetadataElement metadata_element = metadata_value.getMetadataElement();
    177111
    178 //   // Must go at the end of the table
    179 //   metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
    180 //   fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
    181 //       }
     112    //         // Note if there is inherited (folder-level) metadata in the table
     113    //         has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
     114
     115    //         // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     116    //         insertMetadataValueIntoTable(metadata_value);
     117
     118    //         // Remember we have seen this metadata element
     119    //         if (metadata_elements_seen.contains(metadata_element) == false) {
     120    //        metadata_elements_seen.add(metadata_element);
     121    //         }
     122    //      }
     123
     124    //      // Get the extracted metadata for this file, if desired
     125    //      if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
     126    //         ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
     127    //         for (int k = 0; k < extracted_metadata.size(); k++) {
     128    //        MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
     129
     130    //        // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     131    //        insertMetadataValueIntoTable(metadata_value);
     132    //         }
     133    //      }
     134    //   }
     135
     136    //   // Make sure each non-extracted metadata element appears in the table (even if blank)
     137    //   ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
     138    //   for (int i = 0; i < every_metadata_set_element.size(); i++) {
     139    //      MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
     140
     141    //      // If we haven't seen this metadata element and it isn't extracted, add it now
     142    //      if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
     143    //         MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
     144
     145    //         // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
     146    //         metadata_value_table_entry.setOccurrences(file_nodes.length);
     147
     148    //         // Add it to the table
     149    //         insertMetadataValueIntoTable(metadata_value_table_entry);
     150    //      }
     151    //   }
     152
     153    //   // If extracted metadata was hidden, display the warning
     154    //   if (hid_extracted_metadata) {
     155    //      showExtractedMetadataWarning();
     156    //   }
     157
     158    //   // If there is inherited metadata, display the warning
     159    //   if (has_inherited_metadata) {
     160    //      showInheritedMetadataWarning();
     161    //   }
     162    //       }
     163
     164
     165    //       /** Alphabetically inserts the new metadata value into the table */
     166    //       private void insertMetadataValueIntoTable(MetadataValue metadata_value)
     167    //       {
     168    //   for (int i = 0; i < metadata_value_table_entries.size(); i++) {
     169    //      MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
     170    //      int c = current_metadata_value_table_entry.compareTo(metadata_value);
     171
     172    //      // Insert value before existing entry
     173    //      if (c > 0) {
     174    //         metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
     175    //         fireTableRowsInserted(i, i);
     176    //         return;
     177    //      }
     178
     179    //      // Entry already exists (increment existing count)
     180    //      if (c == 0) {
     181    //         current_metadata_value_table_entry.anotherOccurrence();
     182    //         return;
     183    //      }
     184    //   }
     185
     186    //   // Must go at the end of the table
     187    //   metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
     188    //   fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
     189    //       }
    182190}

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

    r7822 r7978  
    55public class MetadataElement
    66{
    7    private String metadata_element_name_full = null;
    8    private String metadata_element_description = null;
    9    private MetadataValueTreeModel metadata_value_tree_model = null;
     7    private String metadata_element_name_full = null;
     8    private String metadata_element_description = null;
     9    private MetadataValueTreeModel metadata_value_tree_model = null;
    1010
    1111
    12    public MetadataElement(String metadata_element_name_full, String metadata_element_description)
    13    {
    14       this.metadata_element_name_full = metadata_element_name_full;
    15       this.metadata_element_description = metadata_element_description;
    16       this.metadata_value_tree_model = new MetadataValueTreeModel(this);
    17    }
     12    public MetadataElement(String metadata_element_name_full, String metadata_element_description)
     13    {
     14    this.metadata_element_name_full = metadata_element_name_full;
     15    this.metadata_element_description = metadata_element_description;
     16    this.metadata_value_tree_model = new MetadataValueTreeModel(this);
     17    }
    1818
    1919
    20    public MetadataValueTreeNode addMetadataValue(String metadata_value)
    21    {
    22       return metadata_value_tree_model.addMetadataValue(metadata_value);
    23    }
     20    public MetadataValueTreeNode addMetadataValue(String metadata_value)
     21    {
     22    return metadata_value_tree_model.addMetadataValue(metadata_value);
     23    }
    2424
    2525
    26    public String getDescription()
    27    {
    28       return metadata_element_description;
    29    }
     26    public String getDescription()
     27    {
     28    return metadata_element_description;
     29    }
    3030
    3131
    32    public MetadataValueTreeModel getMetadataValueTreeModel()
    33    {
    34       return metadata_value_tree_model;
    35    }
     32    public MetadataValueTreeModel getMetadataValueTreeModel()
     33    {
     34    return metadata_value_tree_model;
     35    }
    3636
    3737
    38    public MetadataValueTreeNode getMetadataValueTreeNode(String metadata_value)
    39    {
    40       return metadata_value_tree_model.getMetadataValueTreeNode(metadata_value);
    41    }
     38    public MetadataValueTreeNode getMetadataValueTreeNode(String metadata_value)
     39    {
     40    return metadata_value_tree_model.getMetadataValueTreeNode(metadata_value);
     41    }
    4242
    4343
    44    public String getFullName()
    45    {
    46       return metadata_element_name_full;
    47    }
     44    public String getFullName()
     45    {
     46    return metadata_element_name_full;
     47    }
    4848
    4949
    50    public String getNamespace()
    51    {
    52       return MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    53    }
     50    public String getNamespace()
     51    {
     52    return MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     53    }
    5454
    5555
    56    public String getName()
    57    {
    58       return MetadataTools.getMetadataElementName(metadata_element_name_full);
    59    }
     56    public String getName()
     57    {
     58    return MetadataTools.getMetadataElementName(metadata_element_name_full);
     59    }
    6060
    6161
    62    public boolean isExtractedMetadata()
    63    {
    64       return getNamespace().equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
    65    }
     62    public boolean isExtractedMetadata()
     63    {
     64    return getNamespace().equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
     65    }
    6666
    6767
    68    /** This is used to display the element in the value table */
    69    public String toString()
    70    {
    71       return metadata_element_name_full;
    72    }
     68    /** This is used to display the element in the value table */
     69    public String toString()
     70    {
     71    return metadata_element_name_full;
     72    }
    7373}
    74 

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

    r7827 r7978  
    1111public class MetadataSet
    1212{
    13    private ArrayList metadata_set_elements = new ArrayList();
    14    private String metadata_set_namespace = null;
     13    private ArrayList metadata_set_elements = new ArrayList();
     14    private String metadata_set_namespace = null;
    1515
    1616
    17    public MetadataSet(File metadata_set_file)
    18    {
    19       // Parse the specified metadata set file
    20       Document document = XMLTools.parseXMLFile(metadata_set_file);
    21       if (document == null) {
    22      System.err.println("Error: Could not parse metadata set file " + metadata_set_file.getAbsolutePath());
    23      return;
    24       }
     17    public MetadataSet(File metadata_set_file)
     18    {
     19    // Parse the specified metadata set file
     20    Document document = XMLTools.parseXMLFile(metadata_set_file);
     21    if (document == null) {
     22        System.err.println("Error: Could not parse metadata set file " + metadata_set_file.getAbsolutePath());
     23        return;
     24    }
    2525
    26       // Read the metadata set's namespace
    27       metadata_set_namespace = document.getDocumentElement().getAttribute("namespace");
     26    // Read the metadata set's namespace
     27    metadata_set_namespace = document.getDocumentElement().getAttribute("namespace");
    2828
    29       // Read the Element elements in the metadata set
    30       NodeList element_elements_nodelist = document.getElementsByTagName("Element");
    31       for (int i = 0; i < element_elements_nodelist.getLength(); i++) {
    32      Element current_element_element = (Element) element_elements_nodelist.item(i);
    33      String metadata_element_name = current_element_element.getAttribute("name");
    34      String metadata_element_name_full = metadata_set_namespace + MetadataTools.NAMESPACE_SEPARATOR + metadata_element_name;
    35      String metadata_element_description = "Description";  // !!! TO DO
    36      metadata_set_elements.add(new MetadataElement(metadata_element_name_full, metadata_element_description));
    37       }
    38    }
     29    // Read the Element elements in the metadata set
     30    NodeList element_elements_nodelist = document.getElementsByTagName("Element");
     31    for (int i = 0; i < element_elements_nodelist.getLength(); i++) {
     32        Element current_element_element = (Element) element_elements_nodelist.item(i);
     33        String metadata_element_name = current_element_element.getAttribute("name");
     34        String metadata_element_name_full = metadata_set_namespace + MetadataTools.NAMESPACE_SEPARATOR + metadata_element_name;
     35        String metadata_element_description = "Description";  // !!! TO DO
     36        metadata_set_elements.add(new MetadataElement(metadata_element_name_full, metadata_element_description));
     37    }
     38    }
    3939
    4040
    41    public int compareMetadataElements(MetadataElement metadata_element_a, MetadataElement metadata_element_b)
    42    {
    43       // Extracted metadata is sorted alphabetically
    44       if (metadata_set_namespace.equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE)) {
    45      return metadata_element_a.getName().compareTo(metadata_element_b.getName());
    46       }
     41    public int compareMetadataElements(MetadataElement metadata_element_a, MetadataElement metadata_element_b)
     42    {
     43    // Extracted metadata is sorted alphabetically
     44    if (metadata_set_namespace.equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE)) {
     45        return metadata_element_a.getName().compareTo(metadata_element_b.getName());
     46    }
    4747
    48       // Elements in metadata sets are sorted according to the other they are specified in the .mds file
    49       return metadata_set_elements.indexOf(metadata_element_a) - metadata_set_elements.indexOf(metadata_element_b);
    50    }
     48    // Elements in metadata sets are sorted according to the other they are specified in the .mds file
     49    return metadata_set_elements.indexOf(metadata_element_a) - metadata_set_elements.indexOf(metadata_element_b);
     50    }
    5151
    5252
    53    public MetadataElement getMetadataElement(String metadata_element_name)
    54    {
    55       // Find the desired metadata element in the list
    56       for (int i = 0; i < metadata_set_elements.size(); i++) {
    57      MetadataElement metadata_element = (MetadataElement) metadata_set_elements.get(i);
    58      if (metadata_element.getName().equals(metadata_element_name)) {
    59         return metadata_element;
    60      }
    61       }
     53    public MetadataElement getMetadataElement(String metadata_element_name)
     54    {
     55    // Find the desired metadata element in the list
     56    for (int i = 0; i < metadata_set_elements.size(); i++) {
     57        MetadataElement metadata_element = (MetadataElement) metadata_set_elements.get(i);
     58        if (metadata_element.getName().equals(metadata_element_name)) {
     59        return metadata_element;
     60        }
     61    }
    6262
    63       // Not found
    64       return null;
    65    }
     63    // Not found
     64    return null;
     65    }
    6666
    6767
    68    public ArrayList getMetadataSetElements()
    69    {
    70       return metadata_set_elements;
    71    }
     68    public ArrayList getMetadataSetElements()
     69    {
     70    return metadata_set_elements;
     71    }
    7272
    7373   
    74    public String getNamespace()
    75    {
    76       return metadata_set_namespace;
    77    }
     74    public String getNamespace()
     75    {
     76    return metadata_set_namespace;
     77    }
    7878}

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

    r7822 r7978  
    99public class MetadataSetManager
    1010{
    11    static public final String EXTRACTED_METADATA_NAMESPACE = "ex";
     11    static public final String EXTRACTED_METADATA_NAMESPACE = "ex";
    1212
    13    static private ArrayList metadata_sets = new ArrayList();
     13    static private ArrayList metadata_sets = new ArrayList();
    1414
    1515
    16    static public void clearMetadataSets()
    17    {
    18       metadata_sets.clear();
    19    }
     16    static public void clearMetadataSets()
     17    {
     18    metadata_sets.clear();
     19    }
    2020
    2121
    22    static public int compareMetadataElements(MetadataElement metadata_element_a, MetadataElement metadata_element_b)
    23    {
    24       // First compare the namespaces of the two metadata elements
    25       if (!metadata_element_a.getNamespace().equals(metadata_element_b.getNamespace())) {
    26      return metadata_element_a.getNamespace().compareTo(metadata_element_b.getNamespace());
    27       }
     22    static public int compareMetadataElements(MetadataElement metadata_element_a, MetadataElement metadata_element_b)
     23    {
     24    // First compare the namespaces of the two metadata elements
     25    if (!metadata_element_a.getNamespace().equals(metadata_element_b.getNamespace())) {
     26        return metadata_element_a.getNamespace().compareTo(metadata_element_b.getNamespace());
     27    }
    2828
    29       // Otherwise compare the two elements within the one set
    30       MetadataSet metadata_set = getMetadataSet(metadata_element_a.getNamespace());
    31       return metadata_set.compareMetadataElements(metadata_element_a, metadata_element_b);
    32    }
     29    // Otherwise compare the two elements within the one set
     30    MetadataSet metadata_set = getMetadataSet(metadata_element_a.getNamespace());
     31    return metadata_set.compareMetadataElements(metadata_element_a, metadata_element_b);
     32    }
    3333
    3434
    35    static public ArrayList getEveryMetadataSetElement()
    36    {
    37       ArrayList every_metadata_set_element = new ArrayList();
     35    static public ArrayList getEveryMetadataSetElement()
     36    {
     37    ArrayList every_metadata_set_element = new ArrayList();
    3838
    39       for (int i = 0; i < metadata_sets.size(); i++) {
    40      MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
    41      every_metadata_set_element.addAll(metadata_set.getMetadataSetElements());
    42       }
     39    for (int i = 0; i < metadata_sets.size(); i++) {
     40        MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
     41        every_metadata_set_element.addAll(metadata_set.getMetadataSetElements());
     42    }
    4343
    44       return every_metadata_set_element;
    45    }
     44    return every_metadata_set_element;
     45    }
    4646
    4747   
    48    static public MetadataSet getMetadataSet(String metadata_set_namespace)
    49    {
    50       // Find the desired metadata set in the list
    51       for (int i = 0; i < metadata_sets.size(); i++) {
    52      MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
    53      if (metadata_set.getNamespace().equals(metadata_set_namespace)) {
    54         return metadata_set;
    55      }
    56       }
     48    static public MetadataSet getMetadataSet(String metadata_set_namespace)
     49    {
     50    // Find the desired metadata set in the list
     51    for (int i = 0; i < metadata_sets.size(); i++) {
     52        MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
     53        if (metadata_set.getNamespace().equals(metadata_set_namespace)) {
     54        return metadata_set;
     55        }
     56    }
    5757
    58       // Not found
    59       System.err.println("No metadata set with namespace " + metadata_set_namespace + " found.");
    60       return null;
    61    }
     58    // Not found
     59    System.err.println("No metadata set with namespace " + metadata_set_namespace + " found.");
     60    return null;
     61    }
    6262
    6363
    64    static public void loadMetadataSets(File directory)
    65    {
    66       // Look recursively at each subfile of the directory for .mds files
    67       File[] directory_files = directory.listFiles();
    68       for (int i = 0; i < directory_files.length; i++) {
    69      File child_file = directory_files[i];
    70      if (child_file.isDirectory()) {
    71         loadMetadataSets(child_file);
    72      }
    73      else if (child_file.getName().endsWith(".mds")) {
    74         loadMetadataSet(child_file);
    75      }
    76       }
    77    }
     64    static public void loadMetadataSets(File directory)
     65    {
     66    // Look recursively at each subfile of the directory for .mds files
     67    File[] directory_files = directory.listFiles();
     68    for (int i = 0; i < directory_files.length; i++) {
     69        File child_file = directory_files[i];
     70        if (child_file.isDirectory()) {
     71        loadMetadataSets(child_file);
     72        }
     73        else if (child_file.getName().endsWith(".mds")) {
     74        loadMetadataSet(child_file);
     75        }
     76    }
     77    }
    7878
    7979
    80    static private void loadMetadataSet(File metadata_set_file)
    81    {
    82       MetadataSet metadata_set = new MetadataSet(metadata_set_file);
    83       metadata_sets.add(metadata_set);
    84    }
     80    static private void loadMetadataSet(File metadata_set_file)
     81    {
     82    MetadataSet metadata_set = new MetadataSet(metadata_set_file);
     83    metadata_sets.add(metadata_set);
     84    }
    8585}

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

    r7822 r7978  
    55public class MetadataTools
    66{
    7    static final public String NAMESPACE_SEPARATOR = ".";
     7    static final public String NAMESPACE_SEPARATOR = ".";
    88
    99
    10    static public String getMetadataSetNamespace(String metadata_element_name_full)
    11    {
    12       // Full element name contains namespace
    13       if (metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) != -1) {
    14      return metadata_element_name_full.substring(0, metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR));
    15       }
     10    static public String getMetadataSetNamespace(String metadata_element_name_full)
     11    {
     12    // Full element name contains namespace
     13    if (metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) != -1) {
     14        return metadata_element_name_full.substring(0, metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR));
     15    }
    1616
    17       // No namespace
    18       return "";
    19    }
     17    // No namespace
     18    return "";
     19    }
    2020
    2121
    22    static public String getMetadataElementName(String metadata_element_name_full)
    23    {
    24       // Full element name contains namespace
    25       if (metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) != -1) {
    26      return metadata_element_name_full.substring(metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) + 1);
    27       }
     22    static public String getMetadataElementName(String metadata_element_name_full)
     23    {
     24    // Full element name contains namespace
     25    if (metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) != -1) {
     26        return metadata_element_name_full.substring(metadata_element_name_full.indexOf(NAMESPACE_SEPARATOR) + 1);
     27    }
    2828
    29       // No namespace
    30       return metadata_element_name_full;     
    31    }
     29    // No namespace
     30    return metadata_element_name_full;     
     31    }
    3232}
    33 

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

    r7827 r7978  
    77/** This class represents one metadata (element, value) pair */
    88public class MetadataValue
    9    implements Comparable
     9    implements Comparable
    1010{
    11    /** The folder that this piece of metadata was inherited from, if applicable */
    12    private File folder_metadata_inherited_from = null;
    13    private MetadataElement metadata_element = null;
    14    private MetadataValueTreeNode metadata_value_tree_node = null;
    15    private boolean is_accumulating_metadata = false;
     11    /** The folder that this piece of metadata was inherited from, if applicable */
     12    private File folder_metadata_inherited_from = null;
     13    private MetadataElement metadata_element = null;
     14    private MetadataValueTreeNode metadata_value_tree_node = null;
     15    private boolean is_accumulating_metadata = false;
    1616
    1717
    18    public MetadataValue(MetadataElement metadata_element, MetadataValueTreeNode metadata_value_tree_node)
    19    {
    20       this.metadata_element = metadata_element;
    21       this.metadata_value_tree_node = metadata_value_tree_node;
    22    }
     18    public MetadataValue(MetadataElement metadata_element, MetadataValueTreeNode metadata_value_tree_node)
     19    {
     20    this.metadata_element = metadata_element;
     21    this.metadata_value_tree_node = metadata_value_tree_node;
     22    }
    2323
    2424
    25    public int compareTo(Object metadata_value_object)
    26    {
    27       MetadataValue metadata_value = (MetadataValue) metadata_value_object;
     25    public int compareTo(Object metadata_value_object)
     26    {
     27    MetadataValue metadata_value = (MetadataValue) metadata_value_object;
    2828
    29       // First compare the metadata elements
    30       int c = MetadataSetManager.compareMetadataElements(this.getMetadataElement(), metadata_value.getMetadataElement());
    31       if (c != 0) {
    32      return c;
    33       }
     29    // First compare the metadata elements
     30    int c = MetadataSetManager.compareMetadataElements(this.getMetadataElement(), metadata_value.getMetadataElement());
     31    if (c != 0) {
     32        return c;
     33    }
    3434
    35       // Then use the metadata values
    36       return this.getFullValue().compareTo(metadata_value.getFullValue());
    37    }
     35    // Then use the metadata values
     36    return this.getFullValue().compareTo(metadata_value.getFullValue());
     37    }
    3838
    3939
    40    public File getFolderMetadataInheritedFrom()
    41    {
    42       return folder_metadata_inherited_from;
    43    }
     40    public File getFolderMetadataInheritedFrom()
     41    {
     42    return folder_metadata_inherited_from;
     43    }
    4444
    4545
    46    public MetadataElement getMetadataElement()
    47    {
    48       return metadata_element;
    49    }
     46    public MetadataElement getMetadataElement()
     47    {
     48    return metadata_element;
     49    }
    5050
    5151
    52    public String getFullValue()
    53    {
    54       return metadata_value_tree_node.getFullValue();
    55    }
     52    public String getFullValue()
     53    {
     54    return metadata_value_tree_node.getFullValue();
     55    }
    5656
    5757
    58    public String getValue()
    59    {
    60       return metadata_value_tree_node.getValue();
    61    }
     58    public String getValue()
     59    {
     60    return metadata_value_tree_node.getValue();
     61    }
    6262
    6363
    64    public MetadataValueTreeNode getMetadataValueTreeNode()
    65    {
    66       return metadata_value_tree_node;
    67    }
     64    public MetadataValueTreeNode getMetadataValueTreeNode()
     65    {
     66    return metadata_value_tree_node;
     67    }
    6868
    6969
    70    public void inheritsMetadataFromFolder(File folder_metadata_inherited_from)
    71    {
    72       this.folder_metadata_inherited_from = folder_metadata_inherited_from;
    73    }
     70    public void inheritsMetadataFromFolder(File folder_metadata_inherited_from)
     71    {
     72    this.folder_metadata_inherited_from = folder_metadata_inherited_from;
     73    }
    7474
    7575
    76    public boolean isAccumulatingMetadata()
    77    {
    78       return is_accumulating_metadata;
    79    }
     76    public boolean isAccumulatingMetadata()
     77    {
     78    return is_accumulating_metadata;
     79    }
    8080
    8181
    82    public boolean isInheritedMetadata()
    83    {
    84       return (folder_metadata_inherited_from != null);
    85    }
     82    public boolean isInheritedMetadata()
     83    {
     84    return (folder_metadata_inherited_from != null);
     85    }
    8686
    8787
    88    public void setIsAccumulatingMetadata(boolean is_accumulating_metadata)
    89    {
    90       this.is_accumulating_metadata = is_accumulating_metadata;
    91    }
     88    public void setIsAccumulatingMetadata(boolean is_accumulating_metadata)
     89    {
     90    this.is_accumulating_metadata = is_accumulating_metadata;
     91    }
    9292}
    93 

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

    r7822 r7978  
    77/** This class represents one metadata (element, value) pair */
    88public class MetadataValueTableEntry
    9    extends MetadataValue
     9    extends MetadataValue
    1010{
    11    private int occurrences = 0;
     11    private int occurrences = 0;
    1212
    1313
    14    public MetadataValueTableEntry(MetadataElement metadata_element, MetadataValueTreeNode metadata_value_tree_node)
    15    {
    16       super(metadata_element, metadata_value_tree_node);
     14    public MetadataValueTableEntry(MetadataElement metadata_element, MetadataValueTreeNode metadata_value_tree_node)
     15    {
     16    super(metadata_element, metadata_value_tree_node);
    1717
    18       occurrences = 1;
    19    }
     18    occurrences = 1;
     19    }
    2020
    2121
    22    public MetadataValueTableEntry(MetadataValue metadata_value)
    23    {
    24       this(metadata_value.getMetadataElement(), metadata_value.getMetadataValueTreeNode());
    25       inheritsMetadataFromFolder(metadata_value.getFolderMetadataInheritedFrom());
    26    }
     22    public MetadataValueTableEntry(MetadataValue metadata_value)
     23    {
     24    this(metadata_value.getMetadataElement(), metadata_value.getMetadataValueTreeNode());
     25    inheritsMetadataFromFolder(metadata_value.getFolderMetadataInheritedFrom());
     26    }
    2727
    2828
    29    public void anotherOccurrence()
    30    {
    31       occurrences++;
    32    }
     29    public void anotherOccurrence()
     30    {
     31    occurrences++;
     32    }
    3333
    3434
    35    public int getOccurrences()
    36    {
    37       return occurrences;
    38    }
     35    public int getOccurrences()
     36    {
     37    return occurrences;
     38    }
    3939
    4040
    41    public void setOccurrences(int occurrences)
    42    {
    43       this.occurrences = occurrences;
    44    }
     41    public void setOccurrences(int occurrences)
     42    {
     43    this.occurrences = occurrences;
     44    }
    4545}
    46 

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

    r7827 r7978  
    1515
    1616public class MetadataValueTableModel
    17    extends AbstractTableModel
     17    extends AbstractTableModel
    1818{
    19    /** The FileNodes this model is built for */
    20    private FileNode[] file_nodes = null;
    21    /** The list of MetadataValueTableEntries in the table */
    22    private ArrayList metadata_value_table_entries = new ArrayList();
    23 
    24    static final private String[] COLUMN_NAMES = {"", Dictionary.get("Metadata.Element"),  Dictionary.get("Metadata.Value")};
    25 
    26 
    27    /** Returns the number of columns in this table. */
    28    public int getColumnCount()
    29    {
    30       return COLUMN_NAMES.length;
    31    }
    32 
    33 
    34    /** Retrieves the name of the specified column. */
    35    public String getColumnName(int col)
    36    {
    37       return COLUMN_NAMES[col];
    38    }
    39 
    40 
    41    /* Called to retrieve the MetadataValueTableEntry at a certain row. Usually caused by the user selecting a row in the table. It is synchronized so that the model doesn't up and change while we're trying to retrieve the indicated element. */
    42    public synchronized MetadataValueTableEntry getMetadataValueTableEntry(int row)
    43    {
    44       if (row >= 0 && row < metadata_value_table_entries.size()) {
    45      return (MetadataValueTableEntry) metadata_value_table_entries.get(row);
    46       }
    47 
    48       return null;
    49    }
    50 
    51 
    52    /** Returns the number of rows in this table. */
    53    public int getRowCount()
    54    {
    55       return metadata_value_table_entries.size();
    56    }
    57 
    58 
    59    /** Returns the cell value at a given row and column as an Object. */
    60    public Object getValueAt(int row, int col)
    61    {
    62       // Check values are reasonable
    63       if (row < 0 || row >= metadata_value_table_entries.size() || col < 0 || col >= COLUMN_NAMES.length) {
    64      return null;
    65       }
    66 
    67       MetadataValueTableEntry metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(row);
    68       if (col == 0 && metadata_value_table_entry.isInheritedMetadata()) {
    69      return metadata_value_table_entry.getFolderMetadataInheritedFrom();
    70       }
    71 
    72       if (col == 1) {
    73      return metadata_value_table_entry.getMetadataElement();
    74       }
    75 
    76       if (col == 2) {
    77      return metadata_value_table_entry.getFullValue();
    78       }
    79 
    80       return null;
    81    }
    82 
    83 
    84    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
    85    public boolean isCommon(MetadataValueTableEntry metadata_value_table_entry)
    86    {
    87       return (file_nodes != null && metadata_value_table_entry.getOccurrences() == file_nodes.length);
    88    }
    89 
    90 
    91    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
    92    public boolean isCommon(int row)
    93    {
    94       if (row >= 0 && row < metadata_value_table_entries.size()) {
    95      return isCommon((MetadataValueTableEntry) metadata_value_table_entries.get(row));
    96       }
    97 
    98       return false;
    99    }
    100 
    101 
    102    public void rebuild(FileNode[] file_nodes)
    103    {
    104       metadata_value_table_entries.clear();
    105 
    106       if (!Gatherer.c_man.ready()) {
    107      Gatherer.println("Not ready!");
    108      return;
    109       }
    110 
    111       this.file_nodes = file_nodes;
    112       if (file_nodes != null && file_nodes.length > 0) {
    113      // Create model builder
    114      MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
    115      builder.run();
    116       }
    117    }
    118 
    119 
    120    private class MetadataValueTableModelBuilder
    121    {
    122       public void run()
    123       {
    124      // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
    125      boolean hid_extracted_metadata = false;
    126      boolean has_inherited_metadata = false;
    127      ArrayList metadata_elements_seen = new ArrayList();
    128 
    129      // Process each of the selected files in turn
    130      for (int i = 0; i < file_nodes.length; i++) {
    131         File current_file = file_nodes[i].getFile();
    132 
    133         // Get the metadata assigned to this file
    134         ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
    135         for (int j = 0; j < assigned_metadata.size(); j++) {
    136            MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
    137            MetadataElement metadata_element = metadata_value.getMetadataElement();
    138 
    139            // Note if there is inherited (folder-level) metadata in the table
    140            has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
    141 
    142            // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    143            insertMetadataValueIntoTable(metadata_value);
    144 
    145            // Remember we have seen this metadata element
    146            if (metadata_elements_seen.contains(metadata_element) == false) {
    147           metadata_elements_seen.add(metadata_element);
    148            }
    149         }
    150 
    151         // Get the extracted metadata for this file, if desired
    152         if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
    153            ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
    154            for (int k = 0; k < extracted_metadata.size(); k++) {
    155           MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
    156 
    157           // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    158           insertMetadataValueIntoTable(metadata_value);
    159            }
    160         }
    161      }
    162 
    163      // Make sure each non-extracted metadata element appears in the table (even if blank)
    164      ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
    165      for (int i = 0; i < every_metadata_set_element.size(); i++) {
    166         MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
    167 
    168         // If we haven't seen this metadata element and it isn't extracted, add it now
    169         if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
    170            MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
    171 
    172            // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
    173            metadata_value_table_entry.setOccurrences(file_nodes.length);
    174 
    175            // Add it to the table
    176            insertMetadataValueIntoTable(metadata_value_table_entry);
    177         }
    178      }
    179 
    180      // If extracted metadata was hidden, display the warning
    181      if (hid_extracted_metadata) {
    182         showExtractedMetadataWarning();
    183      }
    184 
    185      // If there is inherited metadata, display the warning
    186      if (has_inherited_metadata) {
    187         showInheritedMetadataWarning();
    188      }
    189       }
    190 
    191 
    192       /** Alphabetically inserts the new metadata value into the table */
    193       private void insertMetadataValueIntoTable(MetadataValue metadata_value)
    194       {
    195      for (int i = 0; i < metadata_value_table_entries.size(); i++) {
    196         MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
    197         int c = current_metadata_value_table_entry.compareTo(metadata_value);
    198 
    199         // Insert value before existing entry
    200         if (c > 0) {
    201            metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
    202            fireTableRowsInserted(i, i);
    203            return;
    204         }
    205 
    206         // Entry already exists (increment existing count)
    207         if (c == 0) {
    208            current_metadata_value_table_entry.anotherOccurrence();
    209            return;
    210         }
    211      }
    212 
    213      // Must go at the end of the table
    214      metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
    215      fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
    216       }
    217 
    218 
    219       private void showExtractedMetadataWarning()
    220       {
    221      Runnable task = new Runnable() {
    222            public void run() {
    223           WarningDialog dialog = new WarningDialog("warning.ExtractedMetadata", false);
    224           dialog.display();
    225           dialog.dispose();
    226           dialog = null;
    227            }
    228         };
    229      SwingUtilities.invokeLater(task);
    230       }
    231 
    232 
    233       private void showInheritedMetadataWarning()
    234       {
    235      Runnable task = new Runnable() {
    236            public void run() {
    237           WarningDialog dialog = new WarningDialog("warning.InheritedMetadata", false);
    238           dialog.display();
    239           dialog.dispose();
    240           dialog = null;
    241            }
    242         };
    243      SwingUtilities.invokeLater(task);
    244       }
    245    }
     19    /** The FileNodes this model is built for */
     20    private FileNode[] file_nodes = null;
     21    /** The list of MetadataValueTableEntries in the table */
     22    private ArrayList metadata_value_table_entries = new ArrayList();
     23
     24    static final private String[] COLUMN_NAMES = {"", Dictionary.get("Metadata.Element"),  Dictionary.get("Metadata.Value")};
     25
     26
     27    /** Returns the number of columns in this table. */
     28    public int getColumnCount()
     29    {
     30    return COLUMN_NAMES.length;
     31    }
     32
     33
     34    /** Retrieves the name of the specified column. */
     35    public String getColumnName(int col)
     36    {
     37    return COLUMN_NAMES[col];
     38    }
     39
     40
     41    /* Called to retrieve the MetadataValueTableEntry at a certain row. Usually caused by the user selecting a row in the table. It is synchronized so that the model doesn't up and change while we're trying to retrieve the indicated element. */
     42    public synchronized MetadataValueTableEntry getMetadataValueTableEntry(int row)
     43    {
     44    if (row >= 0 && row < metadata_value_table_entries.size()) {
     45        return (MetadataValueTableEntry) metadata_value_table_entries.get(row);
     46    }
     47
     48    return null;
     49    }
     50
     51
     52    /** Returns the number of rows in this table. */
     53    public int getRowCount()
     54    {
     55    return metadata_value_table_entries.size();
     56    }
     57
     58
     59    /** Returns the cell value at a given row and column as an Object. */
     60    public Object getValueAt(int row, int col)
     61    {
     62    // Check values are reasonable
     63    if (row < 0 || row >= metadata_value_table_entries.size() || col < 0 || col >= COLUMN_NAMES.length) {
     64        return null;
     65    }
     66
     67    MetadataValueTableEntry metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(row);
     68    if (col == 0 && metadata_value_table_entry.isInheritedMetadata()) {
     69        return metadata_value_table_entry.getFolderMetadataInheritedFrom();
     70    }
     71
     72    if (col == 1) {
     73        return metadata_value_table_entry.getMetadataElement();
     74    }
     75
     76    if (col == 2) {
     77        return metadata_value_table_entry.getFullValue();
     78    }
     79
     80    return null;
     81    }
     82
     83
     84    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
     85    public boolean isCommon(MetadataValueTableEntry metadata_value_table_entry)
     86    {
     87    return (file_nodes != null && metadata_value_table_entry.getOccurrences() == file_nodes.length);
     88    }
     89
     90
     91    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
     92    public boolean isCommon(int row)
     93    {
     94    if (row >= 0 && row < metadata_value_table_entries.size()) {
     95        return isCommon((MetadataValueTableEntry) metadata_value_table_entries.get(row));
     96    }
     97
     98    return false;
     99    }
     100
     101
     102    public void rebuild(FileNode[] file_nodes)
     103    {
     104    metadata_value_table_entries.clear();
     105
     106    if (!Gatherer.c_man.ready()) {
     107        Gatherer.println("Not ready!");
     108        return;
     109    }
     110
     111    this.file_nodes = file_nodes;
     112    if (file_nodes != null && file_nodes.length > 0) {
     113        // Create model builder
     114        MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
     115        builder.run();
     116    }
     117    }
     118
     119
     120    private class MetadataValueTableModelBuilder
     121    {
     122    public void run()
     123    {
     124        // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
     125        boolean hid_extracted_metadata = false;
     126        boolean has_inherited_metadata = false;
     127        ArrayList metadata_elements_seen = new ArrayList();
     128
     129        // Process each of the selected files in turn
     130        for (int i = 0; i < file_nodes.length; i++) {
     131        File current_file = file_nodes[i].getFile();
     132
     133        // Get the metadata assigned to this file
     134        ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
     135        for (int j = 0; j < assigned_metadata.size(); j++) {
     136            MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
     137            MetadataElement metadata_element = metadata_value.getMetadataElement();
     138
     139            // Note if there is inherited (folder-level) metadata in the table
     140            has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
     141
     142            // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     143            insertMetadataValueIntoTable(metadata_value);
     144
     145            // Remember we have seen this metadata element
     146            if (metadata_elements_seen.contains(metadata_element) == false) {
     147            metadata_elements_seen.add(metadata_element);
     148            }
     149        }
     150
     151        // Get the extracted metadata for this file, if desired
     152        if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
     153            ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
     154            for (int k = 0; k < extracted_metadata.size(); k++) {
     155            MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
     156
     157            // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     158            insertMetadataValueIntoTable(metadata_value);
     159            }
     160        }
     161        }
     162
     163        // Make sure each non-extracted metadata element appears in the table (even if blank)
     164        ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
     165        for (int i = 0; i < every_metadata_set_element.size(); i++) {
     166        MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
     167
     168        // If we haven't seen this metadata element and it isn't extracted, add it now
     169        if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
     170            MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
     171
     172            // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
     173            metadata_value_table_entry.setOccurrences(file_nodes.length);
     174
     175            // Add it to the table
     176            insertMetadataValueIntoTable(metadata_value_table_entry);
     177        }
     178        }
     179
     180        // If extracted metadata was hidden, display the warning
     181        if (hid_extracted_metadata) {
     182        showExtractedMetadataWarning();
     183        }
     184
     185        // If there is inherited metadata, display the warning
     186        if (has_inherited_metadata) {
     187        showInheritedMetadataWarning();
     188        }
     189    }
     190
     191
     192    /** Alphabetically inserts the new metadata value into the table */
     193    private void insertMetadataValueIntoTable(MetadataValue metadata_value)
     194    {
     195        for (int i = 0; i < metadata_value_table_entries.size(); i++) {
     196        MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
     197        int c = current_metadata_value_table_entry.compareTo(metadata_value);
     198
     199        // Insert value before existing entry
     200        if (c > 0) {
     201            metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
     202            fireTableRowsInserted(i, i);
     203            return;
     204        }
     205
     206        // Entry already exists (increment existing count)
     207        if (c == 0) {
     208            current_metadata_value_table_entry.anotherOccurrence();
     209            return;
     210        }
     211        }
     212
     213        // Must go at the end of the table
     214        metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
     215        fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
     216    }
     217
     218
     219    private void showExtractedMetadataWarning()
     220    {
     221        Runnable task = new Runnable() {
     222            public void run() {
     223            WarningDialog dialog = new WarningDialog("warning.ExtractedMetadata", false);
     224            dialog.display();
     225            dialog.dispose();
     226            dialog = null;
     227            }
     228        };
     229        SwingUtilities.invokeLater(task);
     230    }
     231
     232
     233    private void showInheritedMetadataWarning()
     234    {
     235        Runnable task = new Runnable() {
     236            public void run() {
     237            WarningDialog dialog = new WarningDialog("warning.InheritedMetadata", false);
     238            dialog.display();
     239            dialog.dispose();
     240            dialog = null;
     241            }
     242        };
     243        SwingUtilities.invokeLater(task);
     244    }
     245    }
    246246}

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

    r7822 r7978  
    88/** This class represents all the metadata values for one metadata element */
    99public class MetadataValueTreeModel
    10    extends DefaultTreeModel
     10    extends DefaultTreeModel
    1111{
    12    public MetadataValueTreeModel(MetadataElement metadata_element)
    13    {
    14       // The root node of the value tree is the MetadataElement it represents
    15       super(new MetadataValueTreeNode(metadata_element));
    16    }
     12    public MetadataValueTreeModel(MetadataElement metadata_element)
     13    {
     14    // The root node of the value tree is the MetadataElement it represents
     15    super(new MetadataValueTreeNode(metadata_element));
     16    }
    1717
    1818
    19    public MetadataValueTreeNode addMetadataValue(String metadata_value)
    20    {
    21       return addMetadataValueInternal((MetadataValueTreeNode) root, metadata_value);
    22    }
     19    public MetadataValueTreeNode addMetadataValue(String metadata_value)
     20    {
     21    return addMetadataValueInternal((MetadataValueTreeNode) root, metadata_value);
     22    }
    2323
    2424
    25    private MetadataValueTreeNode addMetadataValueInternal(MetadataValueTreeNode parent_metadata_value_tree_node, String metadata_value_remaining)
    26    {
    27       // Split the metadata value into a hierarchy
    28       int split_point = metadata_value_remaining.indexOf(MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
    29       String metadata_value = ((split_point == -1) ? metadata_value_remaining : metadata_value_remaining.substring(0, split_point));
    30       metadata_value_remaining = ((split_point == -1) ? "" : metadata_value_remaining.substring(split_point + 1));
     25    private MetadataValueTreeNode addMetadataValueInternal(MetadataValueTreeNode parent_metadata_value_tree_node, String metadata_value_remaining)
     26    {
     27    // Split the metadata value into a hierarchy
     28    int split_point = metadata_value_remaining.indexOf(MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
     29    String metadata_value = ((split_point == -1) ? metadata_value_remaining : metadata_value_remaining.substring(0, split_point));
     30    metadata_value_remaining = ((split_point == -1) ? "" : metadata_value_remaining.substring(split_point + 1));
    3131
    32       // Add the value into the tree in the correct place (sorted)
    33       MetadataValueTreeNode metadata_value_tree_node = null;
    34       for (int i = 0; i < parent_metadata_value_tree_node.getChildCount(); i++) {
    35      MetadataValueTreeNode child_metadata_value_tree_node = (MetadataValueTreeNode) parent_metadata_value_tree_node.getChildAt(i);
    36      int c = metadata_value.compareTo(child_metadata_value_tree_node.getValue());
     32    // Add the value into the tree in the correct place (sorted)
     33    MetadataValueTreeNode metadata_value_tree_node = null;
     34    for (int i = 0; i < parent_metadata_value_tree_node.getChildCount(); i++) {
     35        MetadataValueTreeNode child_metadata_value_tree_node = (MetadataValueTreeNode) parent_metadata_value_tree_node.getChildAt(i);
     36        int c = metadata_value.compareTo(child_metadata_value_tree_node.getValue());
    3737
    38      // Insert node before existing value
    39      if (c < 0) {
     38        // Insert node before existing value
     39        if (c < 0) {
     40        metadata_value_tree_node = new MetadataValueTreeNode(metadata_value);
     41        parent_metadata_value_tree_node.insert(metadata_value_tree_node, i);
     42        break;
     43        }
     44
     45        // Node already exists (don't add again)
     46        if (c == 0) {
     47        metadata_value_tree_node = child_metadata_value_tree_node;
     48        break;
     49        }
     50    }
     51
     52    // If no node has been added yet, it must go at the end of the list
     53    if (metadata_value_tree_node == null) {
    4054        metadata_value_tree_node = new MetadataValueTreeNode(metadata_value);
    41         parent_metadata_value_tree_node.insert(metadata_value_tree_node, i);
    42         break;
    43      }
     55        parent_metadata_value_tree_node.add(metadata_value_tree_node);
     56    }
    4457
    45      // Node already exists (don't add again)
    46      if (c == 0) {
    47         metadata_value_tree_node = child_metadata_value_tree_node;
    48         break;
    49      }
    50       }
     58    // If there is some of the metadata value remaining, add that hierarchically
     59    if (!metadata_value_remaining.equals("")) {
     60        metadata_value_tree_node = addMetadataValueInternal(metadata_value_tree_node, metadata_value_remaining);
     61    }
    5162
    52       // If no node has been added yet, it must go at the end of the list
    53       if (metadata_value_tree_node == null) {
    54      metadata_value_tree_node = new MetadataValueTreeNode(metadata_value);
    55      parent_metadata_value_tree_node.add(metadata_value_tree_node);
    56       }
    57 
    58       // If there is some of the metadata value remaining, add that hierarchically
    59       if (!metadata_value_remaining.equals("")) {
    60      metadata_value_tree_node = addMetadataValueInternal(metadata_value_tree_node, metadata_value_remaining);
    61       }
    62 
    63       return metadata_value_tree_node;
    64    }
     63    return metadata_value_tree_node;
     64    }
    6565
    6666
    67    public MetadataValueTreeNode getMetadataValueTreeNode(String metadata_value)
    68    {
    69       return getMetadataValueTreeNodeInternal((MetadataValueTreeNode) root, metadata_value);
    70    }
     67    public MetadataValueTreeNode getMetadataValueTreeNode(String metadata_value)
     68    {
     69    return getMetadataValueTreeNodeInternal((MetadataValueTreeNode) root, metadata_value);
     70    }
    7171
    7272
    73    private MetadataValueTreeNode getMetadataValueTreeNodeInternal(MetadataValueTreeNode parent_metadata_value_tree_node, String metadata_value_remaining)
    74    {
    75       // Split the metadata value into a hierarchy
    76       int split_point = metadata_value_remaining.indexOf(MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
    77       String metadata_value = ((split_point == -1) ? metadata_value_remaining : metadata_value_remaining.substring(0, split_point));
    78       metadata_value_remaining = ((split_point == -1) ? "" : metadata_value_remaining.substring(split_point + 1));
     73    private MetadataValueTreeNode getMetadataValueTreeNodeInternal(MetadataValueTreeNode parent_metadata_value_tree_node, String metadata_value_remaining)
     74    {
     75    // Split the metadata value into a hierarchy
     76    int split_point = metadata_value_remaining.indexOf(MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
     77    String metadata_value = ((split_point == -1) ? metadata_value_remaining : metadata_value_remaining.substring(0, split_point));
     78    metadata_value_remaining = ((split_point == -1) ? "" : metadata_value_remaining.substring(split_point + 1));
    7979
    80       // Find the value in the tree in the correct place (sorted)
    81       MetadataValueTreeNode metadata_value_tree_node = null;
    82       for (int i = 0; i < parent_metadata_value_tree_node.getChildCount(); i++) {
    83      MetadataValueTreeNode child_metadata_value_tree_node = (MetadataValueTreeNode) parent_metadata_value_tree_node.getChildAt(i);
    84      int c = metadata_value.compareTo(child_metadata_value_tree_node.getValue());
     80    // Find the value in the tree in the correct place (sorted)
     81    MetadataValueTreeNode metadata_value_tree_node = null;
     82    for (int i = 0; i < parent_metadata_value_tree_node.getChildCount(); i++) {
     83        MetadataValueTreeNode child_metadata_value_tree_node = (MetadataValueTreeNode) parent_metadata_value_tree_node.getChildAt(i);
     84        int c = metadata_value.compareTo(child_metadata_value_tree_node.getValue());
    8585
    86      // Node doesn't exist in the tree
    87      if (c < 0) {
     86        // Node doesn't exist in the tree
     87        if (c < 0) {
     88        return null;
     89        }
     90     
     91        // Node exists
     92        if (c == 0) {
     93        metadata_value_tree_node = child_metadata_value_tree_node;
     94        break;
     95        }
     96    }
     97
     98    // If no node has been found, it doesn't exist
     99    if (metadata_value_tree_node == null) {
    88100        return null;
    89      }
    90      
    91      // Node exists
    92      if (c == 0) {
    93         metadata_value_tree_node = child_metadata_value_tree_node;
    94         break;
    95      }
    96       }
     101    }
    97102
    98       // If no node has been found, it doesn't exist
    99       if (metadata_value_tree_node == null) {
    100      return null;
    101       }
     103    // If there is some of the metadata value remaining, find that recursively
     104    if (!metadata_value_remaining.equals("")) {
     105        metadata_value_tree_node = getMetadataValueTreeNodeInternal(metadata_value_tree_node, metadata_value_remaining);
     106    }
    102107
    103       // If there is some of the metadata value remaining, find that hierarchically
    104       if (!metadata_value_remaining.equals("")) {
    105      metadata_value_tree_node = getMetadataValueTreeNodeInternal(metadata_value_tree_node, metadata_value_remaining);
    106       }
    107 
    108       return metadata_value_tree_node;
    109    }
     108    return metadata_value_tree_node;
     109    }
    110110}

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

    r7822 r7978  
    77/** This class represents one Metadata value */
    88public class MetadataValueTreeNode
    9    extends DefaultMutableTreeNode
     9    extends DefaultMutableTreeNode
    1010{
    11    static public final String METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN = "|";
     11    static public final String METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN = "|";
    1212
    13    private String value = null;
     13    private String value = null;
    1414
    1515
    16    public MetadataValueTreeNode(Object object)
    17    {
    18       super(object);
    19    }
     16    public MetadataValueTreeNode(Object object)
     17    {
     18    super(object);
     19    }
    2020
    2121
    22    public MetadataValueTreeNode(String value)
    23    {
    24       this.value = value;
    25    }
     22    public MetadataValueTreeNode(String value)
     23    {
     24    this.value = value;
     25    }
    2626
    2727
    28    public String getFullValue()
    29    {
    30       if (parent == null) {
    31      return "";
    32       }
     28    public String getFullValue()
     29    {
     30    if (parent == null) {
     31        return "";
     32    }
    3333
    34       if (((MetadataValueTreeNode) parent).isRoot()) {
    35      return value;
    36       }
     34    if (((MetadataValueTreeNode) parent).isRoot()) {
     35        return value;
     36    }
    3737
    38       return ((MetadataValueTreeNode) parent).getFullValue() + METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN + value;
    39    }
     38    return ((MetadataValueTreeNode) parent).getFullValue() + METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN + value;
     39    }
    4040
    4141
    42    public String getValue()
    43    {
    44       return value;
    45    }
     42    public String getValue()
     43    {
     44    return value;
     45    }
    4646
    4747
    48    /** This is used to display the node in the value tree */
    49    public String toString()
    50    {
    51       return value;
    52    }
     48    /** This is used to display the node in the value tree */
     49    public String toString()
     50    {
     51    return value;
     52    }
    5353}

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

    r7827 r7978  
    1010/** This class represents one metadata.xml file */
    1111public class MetadataXMLFile
    12    extends File
     12    extends File
    1313{
    14    static final private String DESCRIPTION_ELEMENT = "Description";
    15    static final private String DIRECTORY_FILENAME = ".*";
    16    static final private String FILENAME_ELEMENT = "FileName";
    17    static final private String FILESET_ELEMENT = "FileSet";
    18    static final private String METADATA_ELEMENT = "Metadata";
    19 
    20 
    21    public MetadataXMLFile(String metadata_xml_file_path)
    22    {
    23       super(metadata_xml_file_path);
    24 
    25       // Parse the metadata.xml file
    26       Document document = XMLTools.parseXMLFile(this);
    27       if (document == null) {
    28      System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
    29      return;
    30       }
    31 
    32       // Read all the Metadata elements in the file
    33       NodeList metadata_elements_nodelist = document.getElementsByTagName(METADATA_ELEMENT);
    34       for (int i = 0; i < metadata_elements_nodelist.getLength(); i++) {
    35      Element current_metadata_element = (Element) metadata_elements_nodelist.item(i);
    36      String metadata_element_name_full = current_metadata_element.getAttribute("name");
    37 
    38      String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    39      MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
    40 
    41      String metadata_element_name = MetadataTools.getMetadataElementName(metadata_element_name_full);
    42      MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
    43 
    44      String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    45      metadata_element.addMetadataValue(current_metadata_element_value);
    46       }
    47    }
    48 
    49 
    50    public void addMetadata(File file, MetadataValue metadata_value)
    51    {
    52       // Parse the metadata.xml file
    53       Document document = XMLTools.parseXMLFile(this);
    54       if (document == null) {
    55      System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
    56      return;
    57       }
    58 
    59       // Determine the file's path relative to the location of the metadata.xml file
    60       File metadata_xml_file_directory = getParentFile();
    61       String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
    62       if (file_relative_path.startsWith(File.separator)) {
    63      file_relative_path = file_relative_path.substring(File.separator.length());
    64       }
    65 
    66       // Convert the file path into a regular expression that will match it
    67       String file_path_regexp = file_relative_path.replaceAll("\\.", "\\\\.");
    68       if (file_relative_path.equals("")) {
    69      file_path_regexp = DIRECTORY_FILENAME;
    70       }
    71 
    72       // Create a new Metadata element to record this metadata
    73       Element new_metadata_value_element = document.createElement(METADATA_ELEMENT);
    74       new_metadata_value_element.setAttribute("name", metadata_value.getMetadataElement().getFullName());
    75       new_metadata_value_element.setAttribute("mode", (metadata_value.isAccumulatingMetadata() ? "accumulate" : "override"));
    76       new_metadata_value_element.appendChild(document.createTextNode(metadata_value.getFullValue()));
    77       boolean have_added_metadata = false;
    78 
    79       // Read all the FileSet elements in the file
    80       NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
    81       for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
    82      Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
    83 
    84      // Check the FileName elements of the FileSet to see if we have a match
    85      NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
    86      for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
    87         Element current_filename_element = (Element) filename_elements_nodelist.item(j);
    88         String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
    89 
    90         // Only exact matches can be extended with new metadata
    91         if (current_filename_element_value.equals(file_path_regexp)) {
    92            // Append the new Metadata element to the Description element of this FileSet
    93            Element description_element = (Element) current_fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT).item(0);
    94 
    95            // Accumulating metadata: add at the end
    96            if (metadata_value.isAccumulatingMetadata()) {
    97           description_element.appendChild(new_metadata_value_element);
    98            }
    99            // Override metadata: add at the start (so it overrides inherited metadata without affecting other assigned metadata)
    100            else {
    101           description_element.insertBefore(new_metadata_value_element, description_element.getFirstChild());
    102            }
    103 
    104            have_added_metadata = true;
    105            break;
    106         }
    107      }
    108       }
    109 
    110       // Check if the metadata was added to an existing FileSet
    111       if (!have_added_metadata) {
    112      // It wasn't, so create a new FileSet element for it
    113      Element new_fileset_element = document.createElement(FILESET_ELEMENT);
    114 
    115      Element new_filename_element = document.createElement(FILENAME_ELEMENT);
    116      new_filename_element.appendChild(document.createTextNode(file_path_regexp));
    117      new_fileset_element.appendChild(new_filename_element);
    118 
    119      // Append the new Metadata element to the Description element of this FileSet
    120      Element new_description_element = document.createElement(DESCRIPTION_ELEMENT);
    121      new_description_element.appendChild(new_metadata_value_element);
    122      new_fileset_element.appendChild(new_description_element);
    123 
    124      document.getDocumentElement().appendChild(new_fileset_element);
    125       }
    126 
    127       // Rewrite the metadata.xml file
    128       XMLTools.writeXMLFile(this, document);
    129    }
    130 
    131 
    132    public ArrayList getMetadataAssignedToFile(File file)
    133    {
    134       // Parse the metadata.xml file
    135       Document document = XMLTools.parseXMLFile(this);
    136       if (document == null) {
    137      System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
    138      return null;
    139       }
    140 
    141       // Determine the file's path relative to the location of the metadata.xml file
    142       File metadata_xml_file_directory = getParentFile();
    143       String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
    144       if (file_relative_path.startsWith(File.separator)) {
    145      file_relative_path = file_relative_path.substring(File.separator.length());
    146       }
    147 
    148       // Build up a list of metadata assigned to this file
    149       ArrayList metadata_values = new ArrayList();
    150 
    151       // Read all the FileSet elements in the file
    152       NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
    153       for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
    154      Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
    155      boolean current_fileset_matches = false;
    156      boolean is_folder_level_metadata = false;
    157 
    158      // Check the FileName elements of the FileSet to see if we have a match
    159      NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
    160      for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
    161         Element current_filename_element = (Element) filename_elements_nodelist.item(j);
    162         String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
    163 
    164         // This fileset specifies metadata for this file
    165         if (file_relative_path.matches(current_filename_element_value)) {
    166            current_fileset_matches = true;
    167            is_folder_level_metadata = (current_filename_element_value.equals(DIRECTORY_FILENAME));
    168            break;
    169         }
    170      }
    171 
    172      // The FileSet doesn't apply, so move onto the next one
    173      if (current_fileset_matches == false) {
    174         continue;
    175      }
    176 
    177      // Read all the Metadata elements in the fileset
    178      NodeList metadata_elements_nodelist = current_fileset_element.getElementsByTagName(METADATA_ELEMENT);
    179      for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
    180         Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
    181         String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
    182 
    183         String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(current_metadata_element_name_full);
     14    static final private String DESCRIPTION_ELEMENT = "Description";
     15    static final private String DIRECTORY_FILENAME = ".*";
     16    static final private String FILENAME_ELEMENT = "FileName";
     17    static final private String FILESET_ELEMENT = "FileSet";
     18    static final private String METADATA_ELEMENT = "Metadata";
     19
     20
     21    public MetadataXMLFile(String metadata_xml_file_path)
     22    {
     23    super(metadata_xml_file_path);
     24
     25    // Parse the metadata.xml file
     26    Document document = XMLTools.parseXMLFile(this);
     27    if (document == null) {
     28        System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
     29        return;
     30    }
     31
     32    // Read all the Metadata elements in the file
     33    NodeList metadata_elements_nodelist = document.getElementsByTagName(METADATA_ELEMENT);
     34    for (int i = 0; i < metadata_elements_nodelist.getLength(); i++) {
     35        Element current_metadata_element = (Element) metadata_elements_nodelist.item(i);
     36        String metadata_element_name_full = current_metadata_element.getAttribute("name");
     37
     38        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    18439        MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
    18540
    186         // If the metadata set isn't loaded, we're not interested in the metadata
    187         if (metadata_set == null) {
    188            continue;
    189         }
    190 
    191         String metadata_element_name = MetadataTools.getMetadataElementName(current_metadata_element_name_full);
     41        String metadata_element_name = MetadataTools.getMetadataElementName(metadata_element_name_full);
    19242        MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
    19343
    194         // If the element doesn't exist in the metadata set, we're not interested
    195         if (metadata_element == null) {
    196            continue;
    197         }
    198 
    19944        String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    200         MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
    201 
    202         // If there is no metadata value tree node for this value, something bad has happened
    203         if (metadata_value_tree_node == null) {
    204            System.err.println("Error: Could not find value tree node for metadata value \"" + current_metadata_element_value + "\"");
    205            continue;
    206         }
    207 
    208         MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
    209         if (is_folder_level_metadata && !file_relative_path.equals("")) {
    210            metadata_value.inheritsMetadataFromFolder(metadata_xml_file_directory);
    211         }
    212 
    213         // Is this accumulating metadata?
    214         if (current_metadata_element.getAttribute("mode").equals("accumulate")) {
    215            metadata_value.setIsAccumulatingMetadata(true);
    216         }
    217 
    218         // Add the new metadata value to the list
    219         metadata_values.add(metadata_value);
    220      }
    221       }
    222 
    223       return metadata_values;
    224    }
    225 
    226 
    227    public void removeMetadata(File file, MetadataValue metadata_value)
    228    {
    229       // Parse the metadata.xml file
    230       Document document = XMLTools.parseXMLFile(this);
    231       if (document == null) {
    232      System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
    233      return;
    234       }
    235 
    236       // Determine the file's path relative to the location of the metadata.xml file
    237       File metadata_xml_file_directory = getParentFile();
    238       String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
    239       if (file_relative_path.startsWith(File.separator)) {
    240      file_relative_path = file_relative_path.substring(File.separator.length());
    241       }
    242 
    243       // Convert the file path into a regular expression that will match it
    244       String file_path_regexp = file_relative_path.replaceAll("\\.", "\\\\.");
    245       if (file_relative_path.equals("")) {
    246      file_path_regexp = DIRECTORY_FILENAME;
    247       }
    248 
    249       // Read all the FileSet elements in the file
    250       NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
    251       for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
    252      Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
    253      boolean current_fileset_matches = false;
    254 
    255      // Check the FileName elements of the FileSet to see if we have a match
    256      NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
    257      for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
    258         Element current_filename_element = (Element) filename_elements_nodelist.item(j);
    259         String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
    260 
    261         // Only exact matches can be edited
    262         if (current_filename_element_value.equals(file_path_regexp)) {
    263            current_fileset_matches = true;
    264            break;
    265         }
    266      }
    267 
    268      // The FileSet doesn't apply, so move onto the next one
    269      if (current_fileset_matches == false) {
    270         continue;
    271      }
    272 
    273      // Find the Metadata element to delete from the fileset
    274      String metadata_element_name_full = metadata_value.getMetadataElement().getFullName();
    275      String metadata_element_value = metadata_value.getFullValue();
    276      NodeList metadata_elements_nodelist = current_fileset_element.getElementsByTagName(METADATA_ELEMENT);
    277      for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
    278         Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
    279 
    280         // Check the metadata element name matches
    281         String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
    282         if (!current_metadata_element_name_full.equals(metadata_element_name_full)) {
    283            continue;
    284         }
    285 
    286         // Check the metadata element value matches
    287         String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    288         if (!current_metadata_element_value.equals(metadata_element_value)) {
    289            continue;
    290         }
    291 
    292         // Remove this Metadata element
    293         current_metadata_element.getParentNode().removeChild(current_metadata_element);
    294      }
    295       }
    296 
    297       // Rewrite the metadata.xml file
    298       XMLTools.writeXMLFile(this, document);
    299    }
     45        metadata_element.addMetadataValue(current_metadata_element_value);
     46    }
     47    }
     48
     49
     50    public void addMetadata(File file, MetadataValue metadata_value)
     51    {
     52    // Parse the metadata.xml file
     53    Document document = XMLTools.parseXMLFile(this);
     54    if (document == null) {
     55        System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
     56        return;
     57    }
     58
     59    // Determine the file's path relative to the location of the metadata.xml file
     60    File metadata_xml_file_directory = getParentFile();
     61    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     62    if (file_relative_path.startsWith(File.separator)) {
     63        file_relative_path = file_relative_path.substring(File.separator.length());
     64    }
     65
     66    // Convert the file path into a regular expression that will match it
     67    String file_path_regexp = file_relative_path.replaceAll("\\.", "\\\\.");
     68    if (file_relative_path.equals("")) {
     69        file_path_regexp = DIRECTORY_FILENAME;
     70    }
     71
     72    // Create a new Metadata element to record this metadata
     73    Element new_metadata_value_element = document.createElement(METADATA_ELEMENT);
     74    new_metadata_value_element.setAttribute("name", metadata_value.getMetadataElement().getFullName());
     75    new_metadata_value_element.setAttribute("mode", (metadata_value.isAccumulatingMetadata() ? "accumulate" : "override"));
     76    new_metadata_value_element.appendChild(document.createTextNode(metadata_value.getFullValue()));
     77    boolean have_added_metadata = false;
     78
     79    // Read all the FileSet elements in the file
     80    NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
     81    for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
     82        Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
     83
     84        // Check the FileName elements of the FileSet to see if we have a match
     85        NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
     86        for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
     87        Element current_filename_element = (Element) filename_elements_nodelist.item(j);
     88        String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
     89
     90        // Only exact matches can be extended with new metadata
     91        if (current_filename_element_value.equals(file_path_regexp)) {
     92            // Append the new Metadata element to the Description element of this FileSet
     93            Element description_element = (Element) current_fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT).item(0);
     94
     95            // Accumulating metadata: add at the end
     96            if (metadata_value.isAccumulatingMetadata()) {
     97            description_element.appendChild(new_metadata_value_element);
     98            }
     99            // Override metadata: add at the start (so it overrides inherited metadata without affecting other assigned metadata)
     100            else {
     101            description_element.insertBefore(new_metadata_value_element, description_element.getFirstChild());
     102            }
     103
     104            have_added_metadata = true;
     105            break;
     106        }
     107        }
     108    }
     109
     110    // Check if the metadata was added to an existing FileSet
     111    if (!have_added_metadata) {
     112        // It wasn't, so create a new FileSet element for it
     113        Element new_fileset_element = document.createElement(FILESET_ELEMENT);
     114
     115        Element new_filename_element = document.createElement(FILENAME_ELEMENT);
     116        new_filename_element.appendChild(document.createTextNode(file_path_regexp));
     117        new_fileset_element.appendChild(new_filename_element);
     118
     119        // Append the new Metadata element to the Description element of this FileSet
     120        Element new_description_element = document.createElement(DESCRIPTION_ELEMENT);
     121        new_description_element.appendChild(new_metadata_value_element);
     122        new_fileset_element.appendChild(new_description_element);
     123
     124        document.getDocumentElement().appendChild(new_fileset_element);
     125    }
     126
     127    // Rewrite the metadata.xml file
     128    XMLTools.writeXMLFile(this, document);
     129    }
     130
     131
     132    public ArrayList getMetadataAssignedToFile(File file)
     133    {
     134    // Parse the metadata.xml file
     135    Document document = XMLTools.parseXMLFile(this);
     136    if (document == null) {
     137        System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
     138        return null;
     139    }
     140
     141    // Determine the file's path relative to the location of the metadata.xml file
     142    File metadata_xml_file_directory = getParentFile();
     143    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     144    if (file_relative_path.startsWith(File.separator)) {
     145        file_relative_path = file_relative_path.substring(File.separator.length());
     146    }
     147
     148    // Build up a list of metadata assigned to this file
     149    ArrayList metadata_values = new ArrayList();
     150
     151    // Read all the FileSet elements in the file
     152    NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
     153    for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
     154        Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
     155        boolean current_fileset_matches = false;
     156        boolean is_folder_level_metadata = false;
     157
     158        // Check the FileName elements of the FileSet to see if we have a match
     159        NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
     160        for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
     161        Element current_filename_element = (Element) filename_elements_nodelist.item(j);
     162        String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
     163
     164        // This fileset specifies metadata for this file
     165        if (file_relative_path.matches(current_filename_element_value)) {
     166            current_fileset_matches = true;
     167            is_folder_level_metadata = (current_filename_element_value.equals(DIRECTORY_FILENAME));
     168            break;
     169        }
     170        }
     171
     172        // The FileSet doesn't apply, so move onto the next one
     173        if (current_fileset_matches == false) {
     174        continue;
     175        }
     176
     177        // Read all the Metadata elements in the fileset
     178        NodeList metadata_elements_nodelist = current_fileset_element.getElementsByTagName(METADATA_ELEMENT);
     179        for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
     180        Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
     181        String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
     182
     183        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(current_metadata_element_name_full);
     184        MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
     185
     186        // If the metadata set isn't loaded, we're not interested in the metadata
     187        if (metadata_set == null) {
     188            continue;
     189        }
     190
     191        String metadata_element_name = MetadataTools.getMetadataElementName(current_metadata_element_name_full);
     192        MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
     193
     194        // If the element doesn't exist in the metadata set, we're not interested
     195        if (metadata_element == null) {
     196            continue;
     197        }
     198
     199        String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     200        MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
     201
     202        // If there is no metadata value tree node for this value, something bad has happened
     203        if (metadata_value_tree_node == null) {
     204            System.err.println("Error: Could not find value tree node for metadata value \"" + current_metadata_element_value + "\"");
     205            continue;
     206        }
     207
     208        MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
     209        if (is_folder_level_metadata && !file_relative_path.equals("")) {
     210            metadata_value.inheritsMetadataFromFolder(metadata_xml_file_directory);
     211        }
     212
     213        // Is this accumulating metadata?
     214        if (current_metadata_element.getAttribute("mode").equals("accumulate")) {
     215            metadata_value.setIsAccumulatingMetadata(true);
     216        }
     217
     218        // Add the new metadata value to the list
     219        metadata_values.add(metadata_value);
     220        }
     221    }
     222
     223    return metadata_values;
     224    }
     225
     226
     227    public void removeMetadata(File file, MetadataValue metadata_value)
     228    {
     229    // Parse the metadata.xml file
     230    Document document = XMLTools.parseXMLFile(this);
     231    if (document == null) {
     232        System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
     233        return;
     234    }
     235
     236    // Determine the file's path relative to the location of the metadata.xml file
     237    File metadata_xml_file_directory = getParentFile();
     238    String file_relative_path = file.getAbsolutePath().substring(metadata_xml_file_directory.getAbsolutePath().length());
     239    if (file_relative_path.startsWith(File.separator)) {
     240        file_relative_path = file_relative_path.substring(File.separator.length());
     241    }
     242
     243    // Convert the file path into a regular expression that will match it
     244    String file_path_regexp = file_relative_path.replaceAll("\\.", "\\\\.");
     245    if (file_relative_path.equals("")) {
     246        file_path_regexp = DIRECTORY_FILENAME;
     247    }
     248
     249    // Read all the FileSet elements in the file
     250    NodeList fileset_elements_nodelist = document.getElementsByTagName(FILESET_ELEMENT);
     251    for (int i = 0; i < fileset_elements_nodelist.getLength(); i++) {
     252        Element current_fileset_element = (Element) fileset_elements_nodelist.item(i);
     253        boolean current_fileset_matches = false;
     254
     255        // Check the FileName elements of the FileSet to see if we have a match
     256        NodeList filename_elements_nodelist = current_fileset_element.getElementsByTagName(FILENAME_ELEMENT);
     257        for (int j = 0; j < filename_elements_nodelist.getLength(); j++) {
     258        Element current_filename_element = (Element) filename_elements_nodelist.item(j);
     259        String current_filename_element_value = XMLTools.getElementTextValue(current_filename_element);
     260
     261        // Only exact matches can be edited
     262        if (current_filename_element_value.equals(file_path_regexp)) {
     263            current_fileset_matches = true;
     264            break;
     265        }
     266        }
     267
     268        // The FileSet doesn't apply, so move onto the next one
     269        if (current_fileset_matches == false) {
     270        continue;
     271        }
     272
     273        // Find the Metadata element to delete from the fileset
     274        String metadata_element_name_full = metadata_value.getMetadataElement().getFullName();
     275        String metadata_element_value = metadata_value.getFullValue();
     276        NodeList metadata_elements_nodelist = current_fileset_element.getElementsByTagName(METADATA_ELEMENT);
     277        for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
     278        Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
     279
     280        // Check the metadata element name matches
     281        String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
     282        if (!current_metadata_element_name_full.equals(metadata_element_name_full)) {
     283            continue;
     284        }
     285
     286        // Check the metadata element value matches
     287        String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     288        if (!current_metadata_element_value.equals(metadata_element_value)) {
     289            continue;
     290        }
     291
     292        // Remove this Metadata element
     293        current_metadata_element.getParentNode().removeChild(current_metadata_element);
     294        }
     295    }
     296
     297    // Rewrite the metadata.xml file
     298    XMLTools.writeXMLFile(this, document);
     299    }
    300300}

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

    r7827 r7978  
    1212public class MetadataXMLFileManager
    1313{
    14    static private ArrayList metadata_xml_files = new ArrayList();
     14    static private ArrayList metadata_xml_files = new ArrayList();
    1515
    1616
    17    static public void addMetadata(FileNode[] file_nodes, MetadataValue metadata_value)
    18    {
    19       for (int i = 0; i < file_nodes.length; i++) {
    20      File current_file = file_nodes[i].getFile();
    21      System.err.println("Adding metadata to " + current_file.getAbsolutePath());
     17    static public void addMetadata(FileNode[] file_nodes, MetadataValue metadata_value)
     18    {
     19    for (int i = 0; i < file_nodes.length; i++) {
     20        File current_file = file_nodes[i].getFile();
     21        System.err.println("Adding metadata to " + current_file.getAbsolutePath());
    2222
    23      // Find which metadata.xml file needs editing
    24      boolean applicable_metadata_xml_file_found = false;
    25      File current_file_directory = (current_file.isDirectory() ? current_file : current_file.getParentFile());
    26      for (int j = 0; j < metadata_xml_files.size(); j++) {
    27         MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(j);
     23        // Find which metadata.xml file needs editing
     24        boolean applicable_metadata_xml_file_found = false;
     25        File current_file_directory = (current_file.isDirectory() ? current_file : current_file.getParentFile());
     26        for (int j = 0; j < metadata_xml_files.size(); j++) {
     27        MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(j);
     28
     29        // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
     30        if (current_file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
     31            applicable_metadata_xml_file_found = true;
     32            metadata_xml_file.addMetadata(current_file, metadata_value);
     33        }
     34        }
     35
     36        // If no applicable metadata.xml file exists, we have to create a new one
     37        if (!applicable_metadata_xml_file_found) {
     38        // Create a new (empty) metadata.xml file in the file's directory...
     39        File new_metadata_xml_file_file = new File(current_file_directory, "metadata.xml");
     40        XMLTools.writeXMLFile(new_metadata_xml_file_file, Utility.parse("xml/metadata.xml", true));
     41
     42        // ...load it...
     43        MetadataXMLFile new_metadata_xml_file = loadMetadataXMLFile(new_metadata_xml_file_file);
     44
     45        // ...and add the metadata
     46        new_metadata_xml_file.addMetadata(current_file, metadata_value);
     47        }
     48    }
     49    }
     50
     51
     52    static public void clearMetadataXMLFiles()
     53    {
     54    metadata_xml_files.clear();
     55    }
     56
     57
     58    static public ArrayList getMetadataAssignedToFile(File file)
     59    {
     60    // Build up a list of metadata values assigned to this file
     61    ArrayList metadata_values_all = new ArrayList();
     62
     63    // Look at each loaded metadata.xml file to see if any assign metadata to this file
     64    File file_directory = (file.isDirectory() ? file : file.getParentFile());
     65    for (int i = 0; i < metadata_xml_files.size(); i++) {
     66        MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(i);
    2867
    2968        // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
    30         if (current_file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
    31            applicable_metadata_xml_file_found = true;
    32            metadata_xml_file.addMetadata(current_file, metadata_value);
     69        if (file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
     70        ArrayList metadata_values = metadata_xml_file.getMetadataAssignedToFile(file);
     71        for (int j = 0; j < metadata_values.size(); j++) {
     72            MetadataValue metadata_value = (MetadataValue) metadata_values.get(j);
     73
     74            // Overriding metadata: remove any values with this metadata element
     75            if (metadata_value.isAccumulatingMetadata() == false) {
     76            for (int k = metadata_values_all.size() - 1; k >= 0; k--) {
     77                if (((MetadataValue) metadata_values_all.get(k)).getMetadataElement().equals(metadata_value.getMetadataElement())) {
     78                metadata_values_all.remove(k);
     79                }
     80            }
     81            }
     82
     83            metadata_values_all.add(metadata_value);
     84        }
    3385        }
    34      }
     86    }
    3587
    36      // If no applicable metadata.xml file exists, we have to create a new one
    37      if (!applicable_metadata_xml_file_found) {
    38         // Create a new (empty) metadata.xml file in the file's directory...
    39         File new_metadata_xml_file_file = new File(current_file_directory, "metadata.xml");
    40         XMLTools.writeXMLFile(new_metadata_xml_file_file, Utility.parse("xml/metadata.xml", true));
    41 
    42         // ...load it...
    43         MetadataXMLFile new_metadata_xml_file = loadMetadataXMLFile(new_metadata_xml_file_file);
    44 
    45         // ...and add the metadata
    46         new_metadata_xml_file.addMetadata(current_file, metadata_value);
    47      }
    48       }
    49    }
     88    return metadata_values_all;
     89    }
    5090
    5191
    52    static public void clearMetadataXMLFiles()
    53    {
    54       metadata_xml_files.clear();
    55    }
     92    static public void loadMetadataXMLFiles(File directory)
     93    {
     94    // Look recursively at each subfile of the directory for metadata.xml files
     95    File[] directory_files = directory.listFiles();
     96    for (int i = 0; i < directory_files.length; i++) {
     97        File child_file = directory_files[i];
     98        if (child_file.isDirectory()) {
     99        loadMetadataXMLFiles(child_file);
     100        }
     101        else if (child_file.getName().equals("metadata.xml")) {
     102        loadMetadataXMLFile(child_file);
     103        }
     104    }
     105    }
    56106
    57107
    58    static public ArrayList getMetadataAssignedToFile(File file)
    59    {
    60       // Build up a list of metadata values assigned to this file
    61       ArrayList metadata_values_all = new ArrayList();
    62 
    63       // Look at each loaded metadata.xml file to see if any assign metadata to this file
    64       File file_directory = (file.isDirectory() ? file : file.getParentFile());
    65       for (int i = 0; i < metadata_xml_files.size(); i++) {
    66      MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(i);
    67 
    68      // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
    69      if (file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
    70         ArrayList metadata_values = metadata_xml_file.getMetadataAssignedToFile(file);
    71         for (int j = 0; j < metadata_values.size(); j++) {
    72            MetadataValue metadata_value = (MetadataValue) metadata_values.get(j);
    73 
    74            // Overriding metadata: remove any values with this metadata element
    75            if (metadata_value.isAccumulatingMetadata() == false) {
    76           for (int k = metadata_values_all.size() - 1; k >= 0; k--) {
    77              if (((MetadataValue) metadata_values_all.get(k)).getMetadataElement().equals(metadata_value.getMetadataElement())) {
    78             metadata_values_all.remove(k);
    79              }
    80           }
    81            }
    82 
    83            metadata_values_all.add(metadata_value);
    84         }
    85      }
    86       }
    87 
    88       return metadata_values_all;
    89    }
     108    static private MetadataXMLFile loadMetadataXMLFile(File metadata_xml_file_file)
     109    {
     110    MetadataXMLFile metadata_xml_file = new MetadataXMLFile(metadata_xml_file_file.getAbsolutePath());
     111    metadata_xml_files.add(metadata_xml_file);
     112    return metadata_xml_file;
     113    }
    90114
    91115
    92    static public void loadMetadataXMLFiles(File directory)
    93    {
    94       // Look recursively at each subfile of the directory for metadata.xml files
    95       File[] directory_files = directory.listFiles();
    96       for (int i = 0; i < directory_files.length; i++) {
    97      File child_file = directory_files[i];
    98      if (child_file.isDirectory()) {
    99         loadMetadataXMLFiles(child_file);
    100      }
    101      else if (child_file.getName().equals("metadata.xml")) {
    102         loadMetadataXMLFile(child_file);
    103      }
    104       }
    105    }
     116    static public void removeMetadata(FileNode[] file_nodes, MetadataValue metadata_value)
     117    {
     118    for (int i = 0; i < file_nodes.length; i++) {
     119        File current_file = file_nodes[i].getFile();
     120        System.err.println("Removing metadata from " + current_file.getAbsolutePath());
    106121
     122        // Find which metadata.xml file needs editing
     123        File current_file_directory = (current_file.isDirectory() ? current_file : current_file.getParentFile());
     124        for (int j = 0; j < metadata_xml_files.size(); j++) {
     125        MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(j);
    107126
    108    static private MetadataXMLFile loadMetadataXMLFile(File metadata_xml_file_file)
    109    {
    110       MetadataXMLFile metadata_xml_file = new MetadataXMLFile(metadata_xml_file_file.getAbsolutePath());
    111       metadata_xml_files.add(metadata_xml_file);
    112       return metadata_xml_file;
    113    }
    114 
    115 
    116    static public void removeMetadata(FileNode[] file_nodes, MetadataValue metadata_value)
    117    {
    118       for (int i = 0; i < file_nodes.length; i++) {
    119      File current_file = file_nodes[i].getFile();
    120      System.err.println("Removing metadata from " + current_file.getAbsolutePath());
    121 
    122      // Find which metadata.xml file needs editing
    123      File current_file_directory = (current_file.isDirectory() ? current_file : current_file.getParentFile());
    124      for (int j = 0; j < metadata_xml_files.size(); j++) {
    125         MetadataXMLFile metadata_xml_file = (MetadataXMLFile) metadata_xml_files.get(j);
    126 
    127         // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
    128         if (current_file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
    129            metadata_xml_file.removeMetadata(current_file, metadata_value);
     127        // This metadata.xml file is only potentially applicable if it is above or at the same level as the file
     128        if (current_file_directory.getAbsolutePath().startsWith(metadata_xml_file.getParentFile().getAbsolutePath())) {
     129            metadata_xml_file.removeMetadata(current_file, metadata_value);
     130        }
    130131        }
    131      }
    132       }
    133    }
     132    }
     133    }
    134134}
Note: See TracChangeset for help on using the changeset viewer.