package org.paneris.bibliomania.fti;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   
   import com.sleepycat.db.Database;
   import com.sleepycat.db.DatabaseConfig;
   import com.sleepycat.db.DatabaseType;
   import com.sleepycat.db.Environment;
  import com.sleepycat.db.DatabaseException;
  import com.sleepycat.db.LockMode;
  import com.sleepycat.db.MemoryException;
  import com.sleepycat.db.DatabaseEntry;
  import com.sleepycat.db.OperationStatus;
  
  public class StringDbHash {
    private Database db;
    private DatabaseConfig dbConfig;
    private DatabaseEntry keyDatabaseEntry = new DatabaseEntry(), valueDatabaseEntry = new DatabaseEntry();
    private String path;
  
    public StringDbHash(Environment env, String path, int cacheSize, int mode)
        throws DatabaseException, FileNotFoundException {
      this.path = path;
      dbConfig = new DatabaseConfig();
      dbConfig.setCacheSize(cacheSize);
      dbConfig.setAllowCreate(true);
      dbConfig.setType(DatabaseType.HASH);
      db = new Database(path, null, dbConfig);
     // db.open(null, path, null, DbConstants.DB_HASH, DbConstants.DB_CREATE | DbConstants.DB_THREAD, mode);
    }
  
    public StringDbHash(String path, int cacheSize, int mode)
        throws DatabaseException, FileNotFoundException {
      this(null, path, cacheSize, mode);
    }
  
    public StringDbHash(Environment env, String path, int cacheSize)
        throws DatabaseException, FileNotFoundException {
      this(env, path, cacheSize, 0644);
    }
  
    public StringDbHash(String path, int cacheSize)
        throws DatabaseException, FileNotFoundException {
      this(null, path, cacheSize);
    }
  
    public synchronized void put(String key, String value) {
      DbUtils.setUserMem(keyDatabaseEntry, key.getBytes());
      DbUtils.setUserMem(valueDatabaseEntry, value.getBytes());
  
      try {
        db.put(null, keyDatabaseEntry, valueDatabaseEntry);
      }
      catch (DatabaseException e) {
        throw new DbUtils.UnexpectedDatabaseExceptionException(e, path);
      }
    }
  
    private byte[] buf = new byte[100];
  
    public synchronized String get(String key) {
      DbUtils.setUserMem(keyDatabaseEntry, key.getBytes());
  
      OperationStatus result;
      for (;;) {
        DbUtils.setUserMem(valueDatabaseEntry, buf);
        try {
          result = db.get(null, keyDatabaseEntry, valueDatabaseEntry,LockMode.DEFAULT);
          break;
        } catch (MemoryException e) {
          buf = new byte[buf.length * 2];
        }
        catch (DatabaseException e) {
          throw new DbUtils.UnexpectedDatabaseExceptionException(e, path);
        }
      }
  
      if (buf.length > 10000)
        buf = new byte[10000];
  
      return result == OperationStatus.SUCCESS ?
               new String(valueDatabaseEntry.getData(), 0, valueDatabaseEntry.getSize()) : null;
    }
  
    public void flush() {
      try {
        db.sync();
      }
      catch (DatabaseException e) {
        throw new DbUtils.UnexpectedDatabaseExceptionException(e, path);
      }
    }
  
    protected void finalize() throws Throwable {
      db.close();
    }
    public static void main(String[] args) throws Exception {
      StringDbHash h = new StringDbHash(null, "/tmp/test.db", 0);
     int e = args[0].indexOf('=');
     if (e == -1)
       System.out.println(h.get(args[0]));
     else
       h.put(args[0].substring(0, e), args[0].substring(e + 1));
     h.flush();
   }
 }