2015-07-07 03:54:22 +03:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 19:48:40 +03:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-07 03:54:22 +03:00
|
|
|
//
|
2015-07-23 19:35:11 +03:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-07 03:54:22 +03:00
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2015-07-22 19:48:40 +03:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-07 03:54:22 +03:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 19:48:40 +03:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-07 03:54:22 +03:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 19:48:40 +03:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-07 03:54:22 +03:00
|
|
|
|
2014-10-31 15:45:03 +02:00
|
|
|
package trie
|
2014-10-10 17:56:28 +03:00
|
|
|
|
2016-09-25 21:49:02 +03:00
|
|
|
import "github.com/ethereum/go-ethereum/common"
|
2015-11-25 19:28:21 +02:00
|
|
|
|
2016-09-25 21:49:02 +03:00
|
|
|
// Iterator is a key-value trie iterator that traverses a Trie.
|
2014-10-10 17:56:28 +03:00
|
|
|
type Iterator struct {
|
2016-09-25 21:49:02 +03:00
|
|
|
trie *Trie
|
|
|
|
nodeIt *NodeIterator
|
|
|
|
keyBuf []byte
|
2014-10-10 17:56:28 +03:00
|
|
|
|
2015-12-28 15:20:37 +02:00
|
|
|
Key []byte // Current data key on which the iterator is positioned on
|
|
|
|
Value []byte // Current data value on which the iterator is positioned on
|
2014-10-10 17:56:28 +03:00
|
|
|
}
|
|
|
|
|
2015-12-28 15:20:37 +02:00
|
|
|
// NewIterator creates a new key-value iterator.
|
2014-10-10 17:56:28 +03:00
|
|
|
func NewIterator(trie *Trie) *Iterator {
|
2016-09-25 21:49:02 +03:00
|
|
|
return &Iterator{
|
|
|
|
trie: trie,
|
|
|
|
nodeIt: NewNodeIterator(trie),
|
|
|
|
keyBuf: make([]byte, 0, 64),
|
|
|
|
Key: nil,
|
2015-03-05 03:42:32 +02:00
|
|
|
}
|
2014-10-10 17:56:28 +03:00
|
|
|
}
|
|
|
|
|
2016-09-25 21:49:02 +03:00
|
|
|
// Next moves the iterator forward one key-value entry.
|
|
|
|
func (it *Iterator) Next() bool {
|
|
|
|
for it.nodeIt.Next() {
|
|
|
|
if it.nodeIt.Leaf {
|
|
|
|
it.Key = it.makeKey()
|
|
|
|
it.Value = it.nodeIt.LeafBlob
|
|
|
|
return true
|
2014-10-10 17:56:28 +03:00
|
|
|
}
|
2015-07-06 02:19:48 +03:00
|
|
|
}
|
2016-09-25 21:49:02 +03:00
|
|
|
it.Key = nil
|
|
|
|
it.Value = nil
|
|
|
|
return false
|
2014-10-10 17:56:28 +03:00
|
|
|
}
|
|
|
|
|
2016-09-25 21:49:02 +03:00
|
|
|
func (it *Iterator) makeKey() []byte {
|
|
|
|
key := it.keyBuf[:0]
|
|
|
|
for _, se := range it.nodeIt.stack {
|
|
|
|
switch node := se.node.(type) {
|
2016-10-14 19:04:33 +03:00
|
|
|
case *fullNode:
|
2016-09-25 21:49:02 +03:00
|
|
|
if se.child <= 16 {
|
|
|
|
key = append(key, byte(se.child))
|
|
|
|
}
|
2016-10-14 19:04:33 +03:00
|
|
|
case *shortNode:
|
2016-09-25 21:49:02 +03:00
|
|
|
if hasTerm(node.Key) {
|
|
|
|
key = append(key, node.Key[:len(node.Key)-1]...)
|
|
|
|
} else {
|
|
|
|
key = append(key, node.Key...)
|
2015-01-08 12:47:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-09-25 21:49:02 +03:00
|
|
|
return decodeCompact(key)
|
2014-10-10 17:56:28 +03:00
|
|
|
}
|
2015-12-28 15:20:37 +02:00
|
|
|
|
|
|
|
// nodeIteratorState represents the iteration state at one particular node of the
|
|
|
|
// trie, which can be resumed at a later invocation.
|
|
|
|
type nodeIteratorState struct {
|
2016-01-08 13:46:45 +02:00
|
|
|
hash common.Hash // Hash of the node being iterated (nil if not standalone)
|
|
|
|
node node // Trie node being iterated
|
|
|
|
parent common.Hash // Hash of the first full ancestor node (nil if current is the root)
|
|
|
|
child int // Child to be processed next
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// NodeIterator is an iterator to traverse the trie post-order.
|
|
|
|
type NodeIterator struct {
|
|
|
|
trie *Trie // Trie being iterated
|
|
|
|
stack []*nodeIteratorState // Hierarchy of trie nodes persisting the iteration state
|
|
|
|
|
2016-01-06 12:11:56 +02:00
|
|
|
Hash common.Hash // Hash of the current node being iterated (nil if not standalone)
|
|
|
|
Node node // Current node being iterated (internal representation)
|
2016-01-08 13:46:45 +02:00
|
|
|
Parent common.Hash // Hash of the first full ancestor node (nil if current is the root)
|
2016-01-06 12:11:56 +02:00
|
|
|
Leaf bool // Flag whether the current node is a value (data) node
|
|
|
|
LeafBlob []byte // Data blob contained within a leaf (otherwise nil)
|
2016-02-16 12:37:00 +02:00
|
|
|
|
|
|
|
Error error // Failure set in case of an internal error in the iterator
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewNodeIterator creates an post-order trie iterator.
|
|
|
|
func NewNodeIterator(trie *Trie) *NodeIterator {
|
2016-05-19 13:24:14 +03:00
|
|
|
if trie.Hash() == emptyState {
|
2015-12-28 15:20:37 +02:00
|
|
|
return new(NodeIterator)
|
|
|
|
}
|
|
|
|
return &NodeIterator{trie: trie}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next moves the iterator to the next node, returning whether there are any
|
2016-02-16 12:37:00 +02:00
|
|
|
// further nodes. In case of an internal error this method returns false and
|
|
|
|
// sets the Error field to the encountered failure.
|
2015-12-28 15:20:37 +02:00
|
|
|
func (it *NodeIterator) Next() bool {
|
2016-02-16 12:37:00 +02:00
|
|
|
// If the iterator failed previously, don't do anything
|
|
|
|
if it.Error != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
// Otherwise step forward with the iterator and report any errors
|
|
|
|
if err := it.step(); err != nil {
|
|
|
|
it.Error = err
|
|
|
|
return false
|
|
|
|
}
|
2015-12-28 15:20:37 +02:00
|
|
|
return it.retrieve()
|
|
|
|
}
|
|
|
|
|
|
|
|
// step moves the iterator to the next node of the trie.
|
2016-02-16 12:37:00 +02:00
|
|
|
func (it *NodeIterator) step() error {
|
2015-12-28 15:20:37 +02:00
|
|
|
if it.trie == nil {
|
2016-09-25 21:49:02 +03:00
|
|
|
// Abort if we reached the end of the iteration
|
2016-02-16 12:37:00 +02:00
|
|
|
return nil
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
|
|
|
if len(it.stack) == 0 {
|
2016-09-25 21:49:02 +03:00
|
|
|
// Initialize the iterator if we've just started.
|
2016-05-19 13:24:14 +03:00
|
|
|
root := it.trie.Hash()
|
2016-09-25 21:49:02 +03:00
|
|
|
state := &nodeIteratorState{node: it.trie.root, child: -1}
|
|
|
|
if root != emptyRoot {
|
|
|
|
state.hash = root
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
2016-09-25 21:49:02 +03:00
|
|
|
it.stack = append(it.stack, state)
|
2015-12-28 15:20:37 +02:00
|
|
|
} else {
|
2016-09-25 21:49:02 +03:00
|
|
|
// Continue iterating at the previous node otherwise.
|
2015-12-28 15:20:37 +02:00
|
|
|
it.stack = it.stack[:len(it.stack)-1]
|
|
|
|
if len(it.stack) == 0 {
|
|
|
|
it.trie = nil
|
2016-02-16 12:37:00 +02:00
|
|
|
return nil
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
|
|
|
}
|
2016-09-25 21:49:02 +03:00
|
|
|
|
2015-12-28 15:20:37 +02:00
|
|
|
// Continue iteration to the next child
|
|
|
|
for {
|
|
|
|
parent := it.stack[len(it.stack)-1]
|
2016-01-08 13:46:45 +02:00
|
|
|
ancestor := parent.hash
|
|
|
|
if (ancestor == common.Hash{}) {
|
|
|
|
ancestor = parent.parent
|
|
|
|
}
|
2016-10-14 19:04:33 +03:00
|
|
|
if node, ok := parent.node.(*fullNode); ok {
|
2015-12-28 15:20:37 +02:00
|
|
|
// Full node, traverse all children, then the node itself
|
2016-05-19 13:24:14 +03:00
|
|
|
if parent.child >= len(node.Children) {
|
2015-12-28 15:20:37 +02:00
|
|
|
break
|
|
|
|
}
|
2016-05-19 13:24:14 +03:00
|
|
|
for parent.child++; parent.child < len(node.Children); parent.child++ {
|
|
|
|
if current := node.Children[parent.child]; current != nil {
|
2016-09-25 21:49:02 +03:00
|
|
|
it.stack = append(it.stack, &nodeIteratorState{
|
2016-10-14 19:04:33 +03:00
|
|
|
hash: common.BytesToHash(node.flags.hash),
|
2016-09-25 21:49:02 +03:00
|
|
|
node: current,
|
|
|
|
parent: ancestor,
|
|
|
|
child: -1,
|
|
|
|
})
|
2015-12-28 15:20:37 +02:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2016-10-14 19:04:33 +03:00
|
|
|
} else if node, ok := parent.node.(*shortNode); ok {
|
2015-12-28 15:20:37 +02:00
|
|
|
// Short node, traverse the pointer singleton child, then the node itself
|
|
|
|
if parent.child >= 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
parent.child++
|
2016-09-25 21:49:02 +03:00
|
|
|
it.stack = append(it.stack, &nodeIteratorState{
|
2016-10-14 19:04:33 +03:00
|
|
|
hash: common.BytesToHash(node.flags.hash),
|
2016-09-25 21:49:02 +03:00
|
|
|
node: node.Val,
|
|
|
|
parent: ancestor,
|
|
|
|
child: -1,
|
|
|
|
})
|
2016-01-06 12:11:56 +02:00
|
|
|
} else if hash, ok := parent.node.(hashNode); ok {
|
2015-12-28 15:20:37 +02:00
|
|
|
// Hash node, resolve the hash child from the database, then the node itself
|
|
|
|
if parent.child >= 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
parent.child++
|
|
|
|
|
2016-01-06 12:11:56 +02:00
|
|
|
node, err := it.trie.resolveHash(hash, nil, nil)
|
2015-12-28 15:20:37 +02:00
|
|
|
if err != nil {
|
2016-02-16 12:37:00 +02:00
|
|
|
return err
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
2016-09-25 21:49:02 +03:00
|
|
|
it.stack = append(it.stack, &nodeIteratorState{
|
|
|
|
hash: common.BytesToHash(hash),
|
|
|
|
node: node,
|
|
|
|
parent: ancestor,
|
|
|
|
child: -1,
|
|
|
|
})
|
2015-12-28 15:20:37 +02:00
|
|
|
} else {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2016-02-16 12:37:00 +02:00
|
|
|
return nil
|
2015-12-28 15:20:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// retrieve pulls and caches the current trie node the iterator is traversing.
|
|
|
|
// In case of a value node, the additional leaf blob is also populated with the
|
|
|
|
// data contents for external interpretation.
|
|
|
|
//
|
|
|
|
// The method returns whether there are any more data left for inspection.
|
|
|
|
func (it *NodeIterator) retrieve() bool {
|
|
|
|
// Clear out any previously set values
|
2016-01-08 13:46:45 +02:00
|
|
|
it.Hash, it.Node, it.Parent, it.Leaf, it.LeafBlob = common.Hash{}, nil, common.Hash{}, false, nil
|
2015-12-28 15:20:37 +02:00
|
|
|
|
|
|
|
// If the iteration's done, return no available data
|
|
|
|
if it.trie == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
// Otherwise retrieve the current node and resolve leaf accessors
|
2016-01-06 12:11:56 +02:00
|
|
|
state := it.stack[len(it.stack)-1]
|
|
|
|
|
2016-01-08 13:46:45 +02:00
|
|
|
it.Hash, it.Node, it.Parent = state.hash, state.node, state.parent
|
2015-12-28 15:20:37 +02:00
|
|
|
if value, ok := it.Node.(valueNode); ok {
|
|
|
|
it.Leaf, it.LeafBlob = true, []byte(value)
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|