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.OBStoreByte;
  import net.obsearch.storage.TupleByte;
  
  import com.sleepycat.bind.tuple.ByteBinding;
  
  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;
  
  /** 
  	*  BDBOBStoreByte is a wrapper for Berkeley indexes that assumes
  	*  that keys are bytes and values are byte[].
  	*  
    *  @author      Arnoldo Jose Muller Molina    
    */
  
  public final class BDBOBStoreJeByte
          extends AbstractBDBOBStoreJe<TupleByte> implements OBStoreByte {
  
      /**
       * Builds a new Storage system by receiving a Berkeley DB database that uses
       * bytes 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 BDBOBStoreJeByte(String name, Database db, Database seq, OBStoreFactory fact, boolean duplicates) throws DatabaseException {
  								super(name, db, seq, fact, duplicates);
      }
  
      public net.obsearch.OperationStatus delete(byte 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(byte value) {
          return BDBFactoryJe.byteToBytes(value);
      }
  
  
  		/**
       * Converts the value of the given entry into its primitive type.
       * @param entry
       *                The place where we will put the entry.
       */
      public byte bytesToValue(byte[] entry) {
          //TupleInput in = new TupleInput(entry);
  				//return in.readByte();
  				DatabaseEntry e = new DatabaseEntry(entry);
          return ByteBinding.entryToByte(e);        
      }
  
      public byte[] getValue(byte key) throws IllegalArgumentException,
              OBStorageException {
          return super.getValue(getBytes(key));
      }
  
      public net.obsearch.OperationStatus put(byte key, byte[] value) throws IllegalArgumentException,
              OBStorageException {
         return super.put(getBytes(key), value);
     }
 
     public CloseIterator < TupleByte > processRange(byte low, byte high)
             throws OBStorageException {
         return new ByteIterator(low, high);
     }
 
 		public CloseIterator < TupleByte > processRangeNoDup(byte low, byte high)
             throws OBStorageException {
         return new ByteIterator(low, high, false,false);
     }
 
 		public CloseIterator < TupleByte > processRangeReverse(byte low, byte high)
             throws OBStorageException {
         return new ByteIterator(low, high,true,true);
     }
 
 		public CloseIterator < TupleByte > processRangeReverseNoDup(byte low, byte high)
             throws OBStorageException {
         return new ByteIterator(low, high,true,false);
     }
 
 		public CloseIterator < TupleByte > processAll()
             throws OBStorageException {
         return new ByteIterator();
     }
 
     /**
      * 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 ByteIterator extends CursorIterator < TupleByte > {
         
        
         private ByteIterator(byte min, byte max) throws OBStorageException {
 						super(getBytes(min), getBytes(max));
         }
 
 				/**
 				 * Creates a new ByteIterator given a min range, max range and
 				 * a flag saying if this iterator will go "forward" or "backwards"
 				 */
 				private ByteIterator(byte min, byte max, boolean reverseMode, boolean dups) throws OBStorageException {
 						super(getBytes(min), getBytes(max), false, reverseMode, dups);
         }
 
 				private ByteIterator() throws OBStorageException {
 						super(null, null,true, false,true);
         }
 
 				protected TupleByte createTuple(byte[] key, byte[] value) {
             return new TupleByte(bytesToValue(key),value);
         }
     }
 }