add leastGreaterThanOrEqual(), leastGreaterThan()

Author: edadma

src/main/scala/BPlusTree.scala

@@ -240,6 +240,33 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
 	protected def setValue[V1 >: V]( node: N, index: Int, v: V1 )
 
 
+	/**
+	 * Returns the leaf position of the key that is least greater than or equal to `key`.
+	 **/
+	protected def leastGTE( key: K ) =
+		lookupGTE( key ) match {
+			case (_, leaf, index) => (leaf, index)
+		}
+
+	/**
+	 * Returns the leaf position of the key that is least greater than `key`.
+	 **/
+	protected def leastGT( key: K ) =
+		lookupGTE( key ) match {
+			case (true, leaf, index) => nextPosition( leaf, index )
+			case (false, leaf, index) => (leaf, index)
+		}
+
+	/**
+	 * Returns the key/value pair whose key is least greater than or equal to `key`.
+	 */
+	def leastGreaterThanOrEqual( key: K ) = optionalKeyValue( leastGTE(key) )
+
+	/**
+	 * Returns the key/value pair whose key is least greater than `key`.
+	 */
+	def leastGreaterThan( key: K ) = optionalKeyValue( leastGT(key) )
+	
 	/**
 	 * Returns a bounded iterator over a range of key/value pairs in the tree in ascending sorted key order. The range of key/value pairs in the iterator is specified by `bounds`.  `bounds` must contain one or two pairs where the first element in the pair is a symbol corresponding to the type of bound (i.e. '<, '<=, '>, '>=) and the second element is a key value.
 	 * 
@@ -251,20 +278,9 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
 	 * Returns a bounded iterator over a range of key positions (node/index pairs) in the tree in ascending sorted key order. The `bounds` parameter is the same as for [[boundedIterator]].
 	 */
 	protected def boundedPositionIterator( bounds: (Symbol, K)* ): Iterator[(N, Int)] = {
-		def gte( key: K ) =
-			lookupGTE( key ) match {
-				case (_, leaf, index) => (leaf, index)
-			}
-
-		def gt( key: K ) =
-			lookupGTE( key ) match {
-				case (true, leaf, index) => nextPosition( leaf, index )
-				case (false, leaf, index) => (leaf, index)
-			}
-
 		require( bounds.length == 1 || bounds.length == 2, "boundedIterator: one or two bounds" )
 
-		val symbols = ListMap[Symbol, K => (N, Int)]( '> -> gt, '>= -> gte, '< -> gte, '<= -> gt )
+		val symbols = ListMap[Symbol, K => (N, Int)]( '> -> leastGT, '>= -> leastGTE, '< -> leastGTE, '<= -> leastGT )
 
 		require( bounds forall {case (s, _) => symbols contains s}, "boundedIterator: expected one of '<, '<=, '>, '>=" )
 
@@ -395,6 +411,24 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
    */
 	def reverseKeysIterator = reversePositionIterator map {case (n, i) => getKey( n, i )}
 
+	protected def optionalKeyValue( pos: (N, Int) ) =
+		pos match {
+			case (leaf, index) =>
+				if (index < nodeLength( leaf ))
+					Some( getKeyValue(leaf, index ))
+				else
+					None
+		}
+	
+	protected def optionalKey( pos: (N, Int) ) =
+		pos match {
+			case (leaf, index) =>
+				if (index < nodeLength( leaf ))
+					Some( getKey(leaf, index ))
+				else
+					None
+		}
+		
 	/**
 	 * Returns the maximum key and it's associated value.
 	 * 
@@ -404,7 +438,7 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
 		if (isEmpty)
 			None
 		else
-			Some( (getKey(last, lastlen - 1), getValue(last, lastlen - 1)) )
+			Some( getKeyValue(last, lastlen - 1) )
 
 	/**
    * Returns the maximum key.
@@ -420,20 +454,12 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
 	 * 
 	 * @return `Some( (key, value) )` where `key` is the minimum key and `value` is it's associated value if the tree is non-empty, or `None` if the tree is empty.
 	 */
-	def min =
-		if (isEmpty)
-			None
-		else
-			Some( (getKey(first, 0), getValue(first, 0)) )
+	def min = optionalKeyValue( first, 0 )
 
   /**
    * Returns the minimum key.
    */
-  def minKey =
-    if (isEmpty)
-      None
-    else
-      Some( getKey(first, 0) )
+  def minKey = optionalKey( first, 0 )
 
   /**
    * Inserts `key` with associated `value` into the tree. If `key` exists, then it's new associated value will be `value`.
@@ -559,12 +585,6 @@ abstract class BPlusTree[K <% Ordered[K], +V] {
 		_lookup( root )
 	}
 
-	/**
-	 * Returns the key/value pair at `index` in `leaf` as well as the leaf node and index where the next key (in sorted order) is located. This method assumes that `index` is the index of an existing key within `node`.
-	 * 
-	 * @return a pair where the first element is the key/value pair, and the second element is a pair containing the node containing the next key in sorted order (or `null` if there is no next key), and the index of the next key (or 0 if there is no next key)
-	 */
-	protected def nextKeyValue( leaf: N, index: Int ) = (getKeyValue( leaf, index), nextPosition( leaf, index ))
 
 	/**
 	 * Returns the key/value pair at `index` within `leaf`.

src/main/scala/FileBPlusTree.scala

@@ -297,22 +297,10 @@ class FileBPlusTree[K <% Ordered[K], V]( protected val file: RandomAccessFile, p
 			val dstKeys = savedKeys.view( begin*DATUM_SIZE, end*DATUM_SIZE ).toArray
 			val dstBranches = savedBranches.view( begin + 1, end + 1 ).toArray
 			val len = savedLength - (end - begin)
-			
-// 			dstKeys.insertAll( 0, savedKeys.view(begin, end) )
-// 			savedKeys.remove( begin, end - begin )
-// 			dstBranches.insertAll( 0, savedBranches.view(begin + 1, end + 1) )
-// 			savedBranches.remove( begin + 1, end - begin )
-			
 			file seek (src + NODE_KEYS)
 			file write (savedKeys, 0, len*DATUM_SIZE)
 			file seek (dst + NODE_KEYS)
 			file write dstKeys
-			
-// 			for ((k, i) <- savedKeys zipWithIndex)
-// 				setKey( src, i, k )
-// 				
-// 			for ((k, i) <- dstKeys zipWithIndex)
-// 				setKey( dst, i, k )
 
 			for (i <- 0 to begin)
 				setBranch( src, i, savedBranches(i) )
@@ -346,22 +334,10 @@ class FileBPlusTree[K <% Ordered[K], V]( protected val file: RandomAccessFile, p
 			file write (savedKeys, 0, len*DATUM_SIZE)
 			file seek (src + LEAF_VALUES)
 			file write (savedValues, 0, len*DATUM_SIZE)
-			
-// 			for (((k, v), i) <- savedKeys zip savedValues zipWithIndex) {
-// 				setKey( src, i, k )
-// 				setValue( src, i, v )
-// 			}
-			
 			file seek (dst + NODE_KEYS)
 			file write dstKeys
 			file seek (dst + LEAF_VALUES)
 			file write dstValues
-			
-// 			for (((k, v), i) <- dstKeys zip dstValues zipWithIndex) {
-// 				setKey( dst, i, k )
-// 				setValue( dst, i, v )
-// 			}
-			
 			nodeLength( src, len )
 			nodeLength( dst, dstlen )
 			savedNode = NUL
@@ -419,8 +395,6 @@ class FileBPlusTree[K <% Ordered[K], V]( protected val file: RandomAccessFile, p
 		if (node == savedNode) {
 			Array.copy( savedKeys, (keyIndex + 1)*DATUM_SIZE, savedKeys, keyIndex*DATUM_SIZE, (savedLength - keyIndex - 1)*DATUM_SIZE )
 			Array.copy( savedBranches, branchIndex + 1, savedBranches, branchIndex, savedLength - branchIndex )
-// 			savedKeys.remove( keyIndex, 1 )
-// 			savedBranches.remove( branchIndex, 1 )
 			savedLength -= 1
 			savedLength
 		} else {

src/test/scala/MiscTests.scala

@@ -0,0 +1,30 @@
+package xyz.hyperreal.btree
+
+import org.scalatest._
+import prop.PropertyChecks
+import org.scalatest.prop.TableDrivenPropertyChecks._
+import org.scalatest.Assertions._
+
+
+class MiscTests extends FreeSpec with PropertyChecks with Matchers {
+
+	"max/min" in {
+		val t = new MemoryBPlusTree[Int, Symbol]( 3 )
+		
+		t.min shouldBe None
+		t.max shouldBe None
+		t.minKey shouldBe None
+		t.maxKey shouldBe None
+		t.insert( 5, 'five )
+		t.min shouldBe Some((5, 'five))
+		t.max shouldBe Some((5, 'five))
+		t.minKey shouldBe Some(5)
+		t.maxKey shouldBe Some(5)
+		t.insert( 3, 'three )
+		t.min shouldBe Some((3, 'three))
+		t.max shouldBe Some((5, 'five))
+		t.minKey shouldBe Some(3)
+		t.maxKey shouldBe Some(5)
+	}
+	
+}