func (self *TST) Get(key []byte) (value interface{}, err error) {
type entry struct {
n *TSTNode
d int
}
if err := self.ValidateKey(key); err != nil {
return nil, err
}
symbol := append(key, END)
next := &entry{self.heads[symbol[0]], 1}
for next != nil {
if next.n == nil {
return nil, errors.NotFound(key)
} else if next.n.Internal() {
ch := symbol[next.d]
if ch < next.n.ch {
next = &entry{next.n.l, next.d}
} else if ch == next.n.ch {
next = &entry{next.n.m, next.d + 1}
} else if ch > next.n.ch {
next = &entry{next.n.r, next.d}
}
} else if next.n.KeyEq(symbol) {
return next.n.value, nil
} else {
return nil, errors.NotFound(key)
}
}
// should never reach ...
return nil, errors.NotFound(key)
}
func (self *TST) Remove(key []byte) (value interface{}, err error) {
if err := self.ValidateKey(key); err != nil {
return nil, err
}
symbol := ByteSlice(append(key, END))
check := func(n *TSTNode, err error) (*TSTNode, error) {
if err != nil {
return nil, err
} else if n == nil {
return nil, nil
} else if !n.Internal() && n.key == nil {
return nil, nil
}
return n, nil
}
var remove func(n *TSTNode, d int) (*TSTNode, error)
remove = func(n *TSTNode, d int) (*TSTNode, error) {
if n == nil {
return nil, errors.NotFound(key)
} else if n.Internal() {
n = n.Copy()
ch := symbol[d]
if ch < n.ch {
l, err := check(remove(n.l, d))
if err != nil {
return nil, err
}
n.l = l
} else if ch == n.ch {
m, err := check(remove(n.m, d+1))
if err != nil {
return nil, err
}
n.m = m
} else if ch > n.ch {
r, err := check(remove(n.r, d))
if err != nil {
return nil, err
}
n.r = r
}
} else if n.key.Equals(symbol) {
// found it
value = n.value
return nil, nil
} else {
return nil, errors.NotFound(key)
}
return n, nil
}
n, err := remove(self.heads[symbol[0]], 1)
if err != nil {
return nil, err
}
self.heads[symbol[0]] = n
return value, nil
}
func (self *AvlNode) Remove(key types.Hashable) (_ *AvlNode, value interface{}, err error) {
if self == nil {
return nil, nil, errors.NotFound(key)
}
if self.key.Equals(key) {
if self.left != nil && self.right != nil {
if self.left.Size() < self.right.Size() {
lmd := self.right.lmd()
lmd.left = self.left
return self.right, self.value, nil
} else {
rmd := self.left.rmd()
rmd.right = self.right
return self.left, self.value, nil
}
} else if self.left == nil {
return self.right, self.value, nil
} else if self.right == nil {
return self.left, self.value, nil
} else {
return nil, self.value, nil
}
}
if key.Less(self.key) {
self.left, value, err = self.left.Remove(key)
} else {
self.right, value, err = self.right.Remove(key)
}
if err != nil {
return self.balance(), value, err
}
return self, value, err
}
func (self *BpMap) Get(key types.Hashable) (value interface{}, err error) {
j, l := self.root.get_start(key)
if l.keys[j].Equals(key) {
return l.values[j], nil
}
return nil, errors.NotFound(key)
}
func (self *AvlNode) Get(key types.Hashable) (value interface{}, err error) {
if self == nil {
return nil, errors.NotFound(key)
}
if self.key.Equals(key) {
return self.value, nil
} else if key.Less(self.key) {
return self.left.Get(key)
} else {
return self.right.Get(key)
}
}
func (self *ImmutableAvlNode) Remove(key types.Hashable) (_ *ImmutableAvlNode, value interface{}, err error) {
if self == nil {
return nil, nil, errors.NotFound(key)
}
if self.key.Equals(key) {
if self.left != nil && self.right != nil {
var new_root *ImmutableAvlNode
if self.left.Size() < self.right.Size() {
self, new_root = self.pop_node(self.right.lmd())
} else {
self, new_root = self.pop_node(self.left.rmd())
}
new_root.left = self.left
new_root.right = self.right
return new_root, self.value, nil
} else if self.left == nil {
return self.right, self.value, nil
} else if self.right == nil {
return self.left, self.value, nil
} else {
return nil, self.value, nil
}
}
self = self.Copy()
if key.Less(self.key) {
self.left, value, err = self.left.Remove(key)
} else {
self.right, value, err = self.right.Remove(key)
}
self.height = max(self.left.Height(), self.right.Height()) + 1
if err != nil {
return self.balance(), value, err
}
return self, value, err
}
