Add store package

database/store/cosmos.go

@@ -0,0 +1,74 @@
+package store
+
+import (
+	"github.com/cosmos/cosmos-sdk/types"
+)
+
+// CosmosStore
+type CosmosStore struct {
+	store types.KVStore
+}
+
+func NewCosmosStore(store types.KVStore) *CosmosStore {
+	return &CosmosStore{
+		store: store,
+	}
+}
+
+func (s *CosmosStore) NewIterator() Iterator {
+	return NewCosmosIterator(types.KVStorePrefixIterator(s.store, nil))
+}
+
+func (s *CosmosStore) Has(key []byte) (bool, error) {
+	return s.store.Has(key), nil
+}
+
+func (s *CosmosStore) Get(key []byte) ([]byte, error) {
+	return s.store.Get(key), nil
+}
+
+func (s *CosmosStore) Delete(key []byte) error {
+	s.store.Delete(key)
+	return nil
+}
+
+func (s *CosmosStore) Put(key []byte, value []byte) error {
+	s.store.Set(key, value)
+	return nil
+}
+
+func (s *CosmosStore) Close() error {
+	return nil
+}
+
+// CosmosIterator
+type CosmosIterator struct {
+	iter types.Iterator
+}
+
+func NewCosmosIterator(iter types.Iterator) *CosmosIterator {
+	return &CosmosIterator{
+		iter: iter,
+	}
+}
+
+func (i *CosmosIterator) Next() bool {
+	i.iter.Next()
+	return i.iter.Valid()
+}
+
+func (i *CosmosIterator) Key() []byte {
+	return i.iter.Key()
+}
+
+func (i *CosmosIterator) Value() []byte {
+	return i.iter.Value()
+}
+
+func (i *CosmosIterator) Release() {
+	i.iter.Close()
+}
+
+func (i *CosmosIterator) Error() error {
+	return nil
+}

database/store/interface.go

@@ -0,0 +1,20 @@
+package store
+
+// Store describes the store's API of Services.
+type Store interface {
+	Get(key []byte) ([]byte, error)
+	Has(key []byte) (bool, error)
+	Delete(key []byte) error
+	Put(key []byte, value []byte) error
+	NewIterator() Iterator
+	Close() error
+}
+
+// Iterator
+type Iterator interface {
+	Next() bool
+	Key() []byte
+	Value() []byte
+	Release()
+	Error() error
+}

database/store/leveldb.go

@@ -0,0 +1,82 @@
+package store
+
+import (
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+)
+
+// LevelDBStore
+type LevelDBStore struct {
+	db *leveldb.DB
+}
+
+func NewLevelDBStore(path string) (*LevelDBStore, error) {
+	db, err := leveldb.OpenFile(path, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LevelDBStore{
+		db: db,
+	}, nil
+}
+
+func (s *LevelDBStore) NewIterator() Iterator {
+	return NewLevelDBIterator(s.db.NewIterator(nil, nil))
+}
+
+func (s *LevelDBStore) Has(key []byte) (bool, error) {
+	if _, err := s.db.Get(key, nil); err != nil {
+		if err == leveldb.ErrNotFound {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
+func (s *LevelDBStore) Get(key []byte) ([]byte, error) {
+	return s.db.Get(key, nil)
+}
+
+func (s *LevelDBStore) Delete(key []byte) error {
+	return s.db.Delete(key, nil)
+}
+
+func (s *LevelDBStore) Put(key []byte, value []byte) error {
+	return s.db.Put(key, value, nil)
+}
+
+func (s *LevelDBStore) Close() error {
+	return s.db.Close()
+}
+
+// LevelDBIterator
+type LevelDBIterator struct {
+	iter iterator.Iterator
+}
+
+func NewLevelDBIterator(iter iterator.Iterator) *LevelDBIterator {
+	return &LevelDBIterator{
+		iter: iter,
+	}
+}
+
+func (i *LevelDBIterator) Next() bool {
+	return i.iter.Next()
+}
+
+func (i *LevelDBIterator) Key() []byte {
+	return i.iter.Key()
+}
+
+func (i *LevelDBIterator) Value() []byte {
+	return i.iter.Value()
+}
+
+func (i *LevelDBIterator) Release() {
+	i.iter.Release()
+}
+
+func (i *LevelDBIterator) Error() error {
+	return i.iter.Error()
+}