mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2024-01-19 02:48:24 +00:00
change value type to ItemValue
This commit is contained in:
Chris Lu
parent
38c8470d1d
commit
b3e49d2758
|
|
@ -19,7 +19,7 @@ func (self *BpMap) Has(key Hashable) bool {
|
|||
return (*BpTree)(self).Has(key)
|
||||
}
|
||||
|
||||
func (self *BpMap) Put(key Hashable, value interface{}) (err error) {
|
||||
func (self *BpMap) Put(key Hashable, value ItemValue) (err error) {
|
||||
new_root, err := self.getRoot().put(key, value)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -28,7 +28,7 @@ func (self *BpMap) Put(key Hashable, value interface{}) (err error) {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (self *BpMap) Get(key Hashable) (value interface{}, err error) {
|
||||
func (self *BpMap) Get(key Hashable) (value ItemValue, err error) {
|
||||
j, l := self.getRoot().get_start(key)
|
||||
if l.keys[j].Equals(key) {
|
||||
return l.values[j], nil
|
||||
|
|
@ -36,13 +36,13 @@ func (self *BpMap) Get(key Hashable) (value interface{}, err error) {
|
|||
return nil, fmt.Errorf("key not found: %s", key)
|
||||
}
|
||||
|
||||
func (self *BpMap) Remove(key Hashable) (value interface{}, err error) {
|
||||
func (self *BpMap) Remove(key Hashable) (value ItemValue, err error) {
|
||||
value, err = self.Get(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ns := self.getRoot().NodeSize()
|
||||
new_root, err := self.getRoot().remove(key, func(value interface{}) bool { return true })
|
||||
new_root, err := self.getRoot().remove(key, func(value ItemValue) bool { return true })
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ func (self *BpTree) Count(key Hashable) int {
|
|||
return count
|
||||
}
|
||||
|
||||
func (self *BpTree) Add(key Hashable, value interface{}) (err error) {
|
||||
func (self *BpTree) Add(key Hashable, value ItemValue) (err error) {
|
||||
new_root, err := self.getRoot().put(key, value)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -49,7 +49,7 @@ func (self *BpTree) Add(key Hashable, value interface{}) (err error) {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (self *BpTree) Replace(key Hashable, where WhereFunc, value interface{}) (err error) {
|
||||
func (self *BpTree) Replace(key Hashable, where WhereFunc, value ItemValue) (err error) {
|
||||
li := self.getRoot().forward(key, key)
|
||||
for i, leaf, next := li(); next != nil; i, leaf, next = next() {
|
||||
if where(leaf.values[i]) {
|
||||
|
|
@ -70,7 +70,7 @@ func (self *BpTree) Range(from, to Hashable) (kvi KVIterator) {
|
|||
} else {
|
||||
li = self.getRoot().backward(from, to)
|
||||
}
|
||||
kvi = func() (key Hashable, value interface{}, next KVIterator) {
|
||||
kvi = func() (key Hashable, value ItemValue, next KVIterator) {
|
||||
var i int
|
||||
var leaf *BpNode
|
||||
i, leaf, li = li()
|
||||
|
|
@ -125,7 +125,7 @@ func (self *BpTree) Items() (vi KIterator) {
|
|||
|
||||
func (self *BpTree) Iterate() (kvi KVIterator) {
|
||||
li := self.getRoot().all()
|
||||
kvi = func() (key Hashable, value interface{}, next KVIterator) {
|
||||
kvi = func() (key Hashable, value ItemValue, next KVIterator) {
|
||||
var i int
|
||||
var leaf *BpNode
|
||||
i, leaf, li = li()
|
||||
|
|
@ -139,7 +139,7 @@ func (self *BpTree) Iterate() (kvi KVIterator) {
|
|||
|
||||
func (self *BpTree) Backward() (kvi KVIterator) {
|
||||
li := self.getRoot().all_backward()
|
||||
kvi = func() (key Hashable, value interface{}, next KVIterator) {
|
||||
kvi = func() (key Hashable, value ItemValue, next KVIterator) {
|
||||
var i int
|
||||
var leaf *BpNode
|
||||
i, leaf, li = li()
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ type ProtoNode struct {
|
|||
Pointers []int64 `protobuf:"varint,3,rep,packed,name=pointers,proto3" json:"pointers,omitempty"`
|
||||
Next int64 `protobuf:"varint,4,opt,name=next,proto3" json:"next,omitempty"`
|
||||
Prev int64 `protobuf:"varint,5,opt,name=prev,proto3" json:"prev,omitempty"`
|
||||
Id int64 `protobuf:"varint,6,opt,name=id,proto3" json:"id,omitempty"`
|
||||
}
|
||||
|
||||
func (x *ProtoNode) Reset() {
|
||||
|
|
@ -104,22 +105,30 @@ func (x *ProtoNode) GetPrev() int64 {
|
|||
return 0
|
||||
}
|
||||
|
||||
func (x *ProtoNode) GetId() int64 {
|
||||
if x != nil {
|
||||
return x.Id
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
var File_bptree_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_bptree_proto_rawDesc = []byte{
|
||||
0x0a, 0x0c, 0x62, 0x70, 0x74, 0x72, 0x65, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06,
|
||||
0x62, 0x70, 0x74, 0x72, 0x65, 0x65, 0x22, 0x7b, 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x4e,
|
||||
0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
|
||||
0x0c, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65,
|
||||
0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12,
|
||||
0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
|
||||
0x03, 0x52, 0x08, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e,
|
||||
0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x6e, 0x65, 0x78, 0x74, 0x12,
|
||||
0x12, 0x0a, 0x04, 0x70, 0x72, 0x65, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x70,
|
||||
0x72, 0x65, 0x76, 0x42, 0x31, 0x5a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
|
||||
0x6d, 0x2f, 0x63, 0x68, 0x72, 0x69, 0x73, 0x6c, 0x75, 0x73, 0x66, 0x2f, 0x73, 0x65, 0x61, 0x77,
|
||||
0x65, 0x65, 0x64, 0x66, 0x73, 0x2f, 0x77, 0x65, 0x65, 0x64, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x2f,
|
||||
0x62, 0x70, 0x74, 0x72, 0x65, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
0x62, 0x70, 0x74, 0x72, 0x65, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03,
|
||||
0x28, 0x0c, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75,
|
||||
0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
|
||||
0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03,
|
||||
0x28, 0x03, 0x52, 0x08, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x12, 0x0a, 0x04,
|
||||
0x6e, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x6e, 0x65, 0x78, 0x74,
|
||||
0x12, 0x12, 0x0a, 0x04, 0x70, 0x72, 0x65, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04,
|
||||
0x70, 0x72, 0x65, 0x76, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03,
|
||||
0x52, 0x02, 0x69, 0x64, 0x42, 0x31, 0x5a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
|
||||
0x6f, 0x6d, 0x2f, 0x63, 0x68, 0x72, 0x69, 0x73, 0x6c, 0x75, 0x73, 0x66, 0x2f, 0x73, 0x65, 0x61,
|
||||
0x77, 0x65, 0x65, 0x64, 0x66, 0x73, 0x2f, 0x77, 0x65, 0x65, 0x64, 0x2f, 0x75, 0x74, 0x69, 0x6c,
|
||||
0x2f, 0x62, 0x70, 0x74, 0x72, 0x65, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
|
|
|
|||
|
|
@ -1,12 +1,15 @@
|
|||
package bptree
|
||||
|
||||
type ItemValue Equatable
|
||||
|
||||
type BpNode struct {
|
||||
keys []Hashable
|
||||
values []interface{}
|
||||
values []ItemValue
|
||||
pointers []*BpNode
|
||||
next *BpNode
|
||||
prev *BpNode
|
||||
no_dup bool
|
||||
protoNode *ProtoNode
|
||||
}
|
||||
|
||||
func NewInternal(size int) *BpNode {
|
||||
|
|
@ -25,7 +28,7 @@ func NewLeaf(size int, no_dup bool) *BpNode {
|
|||
}
|
||||
return &BpNode{
|
||||
keys: make([]Hashable, 0, size),
|
||||
values: make([]interface{}, 0, size),
|
||||
values: make([]ItemValue, 0, size),
|
||||
no_dup: no_dup,
|
||||
}
|
||||
}
|
||||
|
|
@ -176,7 +179,7 @@ func (self *BpNode) leaf_get_start(key Hashable) (i int, leaf *BpNode) {
|
|||
/* This puts the k/v pair into the B+Tree rooted at this node and returns the
|
||||
* (possibly) new root of the tree.
|
||||
*/
|
||||
func (self *BpNode) put(key Hashable, value interface{}) (root *BpNode, err error) {
|
||||
func (self *BpNode) put(key Hashable, value ItemValue) (root *BpNode, err error) {
|
||||
a, b, err := self.insert(key, value)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -194,7 +197,7 @@ func (self *BpNode) put(key Hashable, value interface{}) (root *BpNode, err erro
|
|||
// left is always set. When split is false left is the pointer to block
|
||||
// When split is true left is the pointer to the new left
|
||||
// block
|
||||
func (self *BpNode) insert(key Hashable, value interface{}) (a, b *BpNode, err error) {
|
||||
func (self *BpNode) insert(key Hashable, value ItemValue) (a, b *BpNode, err error) {
|
||||
if self.Internal() {
|
||||
return self.internal_insert(key, value)
|
||||
} else { // leaf node
|
||||
|
|
@ -208,7 +211,7 @@ func (self *BpNode) insert(key Hashable, value interface{}) (a, b *BpNode, err e
|
|||
* - if the block is full, split this block
|
||||
* - else insert the new key/pointer into this block
|
||||
*/
|
||||
func (self *BpNode) internal_insert(key Hashable, value interface{}) (a, b *BpNode, err error) {
|
||||
func (self *BpNode) internal_insert(key Hashable, value ItemValue) (a, b *BpNode, err error) {
|
||||
if !self.Internal() {
|
||||
return nil, nil, BpTreeError("Expected a internal node")
|
||||
}
|
||||
|
|
@ -272,7 +275,7 @@ func (self *BpNode) internal_split(key Hashable, ptr *BpNode) (a, b *BpNode, err
|
|||
* a pure block with a matching key)
|
||||
* else this leaf will get a new entry.
|
||||
*/
|
||||
func (self *BpNode) leaf_insert(key Hashable, value interface{}) (a, b *BpNode, err error) {
|
||||
func (self *BpNode) leaf_insert(key Hashable, value ItemValue) (a, b *BpNode, err error) {
|
||||
if self.Internal() {
|
||||
return nil, nil, BpTreeError("Expected a leaf node")
|
||||
}
|
||||
|
|
@ -299,7 +302,7 @@ func (self *BpNode) leaf_insert(key Hashable, value interface{}) (a, b *BpNode,
|
|||
* - the two blocks will be balanced with balanced_nodes
|
||||
* - if the key is less than b.keys[0] it will go in a else b
|
||||
*/
|
||||
func (self *BpNode) leaf_split(key Hashable, value interface{}) (a, b *BpNode, err error) {
|
||||
func (self *BpNode) leaf_split(key Hashable, value ItemValue) (a, b *BpNode, err error) {
|
||||
if self.Internal() {
|
||||
return nil, nil, BpTreeError("Expected a leaf node")
|
||||
}
|
||||
|
|
@ -334,7 +337,7 @@ func (self *BpNode) leaf_split(key Hashable, value interface{}) (a, b *BpNode, e
|
|||
* and putting the new key there.
|
||||
* - always return the current block as "a" and the new block as "b"
|
||||
*/
|
||||
func (self *BpNode) pure_leaf_split(key Hashable, value interface{}) (a, b *BpNode, err error) {
|
||||
func (self *BpNode) pure_leaf_split(key Hashable, value ItemValue) (a, b *BpNode, err error) {
|
||||
if self.Internal() || !self.Pure() {
|
||||
return nil, nil, BpTreeError("Expected a pure leaf node")
|
||||
}
|
||||
|
|
@ -392,7 +395,7 @@ func (self *BpNode) put_kp(key Hashable, ptr *BpNode) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (self *BpNode) put_kv(key Hashable, value interface{}) error {
|
||||
func (self *BpNode) put_kv(key Hashable, value ItemValue) error {
|
||||
if self.Full() {
|
||||
return BpTreeError("Block is full.")
|
||||
}
|
||||
|
|
@ -426,7 +429,7 @@ func (self *BpNode) put_key_at(i int, key Hashable) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (self *BpNode) put_value_at(i int, value interface{}) error {
|
||||
func (self *BpNode) put_value_at(i int, value ItemValue) error {
|
||||
if len(self.values) == cap(self.values) {
|
||||
return BpTreeError("Block is full.")
|
||||
}
|
||||
|
|
@ -573,8 +576,8 @@ func (self *BpNode) remove_ptr_at(i int) error {
|
|||
}
|
||||
|
||||
func (self *BpNode) find(key Hashable) (int, bool) {
|
||||
var l int = 0
|
||||
var r int = len(self.keys) - 1
|
||||
var l = 0
|
||||
var r = len(self.keys) - 1
|
||||
var m int
|
||||
for l <= r {
|
||||
m = ((r - l) >> 1) + l
|
||||
|
|
@ -718,7 +721,7 @@ func balance_nodes(a, b *BpNode) {
|
|||
m--
|
||||
}
|
||||
}
|
||||
var lim int = len(a.keys) - m
|
||||
var lim = len(a.keys) - m
|
||||
b.keys = b.keys[:lim]
|
||||
if cap(a.values) > 0 {
|
||||
if cap(a.values) != cap(a.keys) {
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ func (self Strings) Swap(i, j int) {
|
|||
|
||||
type record struct {
|
||||
key String
|
||||
value String
|
||||
value ItemValue
|
||||
}
|
||||
|
||||
type records []*record
|
||||
|
|
@ -84,7 +84,7 @@ func BenchmarkBpTree(b *testing.B) {
|
|||
t.Add(r.key, r.value)
|
||||
}
|
||||
for _, r := range recs {
|
||||
t.RemoveWhere(r.key, func(value interface{}) bool { return true })
|
||||
t.RemoveWhere(r.key, func(value ItemValue) bool { return true })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -133,7 +133,7 @@ func TestAddHasCountFindIterateRemove(t *testing.T) {
|
|||
t.Error(bpt, "Find Failed Value Error")
|
||||
}
|
||||
}
|
||||
err = bpt.Replace(r.key, func(value interface{}) bool { return true }, new_recs[i].value)
|
||||
err = bpt.Replace(r.key, func(value ItemValue) bool { return true }, new_recs[i].value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
|
@ -193,7 +193,7 @@ func TestAddHasCountFindIterateRemove(t *testing.T) {
|
|||
if count := bpt.Count(r.key); count != 1 {
|
||||
t.Error(bpt, "Missing key")
|
||||
}
|
||||
if err := bpt.RemoveWhere(r.key, func(value interface{}) bool { return true }); err != nil {
|
||||
if err := bpt.RemoveWhere(r.key, func(value ItemValue) bool { return true }); err != nil {
|
||||
t.Fatal(bpt, err)
|
||||
}
|
||||
if has := bpt.Has(r.key); has {
|
||||
|
|
@ -276,15 +276,15 @@ func TestBpMap(t *testing.T) {
|
|||
|
||||
func Test_get_start(t *testing.T) {
|
||||
root := NewLeaf(2, false)
|
||||
root, err := root.put(Int(1), 1)
|
||||
root, err := root.put(Int(1), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
root, err = root.put(Int(5), 3)
|
||||
root, err = root.put(Int(5), Int(3))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 2)
|
||||
root, err = root.put(Int(3), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
|
|
@ -345,31 +345,31 @@ func Test_get_start(t *testing.T) {
|
|||
|
||||
func Test_get_end(t *testing.T) {
|
||||
root := NewLeaf(3, false)
|
||||
root, err := root.put(Int(1), -1)
|
||||
root, err := root.put(Int(1), Int(-1))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(4), -1)
|
||||
root, err = root.put(Int(4), Int(-1))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 1)
|
||||
root, err = root.put(Int(3), Int(1))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 2)
|
||||
root, err = root.put(Int(3), Int(2))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 3)
|
||||
root, err = root.put(Int(3), Int(3))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 4)
|
||||
root, err = root.put(Int(3), Int(4))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root, err = root.put(Int(3), 5)
|
||||
root, err = root.put(Int(3), Int(5))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
|
@ -437,10 +437,10 @@ func Test_get_end(t *testing.T) {
|
|||
|
||||
func Test_put_no_root_split(t *testing.T) {
|
||||
a := NewLeaf(2, false)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, err := a.put(Int(1), 2)
|
||||
p, err := a.put(Int(1), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -451,7 +451,7 @@ func Test_put_no_root_split(t *testing.T) {
|
|||
t.Error("p didn't have the right keys", p)
|
||||
}
|
||||
}
|
||||
p, err = a.put(Int(1), 3)
|
||||
p, err = a.put(Int(1), Int(3))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -471,7 +471,7 @@ func Test_put_no_root_split(t *testing.T) {
|
|||
|
||||
func Test_put_root_split(t *testing.T) {
|
||||
a := NewLeaf(2, false)
|
||||
p, err := a.put(Int(1), 1)
|
||||
p, err := a.put(Int(1), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -482,7 +482,7 @@ func Test_put_root_split(t *testing.T) {
|
|||
t.Error("p didn't have the right keys", p)
|
||||
}
|
||||
}
|
||||
p, err = a.put(Int(3), 3)
|
||||
p, err = a.put(Int(3), Int(3))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -493,7 +493,7 @@ func Test_put_root_split(t *testing.T) {
|
|||
t.Error("p didn't have the right keys", p)
|
||||
}
|
||||
}
|
||||
p, err = a.put(Int(2), 2)
|
||||
p, err = a.put(Int(2), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -521,7 +521,7 @@ func Test_put_root_split(t *testing.T) {
|
|||
func Test_internal_insert_no_split(t *testing.T) {
|
||||
a := NewInternal(3)
|
||||
leaf := NewLeaf(1, false)
|
||||
if err := leaf.put_kv(Int(1), 1); err != nil {
|
||||
if err := leaf.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kp(Int(1), leaf); err != nil {
|
||||
|
|
@ -549,7 +549,7 @@ func Test_internal_insert_no_split(t *testing.T) {
|
|||
func Test_internal_insert_split_less(t *testing.T) {
|
||||
a := NewInternal(3)
|
||||
leaf := NewLeaf(1, false)
|
||||
if err := leaf.put_kv(Int(1), 1); err != nil {
|
||||
if err := leaf.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kp(Int(1), leaf); err != nil {
|
||||
|
|
@ -660,13 +660,13 @@ func Test_internal_split_greater(t *testing.T) {
|
|||
func Test_leaf_insert_no_split(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
insert_linked_list_node(a, nil, nil)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_insert(Int(2), 2)
|
||||
p, q, err := a.leaf_insert(Int(2), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -686,16 +686,16 @@ func Test_leaf_insert_no_split(t *testing.T) {
|
|||
func Test_leaf_insert_split_less(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
insert_linked_list_node(a, nil, nil)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(5), 5); err != nil {
|
||||
if err := a.put_kv(Int(5), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_insert(Int(2), 2)
|
||||
p, q, err := a.leaf_insert(Int(2), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -717,16 +717,16 @@ func Test_leaf_insert_split_less(t *testing.T) {
|
|||
func Test_leaf_split_less(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
insert_linked_list_node(a, nil, nil)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(5), 5); err != nil {
|
||||
if err := a.put_kv(Int(5), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_split(Int(2), 2)
|
||||
p, q, err := a.leaf_split(Int(2), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -748,16 +748,16 @@ func Test_leaf_split_less(t *testing.T) {
|
|||
func Test_leaf_split_equal(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
insert_linked_list_node(a, nil, nil)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(5), 5); err != nil {
|
||||
if err := a.put_kv(Int(5), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_split(Int(3), 2)
|
||||
p, q, err := a.leaf_split(Int(3), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -779,16 +779,16 @@ func Test_leaf_split_equal(t *testing.T) {
|
|||
func Test_leaf_split_greater(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
insert_linked_list_node(a, nil, nil)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(5), 5); err != nil {
|
||||
if err := a.put_kv(Int(5), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_split(Int(4), 2)
|
||||
p, q, err := a.leaf_split(Int(4), Int(2))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -817,28 +817,28 @@ func Test_pure_leaf_insert_split_less(t *testing.T) {
|
|||
insert_linked_list_node(c, b, nil)
|
||||
d := NewLeaf(2, false)
|
||||
insert_linked_list_node(d, c, nil)
|
||||
if err := a.put_kv(Int(3), 1); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 2); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 3); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 4); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 5); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 6); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := d.put_kv(Int(4), 6); err != nil {
|
||||
if err := d.put_kv(Int(4), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.leaf_insert(Int(2), 1)
|
||||
p, q, err := a.leaf_insert(Int(2), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -890,28 +890,28 @@ func Test_pure_leaf_split_less(t *testing.T) {
|
|||
insert_linked_list_node(c, b, nil)
|
||||
d := NewLeaf(2, false)
|
||||
insert_linked_list_node(d, c, nil)
|
||||
if err := a.put_kv(Int(3), 1); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 2); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 3); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 4); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 5); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 6); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := d.put_kv(Int(4), 6); err != nil {
|
||||
if err := d.put_kv(Int(4), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.pure_leaf_split(Int(2), 1)
|
||||
p, q, err := a.pure_leaf_split(Int(2), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -963,25 +963,25 @@ func Test_pure_leaf_split_equal(t *testing.T) {
|
|||
insert_linked_list_node(c, b, nil)
|
||||
d := NewLeaf(2, false)
|
||||
insert_linked_list_node(d, c, nil)
|
||||
if err := a.put_kv(Int(3), 1); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 2); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 3); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 4); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 5); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := d.put_kv(Int(4), 6); err != nil {
|
||||
if err := d.put_kv(Int(4), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.pure_leaf_split(Int(3), 1)
|
||||
p, q, err := a.pure_leaf_split(Int(3), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -1027,25 +1027,25 @@ func Test_pure_leaf_split_greater(t *testing.T) {
|
|||
insert_linked_list_node(c, b, nil)
|
||||
d := NewLeaf(2, false)
|
||||
insert_linked_list_node(d, c, nil)
|
||||
if err := a.put_kv(Int(3), 1); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 2); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 3); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 4); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 5); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := d.put_kv(Int(5), 6); err != nil {
|
||||
if err := d.put_kv(Int(5), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
p, q, err := a.pure_leaf_split(Int(4), 1)
|
||||
p, q, err := a.pure_leaf_split(Int(4), Int(1))
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
} else {
|
||||
|
|
@ -1097,25 +1097,25 @@ func Test_find_end_of_pure_run(t *testing.T) {
|
|||
insert_linked_list_node(c, b, nil)
|
||||
d := NewLeaf(2, false)
|
||||
insert_linked_list_node(d, c, nil)
|
||||
if err := a.put_kv(Int(3), 1); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 2); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 3); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := b.put_kv(Int(3), 4); err != nil {
|
||||
if err := b.put_kv(Int(3), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 5); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := c.put_kv(Int(3), 6); err != nil {
|
||||
if err := c.put_kv(Int(3), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := d.put_kv(Int(4), 6); err != nil {
|
||||
if err := d.put_kv(Int(4), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
e := a.find_end_of_pure_run()
|
||||
|
|
@ -1237,13 +1237,13 @@ func Test_remove_linked_list_node(t *testing.T) {
|
|||
func Test_balance_leaf_nodes_with_dup(t *testing.T) {
|
||||
a := NewLeaf(3, false)
|
||||
b := NewLeaf(3, false)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(2), 1); err != nil {
|
||||
if err := a.put_kv(Int(2), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
balance_nodes(a, b)
|
||||
|
|
@ -1258,25 +1258,25 @@ func Test_balance_leaf_nodes_with_dup(t *testing.T) {
|
|||
func Test_balance_leaf_nodes(t *testing.T) {
|
||||
a := NewLeaf(7, false)
|
||||
b := NewLeaf(7, false)
|
||||
if err := a.put_kv(Int(1), 1); err != nil {
|
||||
if err := a.put_kv(Int(1), Int(1)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(2), 2); err != nil {
|
||||
if err := a.put_kv(Int(2), Int(2)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(3), 3); err != nil {
|
||||
if err := a.put_kv(Int(3), Int(3)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(4), 4); err != nil {
|
||||
if err := a.put_kv(Int(4), Int(4)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(5), 5); err != nil {
|
||||
if err := a.put_kv(Int(5), Int(5)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(6), 6); err != nil {
|
||||
if err := a.put_kv(Int(6), Int(6)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if err := a.put_kv(Int(7), 7); err != nil {
|
||||
if err := a.put_kv(Int(7), Int(7)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
balance_nodes(a, b)
|
||||
|
|
@ -1291,12 +1291,12 @@ func Test_balance_leaf_nodes(t *testing.T) {
|
|||
}
|
||||
}
|
||||
for i, v := range a.values {
|
||||
if v.(int) != i+1 {
|
||||
if int(v.(Int)) != i+1 {
|
||||
t.Errorf("k != %d", i+1)
|
||||
}
|
||||
}
|
||||
for i, v := range b.values {
|
||||
if v.(int) != 3+i+1 {
|
||||
if int(v.(Int)) != 3+i+1 {
|
||||
t.Errorf("v != %d", 3+i+1)
|
||||
}
|
||||
}
|
||||
|
|
@ -1413,10 +1413,14 @@ func read(p []byte, int63 func() int64, readVal *int64, readPos *int8) (n int, e
|
|||
|
||||
type T testing.T
|
||||
|
||||
func (t *T) Assert(ok bool, msg string, vars ...interface{}) {
|
||||
func (t *T) Assert(ok bool, msg string, vars ...ItemValue) {
|
||||
if !ok {
|
||||
t.Log("\n" + string(debug.Stack()))
|
||||
t.Fatalf(msg, vars...)
|
||||
var objects []interface{}
|
||||
for _, t := range vars {
|
||||
objects = append(objects, t)
|
||||
}
|
||||
t.Fatalf(msg, objects...)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,26 +25,26 @@ func NegativeSize() error {
|
|||
return errors.New("negative size")
|
||||
}
|
||||
|
||||
type Iterator func() (item interface{}, next Iterator)
|
||||
type Iterator func() (item ItemValue, next Iterator)
|
||||
type KIterator func() (key Hashable, next KIterator)
|
||||
type KVIterator func() (key Hashable, value interface{}, next KVIterator)
|
||||
type KVIterator func() (key Hashable, value ItemValue, next KVIterator)
|
||||
type KVIterable interface {
|
||||
Iterate() KVIterator
|
||||
}
|
||||
|
||||
type MapOperable interface {
|
||||
Has(key Hashable) bool
|
||||
Put(key Hashable, value interface{}) (err error)
|
||||
Get(key Hashable) (value interface{}, err error)
|
||||
Remove(key Hashable) (value interface{}, err error)
|
||||
Put(key Hashable, value ItemValue) (err error)
|
||||
Get(key Hashable) (value ItemValue, err error)
|
||||
Remove(key Hashable) (value ItemValue, err error)
|
||||
}
|
||||
|
||||
type WhereFunc func(value interface{}) bool
|
||||
type WhereFunc func(value ItemValue) bool
|
||||
|
||||
func MakeValuesIterator(obj KVIterable) Iterator {
|
||||
kv_iterator := obj.Iterate()
|
||||
var v_iterator Iterator
|
||||
v_iterator = func() (value interface{}, next Iterator) {
|
||||
v_iterator = func() (value ItemValue, next Iterator) {
|
||||
_, value, kv_iterator = kv_iterator()
|
||||
if kv_iterator == nil {
|
||||
return nil, nil
|
||||
|
|
@ -58,7 +58,7 @@ func MakeItemsIterator(obj KVIterable) (kit KIterator) {
|
|||
kv_iterator := obj.Iterate()
|
||||
kit = func() (item Hashable, next KIterator) {
|
||||
var key Hashable
|
||||
var value interface{}
|
||||
var value ItemValue
|
||||
key, value, kv_iterator = kv_iterator()
|
||||
if kv_iterator == nil {
|
||||
return nil, nil
|
||||
|
|
@ -70,7 +70,7 @@ func MakeItemsIterator(obj KVIterable) (kit KIterator) {
|
|||
|
||||
type MapEntry struct {
|
||||
Key Hashable
|
||||
Value interface{}
|
||||
Value ItemValue
|
||||
}
|
||||
|
||||
func (m *MapEntry) Equals(other Equatable) bool {
|
||||
|
|
|
|||
Loading…
Reference in a new issue