source: trunk/gli/src/org/greenstone/gatherer/msm/GDMParser.java@ 6318

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.msm;

/**************************************************************************************
 * Title:        Gatherer
 * Description:  The Gatherer: a tool for gathering and enriching a digital collection.
 * Company:      The University of Waikato
 * Written:        /  /02
 * Revised:      20/08/02 Commented and Optimized.
 * @author John Thompson, 9826509
 * @version 2.3
 **************************************************************************************/
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.IllegalArgumentException;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.xerces.parsers.DOMParser;
import org.apache.xml.serialize.XMLSerializer;
import org.apache.xml.serialize.OutputFormat;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;

/** Parses metadata.xml documents of the GreenstoneDirectoryMetadata variety, caching where possible. */
// ####################################################################################
// Optimization                          Saving
// ####################################################################################
// Vector -> ArrayList                   + Memory, + Processor (pos. - Processor)
// Hashtable -> HashMap                  + Memory, + Processor
// Removed extra global references       + Memory (16k)
// ####################################################################################
public class GDMParser 
    extends LinkedHashMap {
    /** A list of file names that we know do not actually belong to valid GDM xml files, so there not much point in ever trying to read them again. */
    private ArrayList ignore = null;
    /** The actual xerces parser used to read in xml documents. */
    private DOMParser parser = null;
    /** The default maximum cache size if max size not explicitly set. */
    private int max_size = 25;
    /** Default constructor. */
    public GDMParser() {
    super();
    this.ignore = new ArrayList();
    try {
        parser = new DOMParser();
        // Don't let it import external dtds. If it does it'll probably spit the dummy. If people try to use a poorly formated xml file more fool them.
        parser.setFeature("http://xml.org/sax/features/validation", false);
        parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); 
        // May or may not be ignored, the documentation for Xerces is contradictory. If it works then parsing -should- be faster.
        parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", true);
    }
    catch(Exception error) {
        ///ystem.err.println("Fatal Error in GDMParser.init(): " + error);
        error.printStackTrace();
        System.exit(1);
    }
    }
    /** Constructor with maximum size set.
     * @param max_size The maximum size of the cache, as an <i>int</i>.
     */
    public GDMParser(int max_size) {
    this();
    this.max_size = max_size;
    }
    /** Destructor, clears cache and remove persistant global references. */
    public void destroy() {
    ignore.clear();
    ignore = null;
    parser = null;
    clear();
    }
    /** Fetches the document for the given xml file. This may mean (re)parsing it or simply fetching it from cache.
     * @param file The metadata.xml <strong>File</strong> you wish to get the document for.
     * @return A <strong>Document</strong> which is sourced from file.
     */
    public Document parse(File file) {
    ///ystem.err.println("Parse: " + file.getAbsolutePath());
    Document result = null;
    if(file.exists()) {
        // Check if we've already parsed this file in an earlier attempt.
        if(containsKey(file)) {
        ///ystem.err.println("Already cached previously.");
        //result = (Document) get(file);
        SoftReference reference = (SoftReference) get(file);
        if(reference != null) {
            result = (Document) reference.get();
        }
        else {
            ///ystem.err.println("Reference expired.");
        }
        }
        // Check the ignore list and see if we've already detected this isn't a greenstone metadata file.
        if(result == null && !ignore.contains(file)) {
        ///ystem.err.println("Reparse file.");
        // Of course we may not have, or it may have expired so...
        try {
            // Display progress dialog.
            InputStream is = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(is);
            Reader r = new BufferedReader(isr);
            InputSource isc = new InputSource(r);
            parser.parse(isc); // Slow.
            Document document = parser.getDocument();
            // First test. Check we have a GreenstoneDirectoryMetadata file, or for the older version DirectoryMetadata.
            if(!document.getDoctype().getName().equals("GreenstoneDirectoryMetadata") && !document.getDoctype().getName().equals("DirectoryMetadata")) {
            ///ystem.err.println("Adding to ignore list.");
            // Add to ignore list. Not a gdm file.
            ignore.add(file);
            }
            // Cache document.
            else {
            ///ystem.err.println("Adding to cache.");
            put(file, new SoftReference(document));
            result = document;
            }
        }
        catch (Exception error) {
            ///ystem.err.println("Error! " + error);
            error.printStackTrace();
        }
        }
        else {
        ///ystem.err.println("File on ignore list.");
        }
    }
    else {
        ///ystem.err.println("File does not exist!");
    }
    return result;
    }
    /** Automatically called by the LinkedHashMap object whenever an object is added, to determine whether it should remove the oldest entry.
     * @param eldest The eldest <strong>Map.Entry</strong> which may mean in terms of age, or in terms of usage.
     * @return <i>true</i> if the given entry should be removed, <i>false</i> otherwise.
     */
    protected boolean removeEldestEntry(Map.Entry eldest) {
    return size() > max_size;
    }
}