Merge branch 'master' into actions

Author: tidwall

README.md

@@ -10,8 +10,8 @@ An efficient [B-tree](https://en.wikipedia.org/wiki/B-tree) implementation in Go
 - `Map` and `Set` types for ordered key-value maps and sets,
 - Fast bulk loading for pre-ordered data using the `Load()` method.
 - `Copy()` method with copy-on-write support.
-- Thread-safe operations.
 - [Path hinting](PATH_HINT.md) optimization for operations with nearby keys.
+- Allows for array-like operations. ([Counted B-tree](https://www.chiark.greenend.org.uk/~sgtatham/algorithms/cbtree.html))
 
 ## Using
 
@@ -27,16 +27,15 @@ This package includes the following types of B-trees:
 
 - [`btree.Map`](#btreemap):
 A fast B-tree for storing ordered key value pairs.
-Go 1.18+ 
+
 - [`btree.Set`](#btreeset):
 Like `Map`, but only for storing keys.
-Go 1.18+
-- [`btree.BTreeG`](#btreegeneric):
-A feature-rich B-tree for storing data using a custom comparator.
-Go 1.18+
+
+- [`btree.BTreeG`](#btreebtreeg):
+A feature-rich B-tree for storing data using a custom comparator. Thread-safe.
+
 - [`btree.BTree`](#btreebtree):
-Like `BTreeG` but uses the `interface{}` type for data. Backwards compatible.
-Go 1.16+
+Like `BTreeG` but uses the `interface{}` type for data. Backwards compatible. Thread-safe.
 
 ### btree.Map
 
@@ -221,6 +220,9 @@ Load(item)              // load presorted items into tree
 SetHint(item, *hint)    // insert or replace an existing item
 GetHint(item, *hint)    // get an existing item
 DeleteHint(item, *hint) // delete an item
+AscendHint(key, iter, *hint)
+DescendHint(key, iter, *hint)
+SeekHint(key, iter, *hint)
 
 // Copy-on-write
 Copy()                  // copy the btree
@@ -341,6 +343,9 @@ Load(item)              // load presorted items into tree
 SetHint(item, *hint)    // insert or replace an existing item
 GetHint(item, *hint)    // get an existing item
 DeleteHint(item, *hint) // delete an item
+AscendHint(key, iter, *hint)
+DescendHint(key, iter, *hint)
+SeekHint(key, iter, *hint)
 
 // Copy-on-write
 Copy()                  // copy the btree

btree.go

@@ -20,6 +20,7 @@ func New(less func(a, b any) bool) *BTree {
 //
 // This is useful for when you do not need the BTree to manage the locking,
 // but would rather do it yourself.
+//
 // Deprecated: use NewOptions
 func NewNonConcurrent(less func(a, b any) bool) *BTree {
 	if less == nil {
@@ -64,16 +65,34 @@ func (tr *BTree) SetHint(item any, hint *PathHint) (prev any) {
 // Get a value for key.
 // Returns nil if the key was not found.
 func (tr *BTree) Get(key any) any {
-	return tr.GetHint(key, nil)
+	return tr.getHintMut(key, nil, false)
+}
+
+func (tr *BTree) GetMut(key any) any {
+	return tr.getHintMut(key, nil, true)
+}
+
+func (tr *BTree) GetHint(key any, hint *PathHint) any {
+	return tr.getHintMut(key, hint, false)
+}
+
+func (tr *BTree) GetHintMut(key any, hint *PathHint) any {
+	return tr.getHintMut(key, hint, true)
 }
 
 // GetHint gets a value for key using a path hint.
 // Returns nil if the item was not found.
-func (tr *BTree) GetHint(key any, hint *PathHint) (value any) {
+func (tr *BTree) getHintMut(key any, hint *PathHint, mut bool) (value any) {
 	if key == nil {
 		return nil
 	}
-	v, ok := tr.base.GetHint(key, hint)
+	var v any
+	var ok bool
+	if mut {
+		v, ok = tr.base.GetHintMut(key, hint)
+	} else {
+		v, ok = tr.base.GetHint(key, hint)
+	}
 	if !ok {
 		return nil
 	}
@@ -97,7 +116,7 @@ func (tr *BTree) DeleteHint(key any, hint *PathHint) (prev any) {
 	if key == nil {
 		return nil
 	}
-	v, ok := tr.base.DeleteHint(key, nil)
+	v, ok := tr.base.DeleteHint(key, hint)
 	if !ok {
 		return nil
 	}
@@ -115,6 +134,34 @@ func (tr *BTree) Ascend(pivot any, iter func(item any) bool) {
 	}
 }
 
+func (tr *BTree) AscendMut(pivot any, iter func(item any) bool) {
+	if pivot == nil {
+		tr.base.ScanMut(iter)
+	} else {
+		tr.base.AscendMut(pivot, iter)
+	}
+}
+
+func (tr *BTree) AscendHint(pivot any, iter func(item any) bool,
+	hint *PathHint,
+) {
+	if pivot == nil {
+		tr.base.Scan(iter)
+	} else {
+		tr.base.AscendHint(pivot, iter, hint)
+	}
+}
+
+func (tr *BTree) AscendHintMut(pivot any, iter func(item any) bool,
+	hint *PathHint,
+) {
+	if pivot == nil {
+		tr.base.ScanMut(iter)
+	} else {
+		tr.base.AscendHintMut(pivot, iter, hint)
+	}
+}
+
 // Descend the tree within the range [pivot, first]
 // Pass nil for pivot to scan all item in descending order
 // Return false to stop iterating
@@ -126,6 +173,34 @@ func (tr *BTree) Descend(pivot any, iter func(item any) bool) {
 	}
 }
 
+func (tr *BTree) DescendMut(pivot any, iter func(item any) bool) {
+	if pivot == nil {
+		tr.base.ReverseMut(iter)
+	} else {
+		tr.base.DescendMut(pivot, iter)
+	}
+}
+
+func (tr *BTree) DescendHint(pivot any, iter func(item any) bool,
+	hint *PathHint,
+) {
+	if pivot == nil {
+		tr.base.Reverse(iter)
+	} else {
+		tr.base.DescendHint(pivot, iter, hint)
+	}
+}
+
+func (tr *BTree) DescendHintMut(pivot any, iter func(item any) bool,
+	hint *PathHint,
+) {
+	if pivot == nil {
+		tr.base.ReverseMut(iter)
+	} else {
+		tr.base.DescendHintMut(pivot, iter, hint)
+	}
+}
+
 // Load is for bulk loading pre-sorted items
 // If the load replaces and existing item then the value for the replaced item
 // is returned.
@@ -150,6 +225,14 @@ func (tr *BTree) Min() any {
 	return v
 }
 
+func (tr *BTree) MinMut() any {
+	v, ok := tr.base.MinMut()
+	if !ok {
+		return nil
+	}
+	return v
+}
+
 // Max returns the maximum item in tree.
 // Returns nil if the tree has no items.
 func (tr *BTree) Max() any {
@@ -160,6 +243,14 @@ func (tr *BTree) Max() any {
 	return v
 }
 
+func (tr *BTree) MaxMut() any {
+	v, ok := tr.base.Max()
+	if !ok {
+		return nil
+	}
+	return v
+}
+
 // PopMin removes the minimum item in tree and returns it.
 // Returns nil if the tree has no items.
 func (tr *BTree) PopMin() any {
@@ -190,6 +281,14 @@ func (tr *BTree) GetAt(index int) any {
 	return v
 }
 
+func (tr *BTree) GetAtMut(index int) any {
+	v, ok := tr.base.GetAtMut(index)
+	if !ok {
+		return nil
+	}
+	return v
+}
+
 // DeleteAt deletes the item at index.
 // Return nil if the tree is empty or the index is out of bounds.
 func (tr *BTree) DeleteAt(index int) any {
@@ -215,19 +314,31 @@ func (tr *BTree) Walk(iter func(items []any)) {
 	})
 }
 
+func (tr *BTree) WalkMut(iter func(items []any)) {
+	tr.base.WalkMut(func(items []any) bool {
+		iter(items)
+		return true
+	})
+}
+
 // Copy the tree. This is a copy-on-write operation and is very fast because
 // it only performs a shadowed copy.
 func (tr *BTree) Copy() *BTree {
 	return &BTree{base: tr.base.Copy()}
 }
 
+func (tr *BTree) IsoCopy() *BTree {
+	return &BTree{base: tr.base.IsoCopy()}
+}
+
 // Clear will delete all items.
 func (tr *BTree) Clear() {
 	tr.base.Clear()
 }
 
+// Iter is an iterator for
 type Iter struct {
-	base GenericIter[any]
+	base IterG[any]
 }
 
 // Iter returns a read-only iterator.
@@ -236,12 +347,20 @@ func (tr *BTree) Iter() Iter {
 	return Iter{tr.base.Iter()}
 }
 
+func (tr *BTree) IterMut() Iter {
+	return Iter{tr.base.IterMut()}
+}
+
 // Seek to item greater-or-equal-to key.
 // Returns false if there was no item found.
 func (iter *Iter) Seek(key any) bool {
 	return iter.base.Seek(key)
 }
 
+func (iter *Iter) SeekHint(key any, hint *PathHint) bool {
+	return iter.base.SeekHint(key, hint)
+}
+
 // First moves iterator to first item in tree.
 // Returns false if the tree is empty.
 func (iter *Iter) First() bool {