source: trunk/gli/src/org/greenstone/gatherer/metadata/DocXMLFile.java@ 9701

/**
 *############################################################################
 * A component of the Greenstone Librarian Interface, part of the Greenstone
 * digital library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * Author: Michael Dewsnip, NZDL Project, University of Waikato, NZ
 *
 * Copyright (C) 2004 New Zealand Digital Library Project
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *############################################################################
 */

package org.greenstone.gatherer.metadata;


import java.io.*;
import java.util.*;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.util.Utility;


/** This class represents one doc.xml file */
public class DocXMLFile
    extends File
{
    private HashMap source_file_name_to_description_elements_mapping = new HashMap();


    public DocXMLFile(String doc_xml_file_path)
    {
    super(doc_xml_file_path);
    }


    public ArrayList getMetadataExtractedFromFile(File file)
    {
    // Build up a list of metadata extracted from this file
    ArrayList metadata_values = new ArrayList();

    String file_relative_path = file.getAbsolutePath();
    int import_index = file_relative_path.indexOf("import");
    if (import_index != -1) {
        file_relative_path = file_relative_path.substring(import_index + "import".length() + 1);
    }

    // Check whether this doc.xml file contains extracted metadata for the specified file
    ArrayList description_elements_list = (ArrayList) source_file_name_to_description_elements_mapping.get(file_relative_path);
    if (description_elements_list == null) {
        // ...it doesn't
        return metadata_values;
    }

    MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);

    // Parse the doc.xml file
    DebugStream.println("Applicable doc.xml file: " + this);
    try {
        BufferedReader buffered_reader = new BufferedReader(new FileReader(this));

        int description_element_num = 0;
        int next_description_element_start = ((Integer) description_elements_list.get(description_element_num)).intValue();
        boolean in_relevant_description_element = false;

        String line = null;
        for (int line_num = 0; (line = buffered_reader.readLine()) != null; line_num++) {
        // Check if this line contains the start of a relevant Description element
        if (line_num == next_description_element_start) {
            in_relevant_description_element = true;
            continue;
        }

        // If we're not in a relevant Description element we don't care about anything
        if (in_relevant_description_element == false) {
            continue;
        }

        // Check if this line contains the end of the relevant Description element
        if (line.indexOf("</Description>") != -1) {
            description_element_num++;
            if (description_element_num == description_elements_list.size()) {
            break;
            }

            next_description_element_start = ((Integer) description_elements_list.get(description_element_num)).intValue();
            in_relevant_description_element = false;
            continue;
        }

        // If this line doesn't contain a complete Metadata element, we're not interested
        if (line.indexOf("<Metadata ") == -1 || line.indexOf("</Metadata>") == -1) {
            continue;
        }

        // Extract the metadata element name
        int name_index = line.indexOf(" name=\"") + " name=\"".length();
        String metadata_element_name_full = line.substring(name_index, line.indexOf("\"", name_index));

        // If the metadata has a namespace it isn't extracted metadata, so we're not interested
        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
        if (!metadata_set_namespace.equals("")) {
            continue;
        }

        // Extracted metadata!
        String metadata_element_name = metadata_element_name_full;

        // We completely ignore bibliographic data
        if (metadata_element_name.equals("SourceSegment")) {
            return new ArrayList();
        }

        // Ignore lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
        //   and those starting with '/' (/srclink)
        char first_character = metadata_element_name.charAt(0);
        if (Character.isLowerCase(first_character) || first_character == '/') {
            continue;
        }

        MetadataElement metadata_element = extracted_metadata_set.getMetadataElementWithName(metadata_element_name);

        // Value trees are not stored for extracted metadata, so create a new value tree node now
        int value_index = line.indexOf(">", name_index) + ">".length();
        String metadata_element_value = line.substring(value_index, line.lastIndexOf("</Metadata>"));

        metadata_element.addMetadataValue(metadata_element_value);
        MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(metadata_element_value);

        // Add the new metadata value to the list
        MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
        metadata_values.add(metadata_value);
        }
    }
    catch (Exception ex) {
        System.err.println("Exception: " + ex);
        ex.printStackTrace();
    }

    return metadata_values;
    }


    /**
     * Every doc.xml file must be skimmed when a collection is opened, for two reasons:
     *   - To build a mapping from source file to its corresponding doc.xml file
     *   - To get a complete list of all extracted metadata elements
     */
    public void skimFile()
    {
    MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);

    // Skim the doc.xml file as quickly as possible (don't parse as XML), looking at the Metadata elements
    DebugStream.println("Skimming doc.xml file " + this + "...");
    try {
        BufferedReader buffered_reader = new BufferedReader(new FileReader(this));
        int description_element_start = -1;

        String line = null;
        for (int line_num = 0; (line = buffered_reader.readLine()) != null; line_num++) {
        // This line contains the start of a Description element
        if (line.indexOf("<Description>") != -1) {
            if (description_element_start != -1) {
            System.err.println("Parse error: previous Description element unfinished!");
            }
            description_element_start = line_num;
            continue;
        }

        // This line contains the end of a Description element
        if (line.indexOf("</Description>") != -1) {
            if (description_element_start == -1) {
            System.err.println("Parse error: Description element unstarted!");
            }
            description_element_start = -1;
            continue;
        }

        // If we're not in a Description element there shouldn't be any Metadata elements
        if (description_element_start == -1) {
            continue;
        }

        // This line doesn't contain a Metadata element, so we're not interested
        if (line.indexOf("<Metadata ") == -1) {
            DebugStream.println("Warning: Description element line doesn't contain Metadata element.");
            continue;
        }

        // Extract the metadata element name
        int name_index = line.indexOf(" name=\"") + " name=\"".length();
        String metadata_element_name_full = line.substring(name_index, line.indexOf("\"", name_index));

        // If the metadata has a namespace it isn't extracted metadata, so we're not interested
        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
        if (!metadata_set_namespace.equals("")) {
            continue;
        }

        // Extracted metadata!
        String metadata_element_name = metadata_element_name_full;

        // Note which file this doc.xml is for
        if (metadata_element_name.equals("gsdlsourcefilename")) {
            // Extract the gsdlsourcefilename element value
            int value_index = line.indexOf(">", name_index) + ">".length();
            String gsdlsourcefilename_value = line.substring(value_index, line.indexOf("<", value_index));

            // We're only interested in the path relative to the import folder
            int import_index = gsdlsourcefilename_value.indexOf("import");
            if (import_index != -1) {
            gsdlsourcefilename_value = gsdlsourcefilename_value.substring(import_index + "import".length());

            boolean is_unix_path = gsdlsourcefilename_value.startsWith("/");
            gsdlsourcefilename_value = gsdlsourcefilename_value.substring(1);

            // Make sure the path matches the OS that is running
            if (is_unix_path && Utility.isWindows()) {
                // Convert path from Unix to Windows
                gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("\\/", "\\\\");
            }
            else if (!is_unix_path && !Utility.isWindows()) {
                // Convert path from Windows to Unix
                gsdlsourcefilename_value = gsdlsourcefilename_value.replaceAll("\\\\", "/");
            }

            // Remember this for quick access later
            if (source_file_name_to_description_elements_mapping.get(gsdlsourcefilename_value) == null) {
                source_file_name_to_description_elements_mapping.put(gsdlsourcefilename_value, new ArrayList());
            }

            ((ArrayList) source_file_name_to_description_elements_mapping.get(gsdlsourcefilename_value)).add(new Integer(description_element_start));
            }

            // Warn about an odd gsdlsourcefilename, except if it is the Greenstone "tmp" directory
            // This is true when the source files come from a zip file processed by ZIPPlug, for example
            else if (gsdlsourcefilename_value.indexOf("tmp") == -1) {
            // We don't really know what is going on...
            System.err.println("Warning: Could not understand gsdlsourcefilename " + gsdlsourcefilename_value);
            }
        }

        // Ignore lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
        //   and those starting with '/' (/srclink)
        char first_character = metadata_element_name.charAt(0);
        if (Character.isLowerCase(first_character) || first_character == '/') {
            continue;
        }

        MetadataElement metadata_element = extracted_metadata_set.getMetadataElementWithName(metadata_element_name);
        if (metadata_element == null) {
            // This element isn't defined in ex.mds, so create it for this session
            DebugStream.println("Extracted metadata element not defined: " + metadata_element_name);
            extracted_metadata_set.addMetadataElementForThisSession(metadata_element_name);
        }
        }
    }
    catch (Exception ex) {
        System.err.println("Exception: " + ex);
        ex.printStackTrace();
    }
    }
}