This repository has been archived by the owner on May 13, 2022. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 346
/
tree.go
100 lines (85 loc) · 2.71 KB
/
tree.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package storage
import (
"fmt"
"github.com/cosmos/iavl"
dbm "github.com/tendermint/tm-db"
)
// We wrap IAVL's tree types in order to implement standard DB interface and iteration helpers
type MutableTree struct {
*iavl.MutableTree
}
type ImmutableTree struct {
*iavl.ImmutableTree
}
func NewMutableTree(db dbm.DB, cacheSize int) (*MutableTree, error) {
tree, err := iavl.NewMutableTree(db, cacheSize)
return &MutableTree{
MutableTree: tree,
}, err
}
func (mut *MutableTree) Load(version int64, overwriting bool) error {
if version <= 0 {
return fmt.Errorf("trying to load MutableTree from non-positive version: version %d", version)
}
var err error
var treeVersion int64
if overwriting {
// Deletes all version above version!
treeVersion, err = mut.MutableTree.LoadVersionForOverwriting(version)
} else {
treeVersion, err = mut.MutableTree.LoadVersion(version)
}
if err != nil {
return fmt.Errorf("could not load current version of MutableTree (version %d): %v", version, err)
}
if treeVersion != version {
return fmt.Errorf("tried to load version %d of MutableTree, but got version %d", version, treeVersion)
}
return nil
}
func (mut *MutableTree) Iterate(start, end []byte, ascending bool, fn func(key []byte, value []byte) error) error {
return mut.asImmutable().Iterate(start, end, ascending, fn)
}
func (mut *MutableTree) IterateWriteTree(start, end []byte, ascending bool, fn func(key []byte, value []byte) error) error {
var err error
mut.MutableTree.IterateRange(start, end, ascending, func(key, value []byte) (stop bool) {
err = fn(key, value)
return err != nil
})
return err
}
func (mut *MutableTree) Has(key []byte) (bool, error) {
ok := mut.MutableTree.Has(key)
return ok, nil
}
func (mut *MutableTree) Get(key []byte) ([]byte, error) {
_, bs := mut.MutableTree.Get(key)
return bs, nil
}
func (mut *MutableTree) GetImmutable(version int64) (*ImmutableTree, error) {
tree, err := mut.MutableTree.GetImmutable(version)
if err != nil {
return nil, err
}
return &ImmutableTree{tree}, nil
}
func (imt *ImmutableTree) Has(key []byte) (bool, error) {
ok := imt.ImmutableTree.Has(key)
return ok, nil
}
func (imt *ImmutableTree) Get(key []byte) ([]byte, error) {
_, value := imt.ImmutableTree.Get(key)
return value, nil
}
func (imt *ImmutableTree) Iterate(start, end []byte, ascending bool, fn func(key []byte, value []byte) error) error {
var err error
imt.ImmutableTree.IterateRange(start, end, ascending, func(key, value []byte) bool {
err = fn(key, value)
return err != nil
})
return err
}
// Get the current working tree as an ImmutableTree (for the methods - not immutable!)
func (mut *MutableTree) asImmutable() *ImmutableTree {
return &ImmutableTree{mut.MutableTree.ImmutableTree}
}