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