github.com/cosmos/cosmos-sdk@v0.50.10/runtime/store.go (about)

     1  package runtime
     2  
     3  import (
     4  	"context"
     5  	"io"
     6  
     7  	dbm "github.com/cosmos/cosmos-db"
     8  
     9  	"cosmossdk.io/core/store"
    10  	storetypes "cosmossdk.io/store/types"
    11  
    12  	sdk "github.com/cosmos/cosmos-sdk/types"
    13  )
    14  
    15  func NewKVStoreService(storeKey *storetypes.KVStoreKey) store.KVStoreService {
    16  	return &kvStoreService{key: storeKey}
    17  }
    18  
    19  type kvStoreService struct {
    20  	key *storetypes.KVStoreKey
    21  }
    22  
    23  func (k kvStoreService) OpenKVStore(ctx context.Context) store.KVStore {
    24  	return newKVStore(sdk.UnwrapSDKContext(ctx).KVStore(k.key))
    25  }
    26  
    27  func NewMemStoreService(storeKey *storetypes.MemoryStoreKey) store.MemoryStoreService {
    28  	return &memStoreService{key: storeKey}
    29  }
    30  
    31  type memStoreService struct {
    32  	key *storetypes.MemoryStoreKey
    33  }
    34  
    35  func (m memStoreService) OpenMemoryStore(ctx context.Context) store.KVStore {
    36  	return newKVStore(sdk.UnwrapSDKContext(ctx).KVStore(m.key))
    37  }
    38  
    39  func NewTransientStoreService(storeKey *storetypes.TransientStoreKey) store.TransientStoreService {
    40  	return &transientStoreService{key: storeKey}
    41  }
    42  
    43  type transientStoreService struct {
    44  	key *storetypes.TransientStoreKey
    45  }
    46  
    47  func (t transientStoreService) OpenTransientStore(ctx context.Context) store.KVStore {
    48  	return newKVStore(sdk.UnwrapSDKContext(ctx).KVStore(t.key))
    49  }
    50  
    51  // CoreKVStore is a wrapper of Core/Store kvstore interface
    52  // Remove after https://github.com/cosmos/cosmos-sdk/issues/14714 is closed
    53  type coreKVStore struct {
    54  	kvStore storetypes.KVStore
    55  }
    56  
    57  // NewKVStore returns a wrapper of Core/Store kvstore interface
    58  // Remove once store migrates to core/store kvstore interface
    59  func newKVStore(store storetypes.KVStore) store.KVStore {
    60  	return coreKVStore{kvStore: store}
    61  }
    62  
    63  // Get returns nil iff key doesn't exist. Errors on nil key.
    64  func (store coreKVStore) Get(key []byte) ([]byte, error) {
    65  	return store.kvStore.Get(key), nil
    66  }
    67  
    68  // Has checks if a key exists. Errors on nil key.
    69  func (store coreKVStore) Has(key []byte) (bool, error) {
    70  	return store.kvStore.Has(key), nil
    71  }
    72  
    73  // Set sets the key. Errors on nil key or value.
    74  func (store coreKVStore) Set(key, value []byte) error {
    75  	store.kvStore.Set(key, value)
    76  	return nil
    77  }
    78  
    79  // Delete deletes the key. Errors on nil key.
    80  func (store coreKVStore) Delete(key []byte) error {
    81  	store.kvStore.Delete(key)
    82  	return nil
    83  }
    84  
    85  // Iterator iterates over a domain of keys in ascending order. End is exclusive.
    86  // Start must be less than end, or the Iterator is invalid.
    87  // Iterator must be closed by caller.
    88  // To iterate over entire domain, use store.Iterator(nil, nil)
    89  // CONTRACT: No writes may happen within a domain while an iterator exists over it.
    90  // Exceptionally allowed for cachekv.Store, safe to write in the modules.
    91  func (store coreKVStore) Iterator(start, end []byte) (store.Iterator, error) {
    92  	return store.kvStore.Iterator(start, end), nil
    93  }
    94  
    95  // ReverseIterator iterates over a domain of keys in descending order. End is exclusive.
    96  // Start must be less than end, or the Iterator is invalid.
    97  // Iterator must be closed by caller.
    98  // CONTRACT: No writes may happen within a domain while an iterator exists over it.
    99  // Exceptionally allowed for cachekv.Store, safe to write in the modules.
   100  func (store coreKVStore) ReverseIterator(start, end []byte) (store.Iterator, error) {
   101  	return store.kvStore.ReverseIterator(start, end), nil
   102  }
   103  
   104  // Adapter
   105  var _ storetypes.KVStore = kvStoreAdapter{}
   106  
   107  type kvStoreAdapter struct {
   108  	store store.KVStore
   109  }
   110  
   111  func (kvStoreAdapter) CacheWrap() storetypes.CacheWrap {
   112  	panic("unimplemented")
   113  }
   114  
   115  func (kvStoreAdapter) CacheWrapWithTrace(w io.Writer, tc storetypes.TraceContext) storetypes.CacheWrap {
   116  	panic("unimplemented")
   117  }
   118  
   119  func (kvStoreAdapter) GetStoreType() storetypes.StoreType {
   120  	panic("unimplemented")
   121  }
   122  
   123  func (s kvStoreAdapter) Delete(key []byte) {
   124  	err := s.store.Delete(key)
   125  	if err != nil {
   126  		panic(err)
   127  	}
   128  }
   129  
   130  func (s kvStoreAdapter) Get(key []byte) []byte {
   131  	bz, err := s.store.Get(key)
   132  	if err != nil {
   133  		panic(err)
   134  	}
   135  	return bz
   136  }
   137  
   138  func (s kvStoreAdapter) Has(key []byte) bool {
   139  	has, err := s.store.Has(key)
   140  	if err != nil {
   141  		panic(err)
   142  	}
   143  	return has
   144  }
   145  
   146  func (s kvStoreAdapter) Set(key, value []byte) {
   147  	err := s.store.Set(key, value)
   148  	if err != nil {
   149  		panic(err)
   150  	}
   151  }
   152  
   153  func (s kvStoreAdapter) Iterator(start, end []byte) dbm.Iterator {
   154  	it, err := s.store.Iterator(start, end)
   155  	if err != nil {
   156  		panic(err)
   157  	}
   158  	return it
   159  }
   160  
   161  func (s kvStoreAdapter) ReverseIterator(start, end []byte) dbm.Iterator {
   162  	it, err := s.store.ReverseIterator(start, end)
   163  	if err != nil {
   164  		panic(err)
   165  	}
   166  	return it
   167  }
   168  
   169  func KVStoreAdapter(store store.KVStore) storetypes.KVStore {
   170  	return &kvStoreAdapter{store}
   171  }