apply requests
This commit is contained in:
parent
373e408fad
commit
1b72a6c40d
|
@ -2,6 +2,8 @@ package lib
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
|
@ -11,38 +13,45 @@ import (
|
|||
// It panics when the element type cannot be (un/)marshalled by the codec
|
||||
|
||||
type ListMapper interface {
|
||||
// ListMapper dosen't checks index out of range
|
||||
// ListMapper dosen't check if an index is in bounds
|
||||
// The user should check Len() before doing any actions
|
||||
Len(sdk.Context) int64
|
||||
Get(sdk.Context, int64, interface{})
|
||||
// Setting element out of range is harmful; use Push() when adding new elements
|
||||
Set(sdk.Context, int64, interface{})
|
||||
Delete(sdk.Context, int64)
|
||||
Len(sdk.Context) uint64
|
||||
|
||||
Get(sdk.Context, uint64, interface{}) error
|
||||
|
||||
// Setting element out of range is harmful
|
||||
// Use Push() instead of Set() to append a new element
|
||||
Set(sdk.Context, uint64, interface{})
|
||||
|
||||
Delete(sdk.Context, uint64)
|
||||
|
||||
Push(sdk.Context, interface{})
|
||||
Iterate(sdk.Context, interface{}, func(sdk.Context, int64) bool)
|
||||
|
||||
// Iterate*() is used to iterate over all existing elements in the list
|
||||
// Return true in the continuation to break
|
||||
|
||||
// CONTRACT: No writes may happen within a domain while an iterator exists 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)
|
||||
}
|
||||
|
||||
type listMapper struct {
|
||||
key sdk.StoreKey
|
||||
cdc *wire.Codec
|
||||
prefix string
|
||||
lk []byte
|
||||
}
|
||||
|
||||
func NewListMapper(cdc *wire.Codec, key sdk.StoreKey, prefix string) ListMapper {
|
||||
lk, err := cdc.MarshalBinary(int64(-1))
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return listMapper{
|
||||
key: key,
|
||||
cdc: cdc,
|
||||
prefix: prefix,
|
||||
lk: lk,
|
||||
}
|
||||
}
|
||||
|
||||
func (lm listMapper) Len(ctx sdk.Context) int64 {
|
||||
func (lm listMapper) Len(ctx sdk.Context) uint64 {
|
||||
store := ctx.KVStore(lm.key)
|
||||
bz := store.Get(lm.LengthKey())
|
||||
if bz == nil {
|
||||
|
@ -53,28 +62,20 @@ func (lm listMapper) Len(ctx sdk.Context) int64 {
|
|||
store.Set(lm.LengthKey(), zero)
|
||||
return 0
|
||||
}
|
||||
var res int64
|
||||
var res uint64
|
||||
if err := lm.cdc.UnmarshalBinary(bz, &res); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func (lm listMapper) Get(ctx sdk.Context, index int64, ptr interface{}) {
|
||||
if index < 0 {
|
||||
panic(fmt.Errorf("Invalid index in ListMapper.Get(ctx, %d, ptr)", index))
|
||||
}
|
||||
func (lm listMapper) Get(ctx sdk.Context, index uint64, ptr interface{}) error {
|
||||
store := ctx.KVStore(lm.key)
|
||||
bz := store.Get(lm.ElemKey(index))
|
||||
if err := lm.cdc.UnmarshalBinary(bz, ptr); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return lm.cdc.UnmarshalBinary(bz, ptr)
|
||||
}
|
||||
|
||||
func (lm listMapper) Set(ctx sdk.Context, index int64, value interface{}) {
|
||||
if index < 0 {
|
||||
panic(fmt.Errorf("Invalid index in ListMapper.Set(ctx, %d, value)", index))
|
||||
}
|
||||
func (lm listMapper) Set(ctx sdk.Context, index uint64, value interface{}) {
|
||||
store := ctx.KVStore(lm.key)
|
||||
bz, err := lm.cdc.MarshalBinary(value)
|
||||
if err != nil {
|
||||
|
@ -83,10 +84,7 @@ func (lm listMapper) Set(ctx sdk.Context, index int64, value interface{}) {
|
|||
store.Set(lm.ElemKey(index), bz)
|
||||
}
|
||||
|
||||
func (lm listMapper) Delete(ctx sdk.Context, index int64) {
|
||||
if index < 0 {
|
||||
panic(fmt.Errorf("Invalid index in ListMapper.Delete(ctx, %d)", index))
|
||||
}
|
||||
func (lm listMapper) Delete(ctx sdk.Context, index uint64) {
|
||||
store := ctx.KVStore(lm.key)
|
||||
store.Delete(lm.ElemKey(index))
|
||||
}
|
||||
|
@ -96,13 +94,38 @@ func (lm listMapper) Push(ctx sdk.Context, value interface{}) {
|
|||
lm.Set(ctx, length, value)
|
||||
|
||||
store := ctx.KVStore(lm.key)
|
||||
store.Set(lm.LengthKey(), marshalInt64(lm.cdc, length+1))
|
||||
store.Set(lm.LengthKey(), marshalUint64(lm.cdc, length+1))
|
||||
}
|
||||
|
||||
func (lm listMapper) Iterate(ctx sdk.Context, ptr interface{}, fn func(sdk.Context, int64) bool) {
|
||||
func (lm listMapper) IterateRead(ctx sdk.Context, ptr interface{}, fn func(sdk.Context, uint64) bool) {
|
||||
store := ctx.KVStore(lm.key)
|
||||
start, end := subspace([]byte(fmt.Sprintf("%s/elem/", lm.prefix)))
|
||||
iter := store.Iterator(start, end)
|
||||
for ; iter.Valid(); iter.Next() {
|
||||
v := iter.Value()
|
||||
if err := lm.cdc.UnmarshalBinary(v, ptr); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s := strings.Split(string(iter.Key()), "/")
|
||||
index, err := strconv.ParseUint(s[len(s)-1], 10, 64)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if fn(ctx, index) {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
func (lm listMapper) IterateWrite(ctx sdk.Context, ptr interface{}, fn func(sdk.Context, uint64) bool) {
|
||||
length := lm.Len(ctx)
|
||||
for i := int64(0); i < length; i++ {
|
||||
lm.Get(ctx, i, ptr)
|
||||
|
||||
for i := uint64(0); i < length; i++ {
|
||||
if err := lm.Get(ctx, i, ptr); err != nil {
|
||||
continue
|
||||
}
|
||||
if fn(ctx, i) {
|
||||
break
|
||||
}
|
||||
|
@ -110,11 +133,11 @@ func (lm listMapper) Iterate(ctx sdk.Context, ptr interface{}, fn func(sdk.Conte
|
|||
}
|
||||
|
||||
func (lm listMapper) LengthKey() []byte {
|
||||
return []byte(fmt.Sprintf("%s/%d", lm.prefix, lm.lk))
|
||||
return []byte(fmt.Sprintf("%s/length", lm.prefix))
|
||||
}
|
||||
|
||||
func (lm listMapper) ElemKey(i int64) []byte {
|
||||
return []byte(fmt.Sprintf("%s/%d", lm.prefix, i))
|
||||
func (lm listMapper) ElemKey(i uint64) []byte {
|
||||
return []byte(fmt.Sprintf("%s/elem/%020d", lm.prefix, i))
|
||||
}
|
||||
|
||||
// QueueMapper is a Mapper interface that provides queue-like functions
|
||||
|
@ -124,12 +147,14 @@ type QueueMapper interface {
|
|||
Push(sdk.Context, interface{})
|
||||
// Popping/Peeking on an empty queue will cause panic
|
||||
// The user should check IsEmpty() before doing any actions
|
||||
Peek(sdk.Context, interface{})
|
||||
Peek(sdk.Context, interface{}) error
|
||||
Pop(sdk.Context)
|
||||
IsEmpty(sdk.Context) bool
|
||||
// Iterate() removes elements it processed; return true in the continuation to break
|
||||
Iterate(sdk.Context, interface{}, func(sdk.Context) bool)
|
||||
Info(sdk.Context) QueueInfo
|
||||
// Iterate() 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
|
||||
Flush(sdk.Context, interface{}, func(sdk.Context) bool)
|
||||
}
|
||||
|
||||
type queueMapper struct {
|
||||
|
@ -137,100 +162,67 @@ type queueMapper struct {
|
|||
cdc *wire.Codec
|
||||
prefix string
|
||||
lm ListMapper
|
||||
lk []byte
|
||||
ik []byte
|
||||
}
|
||||
|
||||
func NewQueueMapper(cdc *wire.Codec, key sdk.StoreKey, prefix string) QueueMapper {
|
||||
lk := []byte("list")
|
||||
ik := []byte("info")
|
||||
return queueMapper{
|
||||
key: key,
|
||||
cdc: cdc,
|
||||
prefix: prefix,
|
||||
lm: NewListMapper(cdc, key, prefix+string(lk)),
|
||||
lk: lk,
|
||||
ik: ik,
|
||||
lm: NewListMapper(cdc, key, prefix+"list"),
|
||||
}
|
||||
}
|
||||
|
||||
type QueueInfo struct {
|
||||
// begin <= elems < end
|
||||
Begin int64
|
||||
End int64
|
||||
}
|
||||
|
||||
func (info QueueInfo) validateBasic() error {
|
||||
if info.End < info.Begin || info.Begin < 0 || info.End < 0 {
|
||||
return fmt.Errorf("Invalid queue information: {Begin: %d, End: %d}", info.Begin, info.End)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (info QueueInfo) isEmpty() bool {
|
||||
return info.Begin == info.End
|
||||
}
|
||||
|
||||
func (qm queueMapper) getQueueInfo(store sdk.KVStore) QueueInfo {
|
||||
bz := store.Get(qm.InfoKey())
|
||||
func (qm queueMapper) getTop(store sdk.KVStore) (res uint64) {
|
||||
bz := store.Get(qm.TopKey())
|
||||
if bz == nil {
|
||||
store.Set(qm.InfoKey(), marshalQueueInfo(qm.cdc, QueueInfo{0, 0}))
|
||||
return QueueInfo{0, 0}
|
||||
store.Set(qm.TopKey(), marshalUint64(qm.cdc, 0))
|
||||
return 0
|
||||
}
|
||||
var info QueueInfo
|
||||
if err := qm.cdc.UnmarshalBinary(bz, &info); err != nil {
|
||||
|
||||
if err := qm.cdc.UnmarshalBinary(bz, &res); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if err := info.validateBasic(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return info
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (qm queueMapper) setQueueInfo(store sdk.KVStore, info QueueInfo) {
|
||||
bz, err := qm.cdc.MarshalBinary(info)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
store.Set(qm.InfoKey(), bz)
|
||||
func (qm queueMapper) setTop(store sdk.KVStore, top uint64) {
|
||||
bz := marshalUint64(qm.cdc, top)
|
||||
store.Set(qm.TopKey(), bz)
|
||||
}
|
||||
|
||||
func (qm queueMapper) Push(ctx sdk.Context, value interface{}) {
|
||||
store := ctx.KVStore(qm.key)
|
||||
info := qm.getQueueInfo(store)
|
||||
|
||||
qm.lm.Set(ctx, info.End, value)
|
||||
|
||||
info.End++
|
||||
qm.setQueueInfo(store, info)
|
||||
qm.lm.Push(ctx, value)
|
||||
}
|
||||
|
||||
func (qm queueMapper) Peek(ctx sdk.Context, ptr interface{}) {
|
||||
func (qm queueMapper) Peek(ctx sdk.Context, ptr interface{}) error {
|
||||
store := ctx.KVStore(qm.key)
|
||||
info := qm.getQueueInfo(store)
|
||||
qm.lm.Get(ctx, info.Begin, ptr)
|
||||
top := qm.getTop(store)
|
||||
return qm.lm.Get(ctx, top, ptr)
|
||||
}
|
||||
|
||||
func (qm queueMapper) Pop(ctx sdk.Context) {
|
||||
store := ctx.KVStore(qm.key)
|
||||
info := qm.getQueueInfo(store)
|
||||
qm.lm.Delete(ctx, info.Begin)
|
||||
info.Begin++
|
||||
qm.setQueueInfo(store, info)
|
||||
top := qm.getTop(store)
|
||||
qm.lm.Delete(ctx, top)
|
||||
qm.setTop(store, top+1)
|
||||
}
|
||||
|
||||
func (qm queueMapper) IsEmpty(ctx sdk.Context) bool {
|
||||
store := ctx.KVStore(qm.key)
|
||||
info := qm.getQueueInfo(store)
|
||||
return info.isEmpty()
|
||||
top := qm.getTop(store)
|
||||
length := qm.lm.Len(ctx)
|
||||
return top >= length
|
||||
}
|
||||
|
||||
func (qm queueMapper) Iterate(ctx sdk.Context, ptr interface{}, fn func(sdk.Context) bool) {
|
||||
func (qm queueMapper) Flush(ctx sdk.Context, ptr interface{}, fn func(sdk.Context) bool) {
|
||||
store := ctx.KVStore(qm.key)
|
||||
info := qm.getQueueInfo(store)
|
||||
top := qm.getTop(store)
|
||||
length := qm.lm.Len(ctx)
|
||||
|
||||
var i int64
|
||||
for i = info.Begin; i < info.End; i++ {
|
||||
var i uint64
|
||||
for i = top; i < length; i++ {
|
||||
qm.lm.Get(ctx, i, ptr)
|
||||
qm.lm.Delete(ctx, i)
|
||||
if fn(ctx) {
|
||||
|
@ -238,32 +230,24 @@ func (qm queueMapper) Iterate(ctx sdk.Context, ptr interface{}, fn func(sdk.Cont
|
|||
}
|
||||
}
|
||||
|
||||
info.Begin = i
|
||||
qm.setQueueInfo(store, info)
|
||||
qm.setTop(store, i)
|
||||
}
|
||||
|
||||
func (qm queueMapper) Info(ctx sdk.Context) QueueInfo {
|
||||
store := ctx.KVStore(qm.key)
|
||||
|
||||
return qm.getQueueInfo(store)
|
||||
func (qm queueMapper) TopKey() []byte {
|
||||
return []byte(fmt.Sprintf("%s/top", qm.prefix))
|
||||
}
|
||||
|
||||
func (qm queueMapper) InfoKey() []byte {
|
||||
return []byte(fmt.Sprintf("%s/%s", qm.prefix, qm.ik))
|
||||
}
|
||||
|
||||
func marshalQueueInfo(cdc *wire.Codec, info QueueInfo) []byte {
|
||||
bz, err := cdc.MarshalBinary(info)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return bz
|
||||
}
|
||||
|
||||
func marshalInt64(cdc *wire.Codec, i int64) []byte {
|
||||
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
|
||||
}
|
||||
|
|
|
@ -9,13 +9,13 @@ import (
|
|||
|
||||
abci "github.com/tendermint/abci/types"
|
||||
|
||||
store "github.com/cosmos/cosmos-sdk/mock"
|
||||
"github.com/cosmos/cosmos-sdk/store"
|
||||
sdk "github.com/cosmos/cosmos-sdk/types"
|
||||
wire "github.com/cosmos/cosmos-sdk/wire"
|
||||
)
|
||||
|
||||
type S struct {
|
||||
I int64
|
||||
I uint64
|
||||
B bool
|
||||
}
|
||||
|
||||
|
@ -38,20 +38,39 @@ func TestListMapper(t *testing.T) {
|
|||
var res S
|
||||
|
||||
lm.Push(ctx, val)
|
||||
assert.Equal(t, int64(1), lm.Len(ctx))
|
||||
lm.Get(ctx, int64(0), &res)
|
||||
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, int64(0), val)
|
||||
lm.Get(ctx, int64(0), &res)
|
||||
lm.Set(ctx, uint64(0), val)
|
||||
lm.Get(ctx, uint64(0), &res)
|
||||
assert.Equal(t, val, res)
|
||||
|
||||
lm.Iterate(ctx, &res, func(ctx sdk.Context, index int64) (brk bool) {
|
||||
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, int64(0), &res)
|
||||
|
||||
lm.Get(ctx, uint64(0), &res)
|
||||
assert.Equal(t, S{3, true}, res)
|
||||
}
|
||||
|
||||
|
@ -71,12 +90,12 @@ func TestQueueMapper(t *testing.T) {
|
|||
empty := qm.IsEmpty(ctx)
|
||||
|
||||
assert.True(t, empty)
|
||||
assert.Panics(t, func() { qm.Peek(ctx, &res) })
|
||||
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.Iterate(ctx, &res, func(ctx sdk.Context) (brk bool) {
|
||||
qm.Flush(ctx, &res, func(ctx sdk.Context) (brk bool) {
|
||||
if res.I == 3 {
|
||||
brk = true
|
||||
}
|
||||
|
@ -84,7 +103,6 @@ func TestQueueMapper(t *testing.T) {
|
|||
})
|
||||
|
||||
assert.False(t, qm.IsEmpty(ctx))
|
||||
assert.Equal(t, QueueInfo{3, 4}, qm.Info(ctx))
|
||||
|
||||
qm.Pop(ctx)
|
||||
assert.True(t, qm.IsEmpty(ctx))
|
||||
|
|
Loading…
Reference in New Issue