/*
 * SimpleDB.java
 *
 * Created on March 29, 2003, 1:25 PM
 */
package Downey;
import java.util.ArrayList;
import java.util.HashMap;
import java.io.*;


/**
 * This class allows for read and write access to a simple database. It is
 * in a package named <i>Downey</i><p>The
 * database is stored as a HashMap, so it can store any object. There are
 * some helper functions to assist for changing a String[] to an ArrayList
 * and from an ArrayList to a String[].
 * Since the database is being serialized, it should only contain objects 
 * that belong to the standard collections, and String[] is not one of them.
 * @author  Tim Downey
*/
public class SimpleDB {
    private String m_fileName;
    private HashMap m_database;
    
    /** Creates a new instance of SimpleDB
     * @param fileName The name of the file to open. The file should
     * already exist and should be readable and writable
     * by the world, but not by the group.
     *
     * <p>Create an instance variable for the database<p>
     * <code>Downey.SimpleDB m_database;</code>
     * <p>Construct the object only once in your servlet. The best place
     * to call it is in the <i>init</i> method<p>
     *
     * <code>m_database = new Downey.SimpleDB("/aul/homes/dlett004/cgs4825/java-servlets/WEB-INF/classes/myFile.db");</code>
     */
    public SimpleDB(String fileName) {
        m_fileName = fileName;
        openDatabase();
    }
  
    /* Opens the database. It is called when the SimpleDB object is constructed.
     */
    private synchronized void openDatabase () {
        File f = new File(m_fileName);
        if (f.exists()) {
            try {
                ObjectInputStream in = new ObjectInputStream
                    (new FileInputStream(f));
                m_database = (HashMap)in.readObject();
                in.close();
            } catch (IOException ioe) {
                m_database = new HashMap();
            } catch (ClassNotFoundException nfe) {
                m_database = new HashMap(); 
            }
        } else {
            m_database = new HashMap();
        }      
    }
   
    
    /* Call this method to write the entire contents of the database to disk. This
     * should be called after every time something is added, just in case there is
     * a server crash.
     */    
    private synchronized void saveDatabase() {
        File f = new File(m_fileName);
        try {
            ObjectOutputStream out = new ObjectOutputStream
                (new FileOutputStream(f));
            out.writeObject(m_database);
            out.close(); 
        } catch (IOException ioe) {
            System.out.println("Couldn't save file\n" + ioe);
        } 
    }
    
    /** Read a record object from the database. 
     * @param key This is the string key used to access the database.
     * @return The Object that is associated with the key
     * <p>It will be necessary to cast
     * the return type to the correct class in your code. It is up to you to insure
     * that you retrieve the correct type.<p>
     * <code>MyRecordClass record = (MyRecordClass) m_database.readRecord("fred");</code>
     */
    public Object readRecord(String key) {
        return m_database.get(key);
    }
    
    /** This will either add or update the object associated with the given key.
     * 
     * @param key The string used to access that database
     * @param obj The object to be added to the database
     * <p>
     * It is not necessary to cast the parameter to any type, since all objects 
     * are derived from <i>Object</i>.<p>
     * <code>m_database.updateRecord("fred", record);</code>
     * 
     */
    public synchronized void updateRecord(String key, Object obj) {
        m_database.put(key, obj);
        saveDatabase();
    }
    
    /** This is a helper function for creating an ArrayList from a String[]. 
     * 
     * @param values The String[] to be converted
     * @return The ArrayList that is created with all the elements of the String[]
     * <p>Since String[] are not of the standard collections, it is more difficult
     * to serialize. If you need to save a String[] into the database, first 
     * convert it to an ArrayList. ArrayList is part of the standard collections
     * and is easily serialized.<p>
     * <code>String str[] = request.getParamterValues("team");
     * <br>ArrayList list = m_database.makeList(str);</code>
     */
    public ArrayList makeList(String[] values) {
        ArrayList list = new ArrayList();
        for(int i=0; i < values.length; i++) {
          list.add(values[i]);   
        }
        return list;
    }
    
    /** This is a helper function for creating a String[] from an ArrayList.
     * This is the counterpart of makeList. 
     * @param list The ArrayList to be converted
     * @return The String[] that is created with all the elements of the ArrayList
     * <p>If a String[] has been converted
     * to an ArrayList and stored in the database, then retrieve the ArrayList 
     * from the database and use the method to recreate the original String[]
     * <br><code>String[] str = Downey.makeArray(list);</code>
     */
    public String[] makeArray(ArrayList list) {
        String[] values = new String[list.size()];
        for(int i=0; i < list.size(); i++) {
          values[i] = (String) list.get(i);   
        }
        return values;
    }
    
    /** Delete all the elements in the database.
     * If you need to erase all the elements in the database, then call this
     * method. It will erase the contents of the HashMap and of the file.
     * <p><code>m_database.eraseDatabase();</code>
     */
    public synchronized void eraseDatabase() {
       m_database = new HashMap();
       saveDatabase();
    }  
}