package net.obsearch.storage.bdb;
   
   /*
   		OBSearch: a distributed similarity search engine This project is to
    similarity search what 'bit-torrent' is to downloads. 
       Copyright (C) 2008 Arnoldo Jose Muller Molina
   
     	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 3 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, see <http://www.gnu.org/licenses/>.
  */
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import net.obsearch.storage.CloseIterator;
  import net.obsearch.exception.OBStorageException;
  import net.obsearch.storage.OBStoreInt;
  import net.obsearch.storage.TupleInt;
  
  import com.sleepycat.bind.tuple.IntegerBinding;
  
  import com.sleepycat.je.DatabaseEntry;
  
  import com.sleepycat.bind.tuple.TupleOutput;
  import com.sleepycat.bind.tuple.TupleInput;
  
  import com.sleepycat.je.Database;
  import com.sleepycat.je.DatabaseException;
  import com.sleepycat.je.OperationStatus;
  import java.nio.ByteBuffer;
  import net.obsearch.storage.OBStoreFactory;
  
  /** 
  	*  BDBOBStoreInt is a wrapper for Berkeley indexes that assumes
  	*  that keys are ints and values are byte[].
  	*  
    *  @author      Arnoldo Jose Muller Molina    
    */
  
  public final class BDBOBStoreJeInt
          extends AbstractBDBOBStoreJe<TupleInt> implements OBStoreInt {
  
      /**
       * Builds a new Storage system by receiving a Berkeley DB database that uses
       * ints as a primary indexing method.
       * @param db
       *                The database to be stored.
  		 * @param seq     Sequences database.
       * @param name
       *                Name of the database.
       * @throws DatabaseException
       *                 if something goes wrong with the database.
       */
  						public BDBOBStoreJeInt(String name, Database db, Database seq, OBStoreFactory fact, boolean duplicates) throws DatabaseException {
  								super(name, db, seq, fact, duplicates);
      }
  
      public net.obsearch.OperationStatus delete(int key) throws OBStorageException {
          return super.delete(getBytes(key));
      }
  
      /**
       * Converts the given value to an array of bytes.
       * @param value
       *                the value to be converted.
       * @return An array of bytes with the given value encoded.
       */
      private byte[] getBytes(int value) {
          return BDBFactoryJe.intToBytes(value);
      }
  
  
  		/**
       * Converts the value of the given entry into its primitive type.
       * @param entry
       *                The place where we will put the entry.
       */
      public int bytesToValue(byte[] entry) {
          //TupleInput in = new TupleInput(entry);
  				//return in.readInt();
  				DatabaseEntry e = new DatabaseEntry(entry);
          return IntegerBinding.entryToInt(e);        
      }
  
      public byte[] getValue(int key) throws IllegalArgumentException,
              OBStorageException {
          return super.getValue(getBytes(key));
      }
  
      public net.obsearch.OperationStatus put(int key, byte[] value) throws IllegalArgumentException,
              OBStorageException {
         return super.put(getBytes(key), value);
     }
 
     public CloseIterator < TupleInt > processRange(int low, int high)
             throws OBStorageException {
         return new IntIterator(low, high);
     }
 
 		public CloseIterator < TupleInt > processRangeNoDup(int low, int high)
             throws OBStorageException {
         return new IntIterator(low, high, false,false);
     }
 
 		public CloseIterator < TupleInt > processRangeReverse(int low, int high)
             throws OBStorageException {
         return new IntIterator(low, high,true,true);
     }
 
 		public CloseIterator < TupleInt > processRangeReverseNoDup(int low, int high)
             throws OBStorageException {
         return new IntIterator(low, high,true,false);
     }
 
 		public CloseIterator < TupleInt > processAll()
             throws OBStorageException {
         return new IntIterator();
     }
 
     /**
      * Iterator used to process range results.
      */
     /*
      * TODO: I am leaving the closing of the cursor to the last iteration or the
      * finalize method (whichever happens first). We should test if
      * this is ok, or if there is an issue with this because
      * Berkeley's iterator explicitly have a "close" method.
      */
     final class IntIterator extends CursorIterator < TupleInt > {
         
        
         private IntIterator(int min, int max) throws OBStorageException {
 						super(getBytes(min), getBytes(max));
         }
 
 				/**
 				 * Creates a new IntIterator given a min range, max range and
 				 * a flag saying if this iterator will go "forward" or "backwards"
 				 */
 				private IntIterator(int min, int max, boolean reverseMode, boolean dups) throws OBStorageException {
 						super(getBytes(min), getBytes(max), false, reverseMode, dups);
         }
 
 				private IntIterator() throws OBStorageException {
 						super(null, null,true, false,true);
         }
 
 				protected TupleInt createTuple(byte[] key, byte[] value) {
             return new TupleInt(bytesToValue(key),value);
         }
     }
 }