source: greenstone3/trunk/src/java/org/greenstone/gsdl3/util/GDBMWrapper.java@ 16869

/*
 *    GDBMWrapper.java
 *    Copyright (C) 2008 New Zealand Digital Library, http://www.nzdl.org
 *
 *    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.gsdl3.util;

import au.com.pharos.gdbm.GdbmFile;
import au.com.pharos.packing.*;
import au.com.pharos.gdbm.GdbmException;

import org.apache.log4j.Logger;

import java.io.UnsupportedEncodingException;

/** java wrapper class for gdbm - uses Java-GDBM written by Martin Pool
 * replaces gdbmclass in the old version
 */

public class GDBMWrapper 
  implements FlatDatabaseWrapper {

  static Logger logger = Logger.getLogger(org.greenstone.gsdl3.util.GDBMWrapper.class.getName());
  
  /* GdbmFile modes:
     READER - read access, many readers may share the database
     WRITER - read/write access, exclusive access
     WRCREAT - read/write access, create db if doesn't exist
     NEWDB - read/write access, db should be replaced if exists
  */
  

    protected GdbmFile db_=null;

  /** open the database filename, with mode mode - uses the constants
      above, eg GdbmFile.WRITER */
  public boolean openDatabase(String filename, int mode) {
    // need to convert mode to GdbmFile mode
    if (mode == READ) { 
      mode = GdbmFile.READER;
    } else if (mode == WRITE) {
      mode = GdbmFile.WRITER;
    }   else {
      logger.error ("invalid mode, "+mode+ ", opening db for reading only");
      mode = GdbmFile.READER;
    }
      
    try {
      if (db_!=null) {
    db_.close();
      }
      db_ = new GdbmFile(filename, mode);
    } catch ( GdbmException e) { // the database wasn't opened or created
      logger.error("couldn't open database "+filename);
      return false;
    } 
    db_.setKeyPacking(new StringPacking());
    db_.setValuePacking(new StringPacking());
    return true;
  }
  
  /** close the database associated with this wrapper */
  public void closeDatabase() {
    try {
      if (db_ != null) {
    db_.close();
    db_ = null;
      }
    } catch (GdbmException e) {
      // should never get here - close never actually throws an exception
      logger.error("error on close()");
    }
  }

  public String getValue(String key) {
    if (db_==null) {
      return null;
    }
    String s_info;
    try {
    try {
        // The key is UTF8: do db lookup using the UTF8 version of key
        s_info = (String)db_.fetch(key.getBytes("UTF-8"));
    } catch(UnsupportedEncodingException e) {
        logger.warn("utf8 key for " + key 
             + " unrecognised. Retrying with default encoding.");
        // retry db lookup using default encoding of key instead of UTF8
        s_info = (String)db_.fetch(key);
    }
    } catch (GdbmException e) {
      logger.error("couldn't get record");
      return null;
    }
    if (s_info==null) {
      // record not present
      logger.error("key "+key+" not present in db");
      return null;
    }
    return s_info;
  }

  /** sets the key value as info 
   * TODO - not implemented yet */
  public boolean setValue (String key, String value) {
    if (db_==null) {
      return false;
    }
    return false;
  }
  /** deletes the entry for key 
   * TODO - not implemented yet */
  public boolean deleteKey(String key) {
    if (db_==null) {
      return false;
    }
    return false;
  }

    /** returns a string of key-value entries that
     *  can be printed for debugging purposes. */
    public String displayAllEntries() {
    StringBuffer output = new StringBuffer();
    try{
        java.util.Enumeration e = db_.keys();
        while(e.hasMoreElements()) {
        Object key = e.nextElement();
        Object value = db_.fetch(key);

        output.append("key href: ");
        output.append((String)key);
        output.append("\tvalue ID: ");
        output.append((String)value);
        output.append("\n");
        //logger.warn("key: " + key + "\tvalue: " + value);

        String urlkey = java.net.URLEncoder.encode((String)key, "UTF8");
        output.append("URL encoded key: " + urlkey);
        //logger.warn("URL encoded key: " + urlkey);
        }
    } catch(UnsupportedEncodingException e) {
        logger.warn("Trouble converting key to UTF-8.");
    } catch(Exception e) {
        logger.warn("Exception encountered when trying to displayAllEntries():" + e);
    }
    return output.toString();
    }
}