certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

apply requests

This commit is contained in:
mossid 2018-04-13 14:10:55 +02:00
parent 373e408fad
commit 1b72a6c40d
2 changed files with 133 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
types/lib/stdlib.go
View File

@ -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
}

40
types/lib/stdlib_test.go
View File

@ -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))