forked from TrueCloudLab/neoneo-go
128 lines
3.6 KiB
Go
128 lines
3.6 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/interop"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/storage"
|
|
"github.com/nspcc-dev/neo-go/pkg/util/slice"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
)
|
|
|
|
// Storage iterator options.
|
|
const (
|
|
FindDefault = 0
|
|
FindKeysOnly = 1 << 0
|
|
FindRemovePrefix = 1 << 1
|
|
FindValuesOnly = 1 << 2
|
|
FindDeserialize = 1 << 3
|
|
FindPick0 = 1 << 4
|
|
FindPick1 = 1 << 5
|
|
|
|
FindAll = FindDefault | FindKeysOnly | FindRemovePrefix | FindValuesOnly |
|
|
FindDeserialize | FindPick0 | FindPick1
|
|
)
|
|
|
|
// Iterator is an iterator state representation.
|
|
type Iterator struct {
|
|
seekCh chan storage.KeyValue
|
|
curr storage.KeyValue
|
|
next bool
|
|
opts int64
|
|
prefix []byte
|
|
}
|
|
|
|
// NewIterator creates a new Iterator with the given options for the given channel of store.Seek results.
|
|
func NewIterator(seekCh chan storage.KeyValue, prefix []byte, opts int64) *Iterator {
|
|
return &Iterator{
|
|
seekCh: seekCh,
|
|
opts: opts,
|
|
prefix: slice.Copy(prefix),
|
|
}
|
|
}
|
|
|
|
// Next advances the iterator and returns true if Value can be called at the
|
|
// current position.
|
|
func (s *Iterator) Next() bool {
|
|
s.curr, s.next = <-s.seekCh
|
|
return s.next
|
|
}
|
|
|
|
// Value returns current iterators value (exact type depends on options this
|
|
// iterator was created with).
|
|
func (s *Iterator) Value() stackitem.Item {
|
|
if !s.next {
|
|
panic("iterator index out of range")
|
|
}
|
|
key := s.curr.Key
|
|
if s.opts&FindRemovePrefix == 0 {
|
|
key = append(s.prefix, key...)
|
|
}
|
|
if s.opts&FindKeysOnly != 0 {
|
|
return stackitem.NewByteArray(key)
|
|
}
|
|
value := stackitem.Item(stackitem.NewByteArray(s.curr.Value))
|
|
if s.opts&FindDeserialize != 0 {
|
|
bs := s.curr.Value
|
|
var err error
|
|
value, err = stackitem.Deserialize(bs)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
if s.opts&FindPick0 != 0 {
|
|
value = value.Value().([]stackitem.Item)[0]
|
|
} else if s.opts&FindPick1 != 0 {
|
|
value = value.Value().([]stackitem.Item)[1]
|
|
}
|
|
if s.opts&FindValuesOnly != 0 {
|
|
return value
|
|
}
|
|
return stackitem.NewStruct([]stackitem.Item{
|
|
stackitem.NewByteArray(key),
|
|
value,
|
|
})
|
|
}
|
|
|
|
// Find finds stored key-value pair.
|
|
func Find(ic *interop.Context) error {
|
|
stcInterface := ic.VM.Estack().Pop().Value()
|
|
stc, ok := stcInterface.(*Context)
|
|
if !ok {
|
|
return fmt.Errorf("%T is not a storage,Context", stcInterface)
|
|
}
|
|
prefix := ic.VM.Estack().Pop().Bytes()
|
|
opts := ic.VM.Estack().Pop().BigInt().Int64()
|
|
if opts&^FindAll != 0 {
|
|
return fmt.Errorf("%w: unknown flag", errFindInvalidOptions)
|
|
}
|
|
if opts&FindKeysOnly != 0 &&
|
|
opts&(FindDeserialize|FindPick0|FindPick1) != 0 {
|
|
return fmt.Errorf("%w KeysOnly conflicts with other options", errFindInvalidOptions)
|
|
}
|
|
if opts&FindValuesOnly != 0 &&
|
|
opts&(FindKeysOnly|FindRemovePrefix) != 0 {
|
|
return fmt.Errorf("%w: KeysOnly conflicts with ValuesOnly", errFindInvalidOptions)
|
|
}
|
|
if opts&FindPick0 != 0 && opts&FindPick1 != 0 {
|
|
return fmt.Errorf("%w: Pick0 conflicts with Pick1", errFindInvalidOptions)
|
|
}
|
|
if opts&FindDeserialize == 0 && (opts&FindPick0 != 0 || opts&FindPick1 != 0) {
|
|
return fmt.Errorf("%w: PickN is specified without Deserialize", errFindInvalidOptions)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
seekres := ic.DAO.SeekAsync(ctx, stc.ID, storage.SeekRange{Prefix: prefix})
|
|
item := NewIterator(seekres, prefix, opts)
|
|
ic.VM.Estack().PushItem(stackitem.NewInterop(item))
|
|
ic.RegisterCancelFunc(func() {
|
|
cancel()
|
|
// Underlying persistent store is likely to be a private MemCachedStore. Thus,
|
|
// to avoid concurrent map iteration and map write we need to wait until internal
|
|
// seek goroutine is finished, because it can access underlying persistent store.
|
|
for range seekres {
|
|
}
|
|
})
|
|
|
|
return nil
|
|
}
|