Merge pull request #53 from Workiva/skiplist_compare

Skiplist compare

Author: dustinhiatt-wf

rangetree/skiplist/skiplist.go

@@ -37,6 +37,33 @@ import (
 	"github.com/Workiva/go-datastructures/slice/skip"
 )
 
+// keyed is required as in the rangetree code we often want to compare
+// two different types of bundles and this allows us to do so without
+// checking for each one.
+type keyed interface {
+	key() uint64
+}
+
+type skipEntry uint64
+
+// Compare is required by the skip.Entry interface.
+func (se skipEntry) Compare(other skip.Entry) int {
+	otherSe := other.(skipEntry)
+	if se == otherSe {
+		return 0
+	}
+
+	if se > otherSe {
+		return 1
+	}
+
+	return -1
+}
+
+func (se skipEntry) key() uint64 {
+	return uint64(se)
+}
+
 // isLastDimension simply returns dimension == lastDimension-1.
 // This panics if dimension >= lastDimension.
 func isLastDimension(dimension, lastDimension uint64) bool {
@@ -63,25 +90,55 @@ func needsDeletion(value, index, number int64) bool {
 // dimensionalBundle is an intermediate holder up to the last
 // dimension and represents a wrapper around a skiplist.
 type dimensionalBundle struct {
-	key uint64
-	sl  *skip.SkipList
+	id uint64
+	sl *skip.SkipList
 }
 
-// Key returns the key for this bundle.  Fulfills skip.Entry interface.
-func (db *dimensionalBundle) Key() uint64 {
-	return db.key
+// Compare returns a value indicating the relative relationship and the
+// provided bundle.
+func (db *dimensionalBundle) Compare(e skip.Entry) int {
+	keyed := e.(keyed)
+	if db.id == keyed.key() {
+		return 0
+	}
+
+	if db.id > keyed.key() {
+		return 1
+	}
+
+	return -1
+}
+
+// key returns the key for this bundle.
+func (db *dimensionalBundle) key() uint64 {
+	return db.id
 }
 
 // lastBundle represents a bundle living at the last dimension
 // of the tree.
 type lastBundle struct {
-	key   uint64
+	id    uint64
 	entry rangetree.Entry
 }
 
-// Key returns the key for this bundle.  Fulfills skip.Entry interface.
-func (lb *lastBundle) Key() uint64 {
-	return lb.key
+// Compare returns a value indicating the relative relationship and the
+// provided bundle.
+func (lb *lastBundle) Compare(e skip.Entry) int {
+	keyed := e.(keyed)
+	if lb.id == keyed.key() {
+		return 0
+	}
+
+	if lb.id > keyed.key() {
+		return 1
+	}
+
+	return -1
+}
+
+// Key returns the key for this bundle.
+func (lb *lastBundle) key() uint64 {
+	return lb.id
 }
 
 type skipListRT struct {
@@ -105,7 +162,7 @@ func (rt *skipListRT) add(entry rangetree.Entry) rangetree.Entry {
 
 	for i := uint64(0); i < rt.dimensions; i++ {
 		value = entry.ValueAtDimension(i)
-		e = sl.Get(uint64(value))[0]
+		e = sl.Get(skipEntry(value))[0]
 		if isLastDimension(i, rt.dimensions) {
 			if e != nil { // this is an overwrite
 				lb = e.(*lastBundle)
@@ -115,14 +172,14 @@ func (rt *skipListRT) add(entry rangetree.Entry) rangetree.Entry {
 			}
 
 			// need to add new sl entry
-			lb = &lastBundle{key: uint64(value), entry: entry}
+			lb = &lastBundle{id: uint64(value), entry: entry}
 			rt.number++
 			sl.Insert(lb)
 			return nil
 		}
 
 		if e == nil { // we need the intermediate dimension
-			db = &dimensionalBundle{key: uint64(value), sl: skip.New(uint64(0))}
+			db = &dimensionalBundle{id: uint64(value), sl: skip.New(uint64(0))}
 			sl.Insert(db)
 		} else {
 			db = e.(*dimensionalBundle)
@@ -155,7 +212,7 @@ func (rt *skipListRT) get(entry rangetree.Entry) rangetree.Entry {
 	)
 	for i := uint64(0); i < rt.dimensions; i++ {
 		value = uint64(entry.ValueAtDimension(i))
-		e = sl.Get(value)[0]
+		e = sl.Get(skipEntry(value))[0]
 		if e == nil {
 			return nil
 		}
@@ -195,7 +252,7 @@ func (rt *skipListRT) deleteRecursive(sl *skip.SkipList, dimension uint64,
 
 	value := entry.ValueAtDimension(dimension)
 	if isLastDimension(dimension, rt.dimensions) {
-		entries := sl.Delete(uint64(value))
+		entries := sl.Delete(skipEntry(value))
 		if entries[0] == nil {
 			return nil
 		}
@@ -204,7 +261,7 @@ func (rt *skipListRT) deleteRecursive(sl *skip.SkipList, dimension uint64,
 		return entries[0].(*lastBundle).entry
 	}
 
-	db, ok := sl.Get(uint64(value))[0].(*dimensionalBundle)
+	db, ok := sl.Get(skipEntry(value))[0].(*dimensionalBundle)
 	if !ok { // value was not found
 		return nil
 	}
@@ -215,7 +272,7 @@ func (rt *skipListRT) deleteRecursive(sl *skip.SkipList, dimension uint64,
 	}
 
 	if db.sl.Len() == 0 {
-		sl.Delete(db.key)
+		sl.Delete(db)
 	}
 
 	return result
@@ -239,9 +296,9 @@ func (rt *skipListRT) apply(sl *skip.SkipList, dimension uint64,
 
 	var e skip.Entry
 
-	for iter := sl.Iter(uint64(lowValue)); iter.Next(); {
+	for iter := sl.Iter(skipEntry(lowValue)); iter.Next(); {
 		e = iter.Value()
-		if int64(e.Key()) >= highValue {
+		if int64(e.(keyed).key()) >= highValue {
 			break
 		}
 
@@ -282,7 +339,7 @@ func (rt *skipListRT) Query(interval rangetree.Interval) rangetree.Entries {
 
 func (rt *skipListRT) flatten(sl *skip.SkipList, dimension uint64, entries *rangetree.Entries) {
 	lastDimension := isLastDimension(dimension, rt.dimensions)
-	for iter := sl.Iter(0); iter.Next(); {
+	for iter := sl.Iter(skipEntry(0)); iter.Next(); {
 		if lastDimension {
 			*entries = append(*entries, iter.Value().(*lastBundle).entry)
 		} else {
@@ -299,9 +356,9 @@ func (rt *skipListRT) insert(sl *skip.SkipList, dimension, insertDimension uint6
 	affectedDimension := dimension == insertDimension
 	var iter skip.Iterator
 	if dimension == insertDimension {
-		iter = sl.Iter(uint64(index))
+		iter = sl.Iter(skipEntry(index))
 	} else {
-		iter = sl.Iter(0)
+		iter = sl.Iter(skipEntry(0))
 	}
 
 	var toDelete skip.Entries
@@ -317,32 +374,30 @@ func (rt *skipListRT) insert(sl *skip.SkipList, dimension, insertDimension uint6
 			)
 			continue
 		}
-		if needsDeletion(int64(e.Key()), index, number) {
+		if needsDeletion(int64(e.(keyed).key()), index, number) {
 			toDelete = append(toDelete, e)
 			continue
 		}
 
 		if lastDimension {
-			e.(*lastBundle).key += uint64(number)
+			e.(*lastBundle).id += uint64(number)
 			*affected = append(*affected, e.(*lastBundle).entry)
 		} else {
-			e.(*dimensionalBundle).key += uint64(number)
+			e.(*dimensionalBundle).id += uint64(number)
 			rt.flatten(e.(*dimensionalBundle).sl, dimension+1, affected)
 		}
 	}
 
 	if len(toDelete) > 0 {
-		keys := make([]uint64, 0, len(toDelete))
 		for _, e := range toDelete {
 			if lastDimension {
 				*deleted = append(*deleted, e.(*lastBundle).entry)
 			} else {
 				rt.flatten(e.(*dimensionalBundle).sl, dimension+1, deleted)
 			}
-			keys = append(keys, e.Key())
 		}
 
-		sl.Delete(keys...)
+		sl.Delete(toDelete...)
 	}
 }
 

slice/skip/entries.go

@@ -22,21 +22,21 @@ import "sort"
 // where that key would be inserted in this list.  This could
 // be equal to the length of the list which means no suitable entry
 // point was found.
-func (entries Entries) search(key uint64) int {
+func (entries Entries) search(e Entry) int {
 	return sort.Search(len(entries), func(i int) bool {
-		return entries[i].Key() >= key
+		return entries[i].Compare(e) > -1
 	})
 }
 
 // insert will insert the provided entry into this list.
 func (entries *Entries) insert(entry Entry) Entry {
-	i := entries.search(entry.Key())
+	i := entries.search(entry)
 	if i >= len(*entries) {
 		*entries = append(*entries, entry)
 		return nil
 	}
 
-	if (*entries)[i].Key() == entry.Key() {
+	if (*entries)[i].Compare(entry) == 0 {
 		oldEntry := (*entries)[i]
 		(*entries)[i] = entry
 		return oldEntry
@@ -49,13 +49,13 @@ func (entries *Entries) insert(entry Entry) Entry {
 }
 
 // delete will delete the provided key from this list.
-func (entries *Entries) delete(key uint64) Entry {
-	i := entries.search(key)
+func (entries *Entries) delete(e Entry) Entry {
+	i := entries.search(e)
 	if i >= len(*entries) {
 		return nil
 	}
 
-	if (*entries)[i].Key() != key {
+	if (*entries)[i].Compare(e) != 0 {
 		return nil
 	}
 
@@ -68,13 +68,13 @@ func (entries *Entries) delete(key uint64) Entry {
 
 // get will return the entry associated with the provided key.
 // If no such Entry exists, this returns nil.
-func (entries Entries) get(key uint64) Entry {
-	i := entries.search(key)
+func (entries Entries) get(e Entry) Entry {
+	i := entries.search(e)
 	if i >= len(entries) {
 		return nil
 	}
 
-	if entries[i].Key() == key {
+	if entries[i].Compare(e) == 0 {
 		return entries[i]
 	}
 

slice/skip/entries_test.go

@@ -52,11 +52,11 @@ func TestEntriesDelete(t *testing.T) {
 
 	entries := Entries{e1, e2}
 
-	result := entries.delete(10)
+	result := entries.delete(e2)
 	assert.Equal(t, Entries{e1}, entries)
 	assert.Equal(t, e2, result)
 
-	result = entries.delete(5)
+	result = entries.delete(e1)
 	assert.Equal(t, Entries{}, entries)
 	assert.Equal(t, e1, result)
 }

slice/skip/interface.go

@@ -19,8 +19,10 @@ package skip
 // Entry defines items that can be inserted into the skip list.
 // This will also be the type returned from a query.
 type Entry interface {
-	// Key defines this entry's place in the skip list.
-	Key() uint64
+	// Compare this entry to the provided entry.  Return a positive
+	// number if this entry is greater than, 0 if equal, negative
+	// number if less than.
+	Compare(Entry) int
 }
 
 // Entries is a typed list of interface Entry.

slice/skip/iterator.go

@@ -68,61 +68,3 @@ func (iter *iterator) exhaust() Entries {
 func nilIterator() *iterator {
 	return &iterator{}
 }
-
-// starIterator is used as an iterator by the SkipList*.
-type starIterator struct {
-	entries Entries
-	iter    Iterator
-	index   int
-}
-
-// isExhausted returns a bool indicating if all values have been
-// iterated.
-func (si *starIterator) isExhausted() bool {
-	return si.index == iteratorExhausted
-}
-
-// Next returns a bool indicating if there are any further values
-// in this iterator.
-func (si *starIterator) Next() bool {
-	if si.isExhausted() {
-		return false
-	}
-
-	si.index++
-	if si.index >= len(si.entries) {
-		canNext := si.iter.Next()
-		if !canNext {
-			si.index = iteratorExhausted
-			return false
-		}
-
-		si.entries = si.iter.Value().(*entryBundle).entries
-		si.index = 0
-	}
-
-	return true
-}
-
-// Value returns an Entry representing the iterator's present
-// position in the query.  Returns nil if no values remain to iterate.
-func (si *starIterator) Value() Entry {
-	if si.isExhausted() {
-		return nil
-	}
-
-	if si.entries == nil || si.index < 0 || si.index >= len(si.entries) {
-		return nil
-	}
-
-	return si.entries[si.index]
-}
-
-func (si *starIterator) exhaust() Entries {
-	entries := make(Entries, 0, 20)
-	for i := si; i.Next(); {
-		entries = append(entries, i.Value())
-	}
-
-	return entries
-}