Merge PR #1254: Add prefixstore and lib refactor
* Merge pull request #1254: add prefixstore and lib refactor add prefixstore refactor lib fix test fix linter in progress in progress add test for prefixstore add KVStoreGetter, PrefixStoreGetter move PrefixStoreGetter to types/ add tests KVStore.Prefix(string) -> KVStore.Prefix([]byte) fix mock apply requests pass lint, add test apply requests * Remove unnecessarily 'valid' boolean
This commit is contained in:
Joon
Christopher Goes
@@ -0,0 +1,250 @@
|
||||
package lib
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
)
|
||||
|
||||
// Linear defines a primitive mapper type
|
||||
type Linear struct {
|
||||
cdc *wire.Codec
|
||||
store sdk.KVStore
|
||||
keys *LinearKeys
|
||||
}
|
||||
|
||||
// LinearKeys defines keysions for the key bytes
|
||||
type LinearKeys struct {
|
||||
LengthKey []byte
|
||||
ElemKey []byte
|
||||
TopKey []byte
|
||||
}
|
||||
|
||||
// Should never be modified
|
||||
var cachedDefaultLinearKeys = DefaultLinearKeys()
|
||||
|
||||
// DefaultLinearKeys returns the default setting of LinearOption
|
||||
func DefaultLinearKeys() *LinearKeys {
|
||||
keys := LinearKeys{
|
||||
LengthKey: []byte{0x00},
|
||||
ElemKey: []byte{0x01},
|
||||
TopKey: []byte{0x02},
|
||||
}
|
||||
return &keys
|
||||
}
|
||||
|
||||
// NewLinear constructs new Linear
|
||||
func NewLinear(cdc *wire.Codec, store sdk.KVStore, keys *LinearKeys) Linear {
|
||||
if keys == nil {
|
||||
keys = cachedDefaultLinearKeys
|
||||
}
|
||||
if keys.LengthKey == nil || keys.ElemKey == nil || keys.TopKey == nil {
|
||||
panic("Invalid LinearKeys")
|
||||
}
|
||||
return Linear{
|
||||
cdc: cdc,
|
||||
store: store,
|
||||
keys: keys,
|
||||
}
|
||||
}
|
||||
|
||||
// List is a Linear interface that provides list-like functions
|
||||
// It panics when the element type cannot be (un/)marshalled by the codec
|
||||
type List interface {
|
||||
|
||||
// Len() returns the length of the list
|
||||
// The length is only increased by Push() and not decreased
|
||||
// List dosen't check if an index is in bounds
|
||||
// The user should check Len() before doing any actions
|
||||
Len() uint64
|
||||
|
||||
// Get() returns the element by its index
|
||||
Get(uint64, interface{}) error
|
||||
|
||||
// Set() stores the element to the given position
|
||||
// Setting element out of range will break length counting
|
||||
// Use Push() instead of Set() to append a new element
|
||||
Set(uint64, interface{})
|
||||
|
||||
// Delete() deletes the element in the given position
|
||||
// Other elements' indices are preserved after deletion
|
||||
// Panics when the index is out of range
|
||||
Delete(uint64)
|
||||
|
||||
// Push() inserts the element to the end of the list
|
||||
// It will increase the length when it is called
|
||||
Push(interface{})
|
||||
|
||||
// Iterate*() is used to iterate over all existing elements in the list
|
||||
// Return true in the continuation to break
|
||||
// The second element of the continuation will indicate the position of the element
|
||||
// Using it with Get() will return the same one with the provided element
|
||||
|
||||
// CONTRACT: No writes may happen within a domain while iterating over it.
|
||||
Iterate(interface{}, func(uint64) bool)
|
||||
}
|
||||
|
||||
// NewList constructs new List
|
||||
func NewList(cdc *wire.Codec, store sdk.KVStore, keys *LinearKeys) List {
|
||||
return NewLinear(cdc, store, keys)
|
||||
}
|
||||
|
||||
// Key for the length of the list
|
||||
func (m Linear) LengthKey() []byte {
|
||||
return m.keys.LengthKey
|
||||
}
|
||||
|
||||
// Key for the elements of the list
|
||||
func (m Linear) ElemKey(index uint64) []byte {
|
||||
return append(m.keys.ElemKey, []byte(fmt.Sprintf("%020d", index))...)
|
||||
}
|
||||
|
||||
// Len implements List
|
||||
func (m Linear) Len() (res uint64) {
|
||||
bz := m.store.Get(m.LengthKey())
|
||||
if bz == nil {
|
||||
return 0
|
||||
}
|
||||
m.cdc.MustUnmarshalBinary(bz, &res)
|
||||
return
|
||||
}
|
||||
|
||||
// Get implements List
|
||||
func (m Linear) Get(index uint64, ptr interface{}) error {
|
||||
bz := m.store.Get(m.ElemKey(index))
|
||||
return m.cdc.UnmarshalBinary(bz, ptr)
|
||||
}
|
||||
|
||||
// Set implements List
|
||||
func (m Linear) Set(index uint64, value interface{}) {
|
||||
bz := m.cdc.MustMarshalBinary(value)
|
||||
m.store.Set(m.ElemKey(index), bz)
|
||||
}
|
||||
|
||||
// Delete implements List
|
||||
func (m Linear) Delete(index uint64) {
|
||||
m.store.Delete(m.ElemKey(index))
|
||||
}
|
||||
|
||||
// Push implements List
|
||||
func (m Linear) Push(value interface{}) {
|
||||
length := m.Len()
|
||||
m.Set(length, value)
|
||||
m.store.Set(m.LengthKey(), m.cdc.MustMarshalBinary(length+1))
|
||||
}
|
||||
|
||||
// IterateRead implements List
|
||||
func (m Linear) Iterate(ptr interface{}, fn func(uint64) bool) {
|
||||
iter := sdk.KVStorePrefixIterator(m.store, []byte{0x01})
|
||||
for ; iter.Valid(); iter.Next() {
|
||||
v := iter.Value()
|
||||
m.cdc.MustUnmarshalBinary(v, ptr)
|
||||
k := iter.Key()
|
||||
s := string(k[len(k)-20:])
|
||||
index, err := strconv.ParseUint(s, 10, 64)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if fn(index) {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
// Queue is a Linear interface that provides queue-like functions
|
||||
// It panics when the element type cannot be (un/)marshalled by the codec
|
||||
type Queue interface {
|
||||
// Push() inserts the elements to the rear of the queue
|
||||
Push(interface{})
|
||||
|
||||
// Popping/Peeking on an empty queue will cause panic
|
||||
// The user should check IsEmpty() before doing any actions
|
||||
|
||||
// Peek() returns the element at the front of the queue without removing it
|
||||
Peek(interface{}) error
|
||||
|
||||
// Pop() returns the element at the front of the queue and removes it
|
||||
Pop()
|
||||
|
||||
// IsEmpty() checks if the queue is empty
|
||||
IsEmpty() bool
|
||||
|
||||
// Flush() removes elements it processed
|
||||
// Return true in the continuation to break
|
||||
// The interface{} is unmarshalled before the continuation is called
|
||||
// Starts from the top(head) of the queue
|
||||
// CONTRACT: Pop() or Push() should not be performed while flushing
|
||||
Flush(interface{}, func() bool)
|
||||
}
|
||||
|
||||
// NewQueue constructs new Queue
|
||||
func NewQueue(cdc *wire.Codec, store sdk.KVStore, keys *LinearKeys) Queue {
|
||||
return NewLinear(cdc, store, keys)
|
||||
}
|
||||
|
||||
// Key for the top element position in the queue
|
||||
func (m Linear) TopKey() []byte {
|
||||
return m.keys.TopKey
|
||||
}
|
||||
|
||||
func (m Linear) getTop() (res uint64) {
|
||||
bz := m.store.Get(m.TopKey())
|
||||
if bz == nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
m.cdc.MustUnmarshalBinary(bz, &res)
|
||||
return
|
||||
}
|
||||
|
||||
func (m Linear) setTop(top uint64) {
|
||||
bz := m.cdc.MustMarshalBinary(top)
|
||||
m.store.Set(m.TopKey(), bz)
|
||||
}
|
||||
|
||||
// Peek implements Queue
|
||||
func (m Linear) Peek(ptr interface{}) error {
|
||||
top := m.getTop()
|
||||
return m.Get(top, ptr)
|
||||
}
|
||||
|
||||
// Pop implements Queue
|
||||
func (m Linear) Pop() {
|
||||
top := m.getTop()
|
||||
m.Delete(top)
|
||||
m.setTop(top + 1)
|
||||
}
|
||||
|
||||
// IsEmpty implements Queue
|
||||
func (m Linear) IsEmpty() bool {
|
||||
top := m.getTop()
|
||||
length := m.Len()
|
||||
return top >= length
|
||||
}
|
||||
|
||||
// Flush implements Queue
|
||||
func (m Linear) Flush(ptr interface{}, fn func() bool) {
|
||||
top := m.getTop()
|
||||
length := m.Len()
|
||||
|
||||
var i uint64
|
||||
for i = top; i < length; i++ {
|
||||
m.Get(i, ptr)
|
||||
m.Delete(i)
|
||||
if fn() {
|
||||
break
|
||||
}
|
||||
}
|
||||
m.setTop(i)
|
||||
}
|
||||
|
||||
func subspace(prefix []byte) (start, end []byte) {
|
||||
end = make([]byte, len(prefix))
|
||||
copy(end, prefix)
|
||||
end[len(end)-1]++
|
||||
return prefix, end
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
package lib
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
dbm "github.com/tendermint/tmlibs/db"
|
||||
"github.com/tendermint/tmlibs/log"
|
||||
|
||||
abci "github.com/tendermint/abci/types"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/store"
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
)
|
||||
|
||||
type S struct {
|
||||
I uint64
|
||||
B bool
|
||||
}
|
||||
|
||||
func defaultComponents(key sdk.StoreKey) (sdk.Context, *wire.Codec) {
|
||||
db := dbm.NewMemDB()
|
||||
cms := store.NewCommitMultiStore(db)
|
||||
cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db)
|
||||
cms.LoadLatestVersion()
|
||||
ctx := sdk.NewContext(cms, abci.Header{}, false, nil, log.NewNopLogger())
|
||||
cdc := wire.NewCodec()
|
||||
return ctx, cdc
|
||||
}
|
||||
|
||||
func TestList(t *testing.T) {
|
||||
key := sdk.NewKVStoreKey("test")
|
||||
ctx, cdc := defaultComponents(key)
|
||||
store := ctx.KVStore(key)
|
||||
lm := NewList(cdc, store, nil)
|
||||
|
||||
val := S{1, true}
|
||||
var res S
|
||||
|
||||
lm.Push(val)
|
||||
assert.Equal(t, uint64(1), lm.Len())
|
||||
lm.Get(uint64(0), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
val = S{2, false}
|
||||
lm.Set(uint64(0), val)
|
||||
lm.Get(uint64(0), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
val = S{100, false}
|
||||
lm.Push(val)
|
||||
assert.Equal(t, uint64(2), lm.Len())
|
||||
lm.Get(uint64(1), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
lm.Delete(uint64(1))
|
||||
assert.Equal(t, uint64(2), lm.Len())
|
||||
|
||||
lm.Iterate(&res, func(index uint64) (brk bool) {
|
||||
var temp S
|
||||
lm.Get(index, &temp)
|
||||
assert.Equal(t, temp, res)
|
||||
|
||||
assert.True(t, index != 1)
|
||||
return
|
||||
})
|
||||
|
||||
lm.Iterate(&res, func(index uint64) (brk bool) {
|
||||
lm.Set(index, S{res.I + 1, !res.B})
|
||||
return
|
||||
})
|
||||
|
||||
lm.Get(uint64(0), &res)
|
||||
assert.Equal(t, S{3, true}, res)
|
||||
}
|
||||
|
||||
func TestQueue(t *testing.T) {
|
||||
key := sdk.NewKVStoreKey("test")
|
||||
ctx, cdc := defaultComponents(key)
|
||||
store := ctx.KVStore(key)
|
||||
|
||||
qm := NewQueue(cdc, store, nil)
|
||||
|
||||
val := S{1, true}
|
||||
var res S
|
||||
|
||||
qm.Push(val)
|
||||
qm.Peek(&res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
qm.Pop()
|
||||
empty := qm.IsEmpty()
|
||||
|
||||
assert.True(t, empty)
|
||||
assert.NotNil(t, qm.Peek(&res))
|
||||
|
||||
qm.Push(S{1, true})
|
||||
qm.Push(S{2, true})
|
||||
qm.Push(S{3, true})
|
||||
qm.Flush(&res, func() (brk bool) {
|
||||
if res.I == 3 {
|
||||
brk = true
|
||||
}
|
||||
return
|
||||
})
|
||||
|
||||
assert.False(t, qm.IsEmpty())
|
||||
|
||||
qm.Pop()
|
||||
assert.True(t, qm.IsEmpty())
|
||||
}
|
||||
|
||||
func TestOptions(t *testing.T) {
|
||||
key := sdk.NewKVStoreKey("test")
|
||||
ctx, cdc := defaultComponents(key)
|
||||
store := ctx.KVStore(key)
|
||||
|
||||
keys := &LinearKeys{
|
||||
LengthKey: []byte{0xDE, 0xAD},
|
||||
ElemKey: []byte{0xBE, 0xEF},
|
||||
TopKey: []byte{0x12, 0x34},
|
||||
}
|
||||
linear := NewLinear(cdc, store, keys)
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
linear.Push(i)
|
||||
}
|
||||
|
||||
var len uint64
|
||||
var top uint64
|
||||
var expected int
|
||||
var actual int
|
||||
|
||||
// Checking keys.LengthKey
|
||||
err := cdc.UnmarshalBinary(store.Get(keys.LengthKey), &len)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, len, linear.Len())
|
||||
|
||||
// Checking keys.ElemKey
|
||||
for i := 0; i < 10; i++ {
|
||||
linear.Get(uint64(i), &expected)
|
||||
bz := store.Get(append(keys.ElemKey, []byte(fmt.Sprintf("%020d", i))...))
|
||||
err = cdc.UnmarshalBinary(bz, &actual)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, expected, actual)
|
||||
}
|
||||
|
||||
linear.Pop()
|
||||
|
||||
err = cdc.UnmarshalBinary(store.Get(keys.TopKey), &top)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, top, linear.getTop())
|
||||
|
||||
}
|
||||
@@ -1,286 +0,0 @@
|
||||
package lib
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
)
|
||||
|
||||
// Mapper defines a primitive mapper type
|
||||
type Mapper struct {
|
||||
key sdk.StoreKey
|
||||
cdc *wire.Codec
|
||||
prefix string
|
||||
}
|
||||
|
||||
// ListMapper is a Mapper interface that provides list-like functions
|
||||
// It panics when the element type cannot be (un/)marshalled by the codec
|
||||
type ListMapper interface {
|
||||
|
||||
// Len() returns the length of the list
|
||||
// The length is only increased by Push() and not decreased
|
||||
// ListMapper dosen't check if an index is in bounds
|
||||
// The user should check Len() before doing any actions
|
||||
Len(sdk.Context) uint64
|
||||
|
||||
// Get() returns the element by its index
|
||||
Get(sdk.Context, uint64, interface{}) error
|
||||
|
||||
// Set() stores the element to the given position
|
||||
// Setting element out of range will break length counting
|
||||
// Use Push() instead of Set() to append a new element
|
||||
Set(sdk.Context, uint64, interface{})
|
||||
|
||||
// Delete() deletes the element in the given position
|
||||
// Other elements' indices are preserved after deletion
|
||||
// Panics when the index is out of range
|
||||
Delete(sdk.Context, uint64)
|
||||
|
||||
// Push() inserts the element to the end of the list
|
||||
// It will increase the length when it is called
|
||||
Push(sdk.Context, interface{})
|
||||
|
||||
// Iterate*() is used to iterate over all existing elements in the list
|
||||
// Return true in the continuation to break
|
||||
// The second element of the continuation will indicate the position of the element
|
||||
// Using it with Get() will return the same one with the provided element
|
||||
|
||||
// CONTRACT: No writes may happen within a domain while iterating over it.
|
||||
IterateRead(sdk.Context, interface{}, func(sdk.Context, uint64) bool)
|
||||
|
||||
// IterateWrite() is safe to write over the domain
|
||||
IterateWrite(sdk.Context, interface{}, func(sdk.Context, uint64) bool)
|
||||
|
||||
// Key for the length of the list
|
||||
LengthKey() []byte
|
||||
|
||||
// Key for getting elements
|
||||
ElemKey(uint64) []byte
|
||||
}
|
||||
|
||||
// NewListMapper constructs new ListMapper
|
||||
func NewListMapper(cdc *wire.Codec, key sdk.StoreKey, prefix string) ListMapper {
|
||||
return Mapper{
|
||||
key: key,
|
||||
cdc: cdc,
|
||||
prefix: prefix,
|
||||
}
|
||||
}
|
||||
|
||||
// Len implements ListMapper
|
||||
func (m Mapper) Len(ctx sdk.Context) uint64 {
|
||||
store := ctx.KVStore(m.key)
|
||||
bz := store.Get(m.LengthKey())
|
||||
if bz == nil {
|
||||
zero, err := m.cdc.MarshalBinary(0)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
store.Set(m.LengthKey(), zero)
|
||||
return 0
|
||||
}
|
||||
var res uint64
|
||||
if err := m.cdc.UnmarshalBinary(bz, &res); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
// Get implements ListMapper
|
||||
func (m Mapper) Get(ctx sdk.Context, index uint64, ptr interface{}) error {
|
||||
store := ctx.KVStore(m.key)
|
||||
bz := store.Get(m.ElemKey(index))
|
||||
return m.cdc.UnmarshalBinary(bz, ptr)
|
||||
}
|
||||
|
||||
// Set implements ListMapper
|
||||
func (m Mapper) Set(ctx sdk.Context, index uint64, value interface{}) {
|
||||
store := ctx.KVStore(m.key)
|
||||
bz, err := m.cdc.MarshalBinary(value)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
store.Set(m.ElemKey(index), bz)
|
||||
}
|
||||
|
||||
// Delete implements ListMapper
|
||||
func (m Mapper) Delete(ctx sdk.Context, index uint64) {
|
||||
store := ctx.KVStore(m.key)
|
||||
store.Delete(m.ElemKey(index))
|
||||
}
|
||||
|
||||
// Push implements ListMapper
|
||||
func (m Mapper) Push(ctx sdk.Context, value interface{}) {
|
||||
length := m.Len(ctx)
|
||||
m.Set(ctx, length, value)
|
||||
|
||||
store := ctx.KVStore(m.key)
|
||||
store.Set(m.LengthKey(), marshalUint64(m.cdc, length+1))
|
||||
}
|
||||
|
||||
// IterateRead implements ListMapper
|
||||
func (m Mapper) IterateRead(ctx sdk.Context, ptr interface{}, fn func(sdk.Context, uint64) bool) {
|
||||
store := ctx.KVStore(m.key)
|
||||
start, end := subspace([]byte(fmt.Sprintf("%s/elem/", m.prefix)))
|
||||
iter := store.Iterator(start, end)
|
||||
for ; iter.Valid(); iter.Next() {
|
||||
v := iter.Value()
|
||||
if err := m.cdc.UnmarshalBinary(v, ptr); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s := string(iter.Key()[len(m.prefix)+6:])
|
||||
index, err := strconv.ParseUint(s, 10, 64)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if fn(ctx, index) {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
// IterateWrite implements ListMapper
|
||||
func (m Mapper) IterateWrite(ctx sdk.Context, ptr interface{}, fn func(sdk.Context, uint64) bool) {
|
||||
length := m.Len(ctx)
|
||||
|
||||
for i := uint64(0); i < length; i++ {
|
||||
if err := m.Get(ctx, i, ptr); err != nil {
|
||||
continue
|
||||
}
|
||||
if fn(ctx, i) {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// LengthKey implements ListMapper
|
||||
func (m Mapper) LengthKey() []byte {
|
||||
return []byte(fmt.Sprintf("%s/length", m.prefix))
|
||||
}
|
||||
|
||||
// ElemKey implements ListMapper
|
||||
func (m Mapper) ElemKey(i uint64) []byte {
|
||||
return []byte(fmt.Sprintf("%s/elem/%020d", m.prefix, i))
|
||||
}
|
||||
|
||||
// QueueMapper is a Mapper interface that provides queue-like functions
|
||||
// It panics when the element type cannot be (un/)marshalled by the codec
|
||||
type QueueMapper interface {
|
||||
// Push() inserts the elements to the rear of the queue
|
||||
Push(sdk.Context, interface{})
|
||||
|
||||
// Popping/Peeking on an empty queue will cause panic
|
||||
// The user should check IsEmpty() before doing any actions
|
||||
|
||||
// Peek() returns the element at the front of the queue without removing it
|
||||
Peek(sdk.Context, interface{}) error
|
||||
|
||||
// Pop() returns the element at the front of the queue and removes it
|
||||
Pop(sdk.Context)
|
||||
|
||||
// IsEmpty() checks if the queue is empty
|
||||
IsEmpty(sdk.Context) bool
|
||||
|
||||
// Flush() removes elements it processed
|
||||
// Return true in the continuation to break
|
||||
// The interface{} is unmarshalled before the continuation is called
|
||||
// Starts from the top(head) of the queue
|
||||
// CONTRACT: Pop() or Push() should not be performed while flushing
|
||||
Flush(sdk.Context, interface{}, func(sdk.Context) bool)
|
||||
|
||||
// Key for the index of top element
|
||||
TopKey() []byte
|
||||
}
|
||||
|
||||
// NewQueueMapper constructs new QueueMapper
|
||||
func NewQueueMapper(cdc *wire.Codec, key sdk.StoreKey, prefix string) QueueMapper {
|
||||
return Mapper{
|
||||
key: key,
|
||||
cdc: cdc,
|
||||
prefix: prefix,
|
||||
}
|
||||
}
|
||||
|
||||
func (m Mapper) getTop(store sdk.KVStore) (res uint64) {
|
||||
bz := store.Get(m.TopKey())
|
||||
if bz == nil {
|
||||
store.Set(m.TopKey(), marshalUint64(m.cdc, 0))
|
||||
return 0
|
||||
}
|
||||
|
||||
if err := m.cdc.UnmarshalBinary(bz, &res); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (m Mapper) setTop(store sdk.KVStore, top uint64) {
|
||||
bz := marshalUint64(m.cdc, top)
|
||||
store.Set(m.TopKey(), bz)
|
||||
}
|
||||
|
||||
// Peek implements QueueMapper
|
||||
func (m Mapper) Peek(ctx sdk.Context, ptr interface{}) error {
|
||||
store := ctx.KVStore(m.key)
|
||||
top := m.getTop(store)
|
||||
return m.Get(ctx, top, ptr)
|
||||
}
|
||||
|
||||
// Pop implements QueueMapper
|
||||
func (m Mapper) Pop(ctx sdk.Context) {
|
||||
store := ctx.KVStore(m.key)
|
||||
top := m.getTop(store)
|
||||
m.Delete(ctx, top)
|
||||
m.setTop(store, top+1)
|
||||
}
|
||||
|
||||
// IsEmpty implements QueueMapper
|
||||
func (m Mapper) IsEmpty(ctx sdk.Context) bool {
|
||||
store := ctx.KVStore(m.key)
|
||||
top := m.getTop(store)
|
||||
length := m.Len(ctx)
|
||||
return top >= length
|
||||
}
|
||||
|
||||
// Flush implements QueueMapper
|
||||
func (m Mapper) Flush(ctx sdk.Context, ptr interface{}, fn func(sdk.Context) bool) {
|
||||
store := ctx.KVStore(m.key)
|
||||
top := m.getTop(store)
|
||||
length := m.Len(ctx)
|
||||
|
||||
var i uint64
|
||||
for i = top; i < length; i++ {
|
||||
m.Get(ctx, i, ptr)
|
||||
m.Delete(ctx, i)
|
||||
if fn(ctx) {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
m.setTop(store, i)
|
||||
}
|
||||
|
||||
// TopKey implements QueueMapper
|
||||
func (m Mapper) TopKey() []byte {
|
||||
return []byte(fmt.Sprintf("%s/top", m.prefix))
|
||||
}
|
||||
|
||||
func marshalUint64(cdc *wire.Codec, i uint64) []byte {
|
||||
bz, err := cdc.MarshalBinary(i)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return bz
|
||||
}
|
||||
|
||||
func subspace(prefix []byte) (start, end []byte) {
|
||||
end = make([]byte, len(prefix))
|
||||
copy(end, prefix)
|
||||
end[len(end)-1]++
|
||||
return prefix, end
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
package lib
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
dbm "github.com/tendermint/tmlibs/db"
|
||||
"github.com/tendermint/tmlibs/log"
|
||||
|
||||
abci "github.com/tendermint/abci/types"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/store"
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
)
|
||||
|
||||
type S struct {
|
||||
I uint64
|
||||
B bool
|
||||
}
|
||||
|
||||
func defaultComponents(key sdk.StoreKey) (sdk.Context, *wire.Codec) {
|
||||
db := dbm.NewMemDB()
|
||||
cms := store.NewCommitMultiStore(db)
|
||||
cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db)
|
||||
cms.LoadLatestVersion()
|
||||
ctx := sdk.NewContext(cms, abci.Header{}, false, nil, log.NewNopLogger())
|
||||
cdc := wire.NewCodec()
|
||||
return ctx, cdc
|
||||
}
|
||||
|
||||
func TestListMapper(t *testing.T) {
|
||||
key := sdk.NewKVStoreKey("list")
|
||||
ctx, cdc := defaultComponents(key)
|
||||
lm := NewListMapper(cdc, key, "data")
|
||||
|
||||
val := S{1, true}
|
||||
var res S
|
||||
|
||||
lm.Push(ctx, val)
|
||||
assert.Equal(t, uint64(1), lm.Len(ctx))
|
||||
lm.Get(ctx, uint64(0), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
val = S{2, false}
|
||||
lm.Set(ctx, uint64(0), val)
|
||||
lm.Get(ctx, uint64(0), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
val = S{100, false}
|
||||
lm.Push(ctx, val)
|
||||
assert.Equal(t, uint64(2), lm.Len(ctx))
|
||||
lm.Get(ctx, uint64(1), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
lm.Delete(ctx, uint64(1))
|
||||
assert.Equal(t, uint64(2), lm.Len(ctx))
|
||||
|
||||
lm.IterateRead(ctx, &res, func(ctx sdk.Context, index uint64) (brk bool) {
|
||||
var temp S
|
||||
lm.Get(ctx, index, &temp)
|
||||
assert.Equal(t, temp, res)
|
||||
|
||||
assert.True(t, index != 1)
|
||||
return
|
||||
})
|
||||
|
||||
lm.IterateWrite(ctx, &res, func(ctx sdk.Context, index uint64) (brk bool) {
|
||||
lm.Set(ctx, index, S{res.I + 1, !res.B})
|
||||
return
|
||||
})
|
||||
|
||||
lm.Get(ctx, uint64(0), &res)
|
||||
assert.Equal(t, S{3, true}, res)
|
||||
}
|
||||
|
||||
func TestQueueMapper(t *testing.T) {
|
||||
key := sdk.NewKVStoreKey("queue")
|
||||
ctx, cdc := defaultComponents(key)
|
||||
qm := NewQueueMapper(cdc, key, "data")
|
||||
|
||||
val := S{1, true}
|
||||
var res S
|
||||
|
||||
qm.Push(ctx, val)
|
||||
qm.Peek(ctx, &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
qm.Pop(ctx)
|
||||
empty := qm.IsEmpty(ctx)
|
||||
|
||||
assert.True(t, empty)
|
||||
assert.NotNil(t, qm.Peek(ctx, &res))
|
||||
|
||||
qm.Push(ctx, S{1, true})
|
||||
qm.Push(ctx, S{2, true})
|
||||
qm.Push(ctx, S{3, true})
|
||||
qm.Flush(ctx, &res, func(ctx sdk.Context) (brk bool) {
|
||||
if res.I == 3 {
|
||||
brk = true
|
||||
}
|
||||
return
|
||||
})
|
||||
|
||||
assert.False(t, qm.IsEmpty(ctx))
|
||||
|
||||
qm.Pop(ctx)
|
||||
assert.True(t, qm.IsEmpty(ctx))
|
||||
}
|
||||
@@ -103,6 +103,9 @@ type KVStore interface {
|
||||
// Delete deletes the key. Panics on nil key.
|
||||
Delete(key []byte)
|
||||
|
||||
// Prefix applied keys with the argument
|
||||
Prefix(prefix []byte) KVStore
|
||||
|
||||
// Iterator over a domain of keys in ascending order. End is exclusive.
|
||||
// Start must be less than end, or the Iterator is invalid.
|
||||
// Iterator must be closed by caller.
|
||||
@@ -152,6 +155,11 @@ type CommitKVStore interface {
|
||||
KVStore
|
||||
}
|
||||
|
||||
// Wrapper for StoreKeys to get KVStores
|
||||
type KVStoreGetter interface {
|
||||
KVStore(Context) KVStore
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// CacheWrap
|
||||
|
||||
@@ -204,6 +212,7 @@ const (
|
||||
StoreTypeMulti StoreType = iota
|
||||
StoreTypeDB
|
||||
StoreTypeIAVL
|
||||
StoreTypePrefix
|
||||
)
|
||||
|
||||
//----------------------------------------
|
||||
@@ -237,6 +246,11 @@ func (key *KVStoreKey) String() string {
|
||||
return fmt.Sprintf("KVStoreKey{%p, %s}", key, key.name)
|
||||
}
|
||||
|
||||
// Implements KVStoreGetter
|
||||
func (key *KVStoreKey) KVStore(ctx Context) KVStore {
|
||||
return ctx.KVStore(key)
|
||||
}
|
||||
|
||||
// PrefixEndBytes returns the []byte that would end a
|
||||
// range query for all []byte with a certain prefix
|
||||
// Deals with last byte of prefix being FF without overflowing
|
||||
@@ -263,7 +277,24 @@ func PrefixEndBytes(prefix []byte) []byte {
|
||||
return end
|
||||
}
|
||||
|
||||
// Getter struct for prefixed stores
|
||||
type PrefixStoreGetter struct {
|
||||
key StoreKey
|
||||
prefix []byte
|
||||
}
|
||||
|
||||
func NewPrefixStoreGetter(key StoreKey, prefix []byte) PrefixStoreGetter {
|
||||
return PrefixStoreGetter{key, prefix}
|
||||
}
|
||||
|
||||
// Implements sdk.KVStoreGetter
|
||||
func (getter PrefixStoreGetter) KVStore(ctx Context) KVStore {
|
||||
return ctx.KVStore(getter.key).Prefix(getter.prefix)
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
|
||||
// key-value result for iterator queries
|
||||
type KVPair cmn.KVPair
|
||||
|
||||
//----------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user