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 StaticDB { /* *The file name that corresponds to the DB */ static protected String m_fileName = "/home/ocelot/aul-user-web/jakarta-tomcat-5.0.19/shared/hw3.db"; //"/data.tim/cgs4825/tomcat/WEB-INF/classes/hw3.db"; /* *Name of HashMap that contains DB */ static protected HashMap m_database; /* *Flag for determing if DB is open */ static protected boolean isOpen = false; /**init with no parameters. It will only create a DB if the setFileName method *has already been called. Call this method before using the DB. Test the return *value, it should be empty. If it is not empty, then it will tell you why the *DB can not be accessed.
*String error = StaticDB.init();
*if (!error.equals("")) {
* out.println("Could not access DB: " + error);
*}
*
*/
public static String init() {
if (m_fileName == null || m_fileName.trim().equals("")) {
return "Cannot init: file name not set";
}
return openDatabase();
}
/** Opens the database.
*
* It is called when the StaticDB object is constructed.
* This is a protected method.
*
*/
protected synchronized static String openDatabase () {
String error = "";
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) {
error = "Couldn't open database file\n" + ioe;
m_database = new HashMap();
} catch (ClassNotFoundException nfe) {
error = "Couldn't find class\n" + nfe;
m_database = new HashMap();
}
} else {
int index = m_fileName.lastIndexOf('/');
File p = null;
String path = null;
if (index > -1) {
path = m_fileName.substring(0, index);
p = new File(path);
}
if (p != null && !p.exists()) {
error = "Error: " + path + " is an invalid path. Creating empty DB.";
} else {
error = m_fileName + " does not exist. Creating empty DB.";
}
m_database = new HashMap();
}
if (!"".equals(error)) {
System.out.println(error);
}
isOpen = true;
return error;
}
/** 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. This method is protected. It should only be called if you are
* deriving a new DB class from this one.
*/
protected synchronized static void saveDatabase() {
if (!isOpen) {
System.out.println("Cannot save: no database is initialized");
return;
}
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
* 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.
* MyRecordClass record = (MyRecordClass) StaticDB.readRecord("fred");
*/
public static Object readRecord(String key) {
if (!isOpen) {
System.out.println("Cannot read: no database is initialized");
return null;
}
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
*
* It is not necessary to cast the parameter to any type, since all objects * are derived from Object.
* StaticDB.updateRecord("fred", record);
*
*/
public synchronized static void updateRecord(String key, Object obj) {
if (!isOpen) {
System.out.println("Cannot update: no database is initialized");
return;
}
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[]
*
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.
* String str[] = request.getParamterValues("team");
*
*/
public static 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
*
ArrayList list = StaticDB.makeList(str);
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[]
* String[] str = StaticDB.makeArray(list);
*/
public static 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.
*
StaticDB.eraseDatabase();
*/
public synchronized static void eraseDatabase() {
if (!isOpen) {
System.out.println("Cannot erase: no database is initialized");
return;
}
m_database = new HashMap();
saveDatabase();
}
/** Returns an Iterator of the keys in the DB
*@return Iterator of keys
*
*java.util.iterator it = StaticDB.keyIterator();
*while(it.hasNext()) {
* String key = (String) it.next();
*}
*
*/
public static Iterator keyIterator() {
if (!isOpen) {
System.out.println("Cannot get iterator: no database is initialized");
return null;
}
return m_database.keySet().iterator();
}
/** Returns an Iterator of the values in the DB
*@return Iterator of values
*
*java.util.iterator it = StaticDB.valueIterator();
*while(it.hasNext()) {
* MyRecord rec = (MyRecord) it.next();
*}
*
*/
public static Iterator valueIterator() {
if (!isOpen) {
System.out.println("Cannot get iterator: no database is initialized");
return null;
}
return m_database.values().iterator();
}
}