github.com/Finschia/finschia-sdk@v0.48.1/store/dbadapter/store.go (about)

     1  package dbadapter
     2  
     3  import (
     4  	"io"
     5  
     6  	dbm "github.com/tendermint/tm-db"
     7  
     8  	"github.com/Finschia/finschia-sdk/store/cachekv"
     9  	"github.com/Finschia/finschia-sdk/store/listenkv"
    10  	"github.com/Finschia/finschia-sdk/store/tracekv"
    11  	"github.com/Finschia/finschia-sdk/store/types"
    12  )
    13  
    14  // Wrapper type for dbm.DB with implementation of KVStore
    15  type Store struct {
    16  	dbm.DB
    17  }
    18  
    19  // Get wraps the underlying DB's Get method panicing on error.
    20  func (dsa Store) Get(key []byte) []byte {
    21  	v, err := dsa.DB.Get(key)
    22  	if err != nil {
    23  		panic(err)
    24  	}
    25  
    26  	return v
    27  }
    28  
    29  // Has wraps the underlying DB's Has method panicing on error.
    30  func (dsa Store) Has(key []byte) bool {
    31  	ok, err := dsa.DB.Has(key)
    32  	if err != nil {
    33  		panic(err)
    34  	}
    35  
    36  	return ok
    37  }
    38  
    39  // Set wraps the underlying DB's Set method panicing on error.
    40  func (dsa Store) Set(key, value []byte) {
    41  	types.AssertValidKey(key)
    42  	if err := dsa.DB.Set(key, value); err != nil {
    43  		panic(err)
    44  	}
    45  }
    46  
    47  // Delete wraps the underlying DB's Delete method panicing on error.
    48  func (dsa Store) Delete(key []byte) {
    49  	if err := dsa.DB.Delete(key); err != nil {
    50  		panic(err)
    51  	}
    52  }
    53  
    54  // Iterator wraps the underlying DB's Iterator method panicing on error.
    55  func (dsa Store) Iterator(start, end []byte) types.Iterator {
    56  	iter, err := dsa.DB.Iterator(start, end)
    57  	if err != nil {
    58  		panic(err)
    59  	}
    60  
    61  	return iter
    62  }
    63  
    64  // ReverseIterator wraps the underlying DB's ReverseIterator method panicing on error.
    65  func (dsa Store) ReverseIterator(start, end []byte) types.Iterator {
    66  	iter, err := dsa.DB.ReverseIterator(start, end)
    67  	if err != nil {
    68  		panic(err)
    69  	}
    70  
    71  	return iter
    72  }
    73  
    74  // GetStoreType returns the type of the store.
    75  func (Store) GetStoreType() types.StoreType {
    76  	return types.StoreTypeDB
    77  }
    78  
    79  // CacheWrap branches the underlying store.
    80  func (dsa Store) CacheWrap() types.CacheWrap {
    81  	return cachekv.NewStore(dsa)
    82  }
    83  
    84  // CacheWrapWithTrace implements KVStore.
    85  func (dsa Store) CacheWrapWithTrace(w io.Writer, tc types.TraceContext) types.CacheWrap {
    86  	return cachekv.NewStore(tracekv.NewStore(dsa, w, tc))
    87  }
    88  
    89  // CacheWrapWithListeners implements the CacheWrapper interface.
    90  func (dsa Store) CacheWrapWithListeners(storeKey types.StoreKey, listeners []types.WriteListener) types.CacheWrap {
    91  	return cachekv.NewStore(listenkv.NewStore(dsa, storeKey, listeners))
    92  }
    93  
    94  // dbm.DB implements KVStore so we can CacheKVStore it.
    95  var _ types.KVStore = Store{}