R4R: Store Accessor Types

store/state/base.go

@@ -0,0 +1,54 @@
+package state
+
+import (
+	//	"github.com/tendermint/tendermint/crypto/merkle"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type Base struct {
+	cdc     *codec.Codec
+	storefn func(Context) KVStore
+	prefix  []byte
+}
+
+func EmptyBase() Base {
+	return NewBase(nil, nil)
+}
+
+func NewBase(cdc *codec.Codec, key sdk.StoreKey) Base {
+	return Base{
+		cdc:     cdc,
+		storefn: func(ctx Context) KVStore { return ctx.KVStore(key) },
+	}
+}
+
+func (base Base) store(ctx Context) KVStore {
+	return prefix.NewStore(base.storefn(ctx), base.prefix)
+}
+
+func join(a, b []byte) (res []byte) {
+	res = make([]byte, len(a)+len(b))
+	copy(res, a)
+	copy(res[len(a):], b)
+	return
+}
+
+func (base Base) Prefix(prefix []byte) (res Base) {
+	res = Base{
+		cdc:     base.cdc,
+		storefn: base.storefn,
+		prefix:  join(base.prefix, prefix),
+	}
+	return
+}
+
+func (base Base) Cdc() *codec.Codec {
+	return base.cdc
+}
+
+func (base Base) key(key []byte) []byte {
+	return join(base.prefix, key)
+}

store/state/boolean.go

@@ -0,0 +1,23 @@
+package state
+
+type Boolean struct {
+	Value
+}
+
+func NewBoolean(v Value) Boolean {
+	return Boolean{v}
+}
+
+func (v Boolean) Get(ctx Context) (res bool) {
+	v.Value.Get(ctx, &res)
+	return
+}
+
+func (v Boolean) GetSafe(ctx Context) (res bool, err error) {
+	err = v.Value.GetSafe(ctx, &res)
+	return
+}
+
+func (v Boolean) Set(ctx Context, value bool) {
+	v.Value.Set(ctx, value)
+}

store/state/enum.go

@@ -0,0 +1,37 @@
+package state
+
+type Enum struct {
+	Value
+}
+
+func NewEnum(v Value) Enum {
+	return Enum{v}
+}
+
+func (v Enum) Get(ctx Context) (res byte) {
+	v.Value.Get(ctx, &res)
+	return
+}
+
+func (v Enum) GetSafe(ctx Context) (res byte, err error) {
+	v.Value.GetSafe(ctx, &res)
+	return
+}
+
+func (v Enum) Set(ctx Context, value byte) {
+	v.Value.Set(ctx, value)
+}
+
+func (v Enum) Incr(ctx Context) (res byte) {
+	res = v.Get(ctx) + 1
+	v.Set(ctx, res)
+	return
+}
+
+func (v Enum) Transit(ctx Context, from, to byte) bool {
+	if v.Get(ctx) != from {
+		return false
+	}
+	v.Set(ctx, to)
+	return true
+}

store/state/indexer.go

@@ -0,0 +1,93 @@
+package state
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strconv"
+)
+
+type IntEncoding byte
+
+const (
+	Dec IntEncoding = iota
+	Hex
+	Bin
+)
+
+type Indexer struct {
+	m Mapping
+
+	enc IntEncoding
+}
+
+func NewIndexer(base Base, prefix []byte, enc IntEncoding) Indexer {
+	return Indexer{
+		m:   NewMapping(base, prefix),
+		enc: enc,
+	}
+}
+
+// Identical length independent from the index, ensure ordering
+func EncodeInt(index uint64, enc IntEncoding) (res []byte) {
+	switch enc {
+	case Dec:
+		return []byte(fmt.Sprintf("%020d", index))
+	case Hex:
+		return []byte(fmt.Sprintf("%020x", index))
+	case Bin:
+		res = make([]byte, 8)
+		binary.BigEndian.PutUint64(res, index)
+		return
+	default:
+		panic("invalid IntEncoding")
+	}
+}
+
+func DecodeInt(bz []byte, enc IntEncoding) (res uint64, err error) {
+	switch enc {
+	case Dec:
+		return strconv.ParseUint(string(bz), 10, 64)
+	case Hex:
+		return strconv.ParseUint(string(bz), 16, 64)
+	case Bin:
+		return binary.BigEndian.Uint64(bz), nil
+	default:
+		panic("invalid IntEncoding")
+	}
+}
+
+func (ix Indexer) Value(index uint64) Value {
+	return ix.m.Value(EncodeInt(index, ix.enc))
+}
+
+func (ix Indexer) Get(ctx Context, index uint64, ptr interface{}) {
+	ix.Value(index).Get(ctx, ptr)
+}
+
+func (ix Indexer) GetSafe(ctx Context, index uint64, ptr interface{}) error {
+	return ix.Value(index).GetSafe(ctx, ptr)
+}
+
+func (ix Indexer) Set(ctx Context, index uint64, o interface{}) {
+	ix.Value(index).Set(ctx, o)
+}
+
+func (ix Indexer) Has(ctx Context, index uint64) bool {
+	return ix.Value(index).Exists(ctx)
+}
+
+func (ix Indexer) Delete(ctx Context, index uint64) {
+	ix.Value(index).Delete(ctx)
+}
+
+func (ix Indexer) IsEmpty(ctx Context) bool {
+	return ix.m.IsEmpty(ctx)
+}
+
+func (ix Indexer) Prefix(prefix []byte) Indexer {
+	return Indexer{
+		m: ix.m.Prefix(prefix),
+
+		enc: ix.enc,
+	}
+}

