source: trunk/gli/src/org/greenstone/gatherer/util/MetadataXML.java@ 5150

package org.greenstone.gatherer.util;
/**
 *#########################################################################
 *
 * 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.
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * Copyright (C) 1999 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.
 *########################################################################
 */
import java.awt.Point;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Vector;
import javax.swing.tree.TreePath;
//import net.n3.nanoxml.IXMLElement;
//import net.n3.nanoxml.IXMLParser;
//import net.n3.nanoxml.IXMLReader;
//import net.n3.nanoxml.StdXMLReader;
//import net.n3.nanoxml.XMLParserFactory;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.gui.SaveProgressDialog;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.msm.Metadata;
import org.greenstone.gatherer.msm.MetadataSetManager;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.valuetree.GValueModel;
import org.greenstone.gatherer.valuetree.GValueNode;
import org.greenstone.gatherer.valuetree.GValueTree;
import org.w3c.dom.Element;

public class MetadataXML {
    //private boolean can_wait = true;
    private Gatherer gatherer = null;
    private Hashtable known_indexes = null;
    //private int spare_processes = 25;
    //private MetadataXML mummy = null;
    private SaveProgressDialog spd = null;
    //private Vector complete = null;
    //private Vector processes = null;

    static public String METADATA_FILE = "metadata.xml";

    // not actually used anywhere
    /*   static public IXMLElement read(String filename) {
     IXMLElement xml = null;
     IXMLParser parser = null;
     IXMLReader reader = null;
     try {
     parser = XMLParserFactory.createDefaultXMLParser();
     File in_file = new File(filename);
     FileReader in_reader = new FileReader(in_file);
     BufferedReader in = new BufferedReader(in_reader, Utility.BUFFER_SIZE);
     String content = "";
     String next_line = null;
     while((next_line = in.readLine()) != null) {
     // Throw away the document type, as I don't want to deal
     // with dtd's. If someone has tampered with these files to
     // the point that this parser can't read them then too bad.
     if(!next_line.startsWith("<!DOCTYPE")) {
     content = content + next_line;
     }
     }
     in.close();
     reader = StdXMLReader.stringReader(content);
     parser.setReader(reader);
     xml = (IXMLElement) parser.parse();
     }
     catch (Exception e) {
     }
     return xml;
     }
    */

    /**
    public static void write(Gatherer gatherer, String etc_dir) {
    if(gatherer != null && gatherer.c_man != null && gatherer.c_man.getCollection() != null && gatherer.c_man.getCollection().msm != null) {
        Vector elements = gatherer.c_man.getCollection().msm.getElements(true);
        for(int i = 0; i < elements.size(); i++) {
        ElementWrapper element = (ElementWrapper)elements.get(i);
        ///ystem.err.print("Checking " + element + " for HFile: ");
        GValueModel model = gatherer.c_man.getCollection().msm.getValueTree(element);
        if(model != null && (element.getNamespace().equals(MetadataSetManager.HIDDEN) || model.isHierarchy())) {
            ///ystem.err.println("Found. Writing file.");
            write(model, gatherer.c_man.getCollection().msm, etc_dir);
        }
        else {
            ///ystem.err.println("No file found.");
        }
        }
    }
    }
    */

    private String getHIndex(Gatherer gatherer, GValueModel model, String value) {
    String index = null;
    index = (String) known_indexes.get(value);
    if(index == null) {
        index = model.getHIndex(value);
        ///ystem.err.println("Adding to known indexes: " + value + " -> " + index);
        known_indexes.put(value, index);
    }
    return index;
    }

    static private String safe(String unsafe) {
    String safe_str = "";
    for(int i = 0; i < unsafe.length(); i++) {
        char c = unsafe.charAt(i);
        if(c != ' ') {
        safe_str = safe_str + c;
        }
    }
    return safe_str;
    }

    static private void write(Writer w, String text)
    throws Exception {
    text = text + "\r\n";
    char buffer[] = text.toCharArray();
    w.write(buffer, 0, buffer.length);
    }

    static public void write(ElementWrapper element, GValueModel model, MetadataSetManager msm, String etc_dir) {
    try {
        File out_file = new File(etc_dir + element.getName() + ".txt");
        FileOutputStream fos = new FileOutputStream(out_file);
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        BufferedWriter bw = new BufferedWriter(osw, Utility.BUFFER_SIZE);
        Vector all_values = model.traverseTree();
        for(int i = 0; i < all_values.size(); i++) {
        GValueNode node = (GValueNode)all_values.get(i);
        TreePath path = new TreePath(node.getPath());
        String value = node.getFullPath(); // formatPath(null, path, true);
        String index = model.getHIndex(value);
        String alias = node.getAlias(index);
        if(value.indexOf("\\") != -1) {
            value = value.substring(value.lastIndexOf("\\") + 1);
        }
        write(bw, index + "\t\"" + alias + "\"\t\"" + Utility.stripNL(value) + "\"");
        }
                // Very important we do this, or else buffer may not have 
                // flushed.
        bw.flush();
        bw.close();
    }
    catch(Exception error) {
        error.printStackTrace();
    }
    }

    /** Returns the given tree path as path formatted string (ie subject\subject\subject).
     * @param tree The <strong>JTree</strong> the TreePath came from. Used to determine if the root node should be encoded as well.
     * @param path A <strong>TreePath</strong> that you wish to encode to String.
     * @param full <i>true</i> if this is the full path (ie a leaf node), <i>false</i> otherwise.
     * @return A <strong>String</strong> encoding the information from the TreePath.
     * @see javax.swing.JTree
     * @see javax.swing.tree.TreePath
     */
//      static public String formatPath(JTree tree, TreePath path, boolean full) {
//      String text = "";
//      int i = 0;
//      if(tree == null || (!tree.isRootVisible() && !full)) {
//          i = 1;
//      }
//      for( ; i < path.getPathCount(); i++) {
//          GValueNode node = (GValueNode)path.getPathComponent(i);
//          text = text + node.toString();
//          if(node.getChildCount() > 0) {
//          text = text + "\\";
//          }
//      }
//      if(full && text.endsWith("\\")) {
//          return text.substring(0, text.length() - 1);
//      }
//      return text;
//      }

    static final private long showTime(String message, long time) {
    if(time == -1) {
                ///ystem.err.println(message + System.currentTimeMillis());
    }
    else {
                ///ystem.err.println(message + (System.currentTimeMillis() - time));
    }
    return System.currentTimeMillis();
    }
}