store/state/integer.go

@@ -0,0 +1,48 @@
+package state
+
+type Integer struct {
+	Value
+
+	enc IntEncoding
+}
+
+func NewInteger(v Value, enc IntEncoding) Integer {
+	return Integer{
+		Value: v,
+		enc:   enc,
+	}
+}
+
+func (v Integer) Get(ctx Context) (res uint64) {
+	bz := v.GetRaw(ctx)
+	if bz == nil {
+		return 0
+	}
+	res, err := DecodeInt(bz, v.enc)
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func (v Integer) GetSafe(ctx Context) (uint64, error) {
+	bz := v.GetRaw(ctx)
+	if bz == nil {
+		return 0, &GetSafeError{}
+	}
+	res, err := DecodeInt(bz, v.enc)
+	if err != nil {
+		panic(err)
+	}
+	return res, nil
+}
+
+func (v Integer) Set(ctx Context, value uint64) {
+	v.SetRaw(ctx, EncodeInt(value, v.enc))
+}
+
+func (v Integer) Incr(ctx Context) (res uint64) {
+	res = v.Get(ctx) + 1
+	v.Set(ctx, res)
+	return
+}

store/state/mapping.go

@@ -0,0 +1,55 @@
+package state
+
+type Mapping struct {
+	base       Base
+	start, end []byte
+}
+
+func NewMapping(base Base, prefix []byte) Mapping {
+	return Mapping{
+		base:  base.Prefix(prefix),
+		start: []byte{}, // preventing nil key access in store.Last
+	}
+}
+
+func (m Mapping) store(ctx Context) KVStore {
+	return m.base.store(ctx)
+}
+
+func (m Mapping) Value(key []byte) Value {
+	return NewValue(m.base, key)
+}
+
+func (m Mapping) Get(ctx Context, key []byte, ptr interface{}) {
+	m.Value(key).Get(ctx, ptr)
+}
+
+func (m Mapping) GetSafe(ctx Context, key []byte, ptr interface{}) error {
+	return m.Value(key).GetSafe(ctx, ptr)
+}
+
+func (m Mapping) Set(ctx Context, key []byte, o interface{}) {
+	if o == nil {
+		m.Delete(ctx, key)
+		return
+	}
+	m.Value(key).Set(ctx, o)
+}
+
+func (m Mapping) Has(ctx Context, key []byte) bool {
+	return m.Value(key).Exists(ctx)
+}
+
+func (m Mapping) Delete(ctx Context, key []byte) {
+	m.Value(key).Delete(ctx)
+}
+
+func (m Mapping) IsEmpty(ctx Context) bool {
+	iter := m.store(ctx).Iterator(nil, nil)
+	defer iter.Close()
+	return iter.Valid()
+}
+
+func (m Mapping) Prefix(prefix []byte) Mapping {
+	return NewMapping(m.base, prefix)
+}

store/state/test_common.go

@@ -0,0 +1,58 @@
+package state
+
+import (
+	//	"testing"
+	"math/rand"
+
+	//	"github.com/stretchr/testify/require"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/store"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const testsize = 10
+
+type test interface {
+	test()
+}
+
+type teststruct struct {
+	I  uint64
+	B  bool
+	SL []byte
+}
+
+var _ test = teststruct{}
+
+func (teststruct) test() {}
+
+func newtest() test {
+	var res teststruct
+	res.I = rand.Uint64()
+	res.B = rand.Int()%2 == 0
+	res.SL = make([]byte, 20)
+	rand.Read(res.SL)
+	return res
+}
+
+func defaultComponents() (sdk.StoreKey, Context, *codec.Codec) {
+	key := sdk.NewKVStoreKey("test")
+	db := dbm.NewMemDB()
+	cms := store.NewCommitMultiStore(db)
+	cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db)
+	err := cms.LoadLatestVersion()
+	if err != nil {
+		panic(err)
+	}
+	ctx := sdk.NewContext(cms, abci.Header{}, false, log.NewNopLogger())
+	cdc := codec.New()
+	cdc.RegisterInterface((*test)(nil), nil)
+	cdc.RegisterConcrete(teststruct{}, "test/struct", nil)
+	cdc.Seal()
+	return key, ctx, cdc
+}

store/state/types.go

@@ -0,0 +1,8 @@
+package state
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type KVStore = sdk.KVStore
+type Context = sdk.Context