1 files changed, 16 insertions, 66 deletions
diff --git a/vendor/codeberg.org/gruf/go-store/kv/state.go b/vendor/codeberg.org/gruf/go-store/kv/state.go
index 330928bce..0b226e107 100644
--- a/vendor/codeberg.org/gruf/go-store/kv/state.go
+++ b/vendor/codeberg.org/gruf/go-store/kv/state.go
@@ -2,9 +2,9 @@ package kv
 
 import (
 	"io"
-	"sync"
 
 	"codeberg.org/gruf/go-errors"
+	"codeberg.org/gruf/go-mutexes"
 )
 
 var ErrStateClosed = errors.New("store/kv: state closed")
@@ -16,61 +16,42 @@ var ErrStateClosed = errors.New("store/kv: state closed")
 // then the state has zero guarantees
 type StateRO struct {
 	store *KVStore
-	mutex sync.RWMutex
+	state *mutexes.LockState
 }
 
 func (st *StateRO) Get(key string) ([]byte, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return nil, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.get(st.store.mutexMap.RLock, key)
+	return st.store.get(st.state.RLock, key)
 }
 
 func (st *StateRO) GetStream(key string) (io.ReadCloser, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return nil, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.getStream(st.store.mutexMap.RLock, key)
+	return st.store.getStream(st.state.RLock, key)
 }
 
 func (st *StateRO) Has(key string) (bool, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return false, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.has(st.store.mutexMap.RLock, key)
+	return st.store.has(st.state.RLock, key)
 }
 
 func (st *StateRO) Release() {
-	// Get state write lock
-	st.mutex.Lock()
-	defer st.mutex.Unlock()
-
-	// Release the store
-	if st.store != nil {
-		st.store.mutex.RUnlock()
-		st.store = nil
-	}
+	st.state.UnlockMap()
+	st.store = nil
 }
 
 // StateRW provides a read-write window to the store. While this
@@ -80,101 +61,70 @@ func (st *StateRO) Release() {
 // then the state has zero guarantees
 type StateRW struct {
 	store *KVStore
-	mutex sync.RWMutex
+	state *mutexes.LockState
 }
 
 func (st *StateRW) Get(key string) ([]byte, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return nil, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.get(st.store.mutexMap.RLock, key)
+	return st.store.get(st.state.RLock, key)
 }
 
 func (st *StateRW) GetStream(key string) (io.ReadCloser, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return nil, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.getStream(st.store.mutexMap.RLock, key)
+	return st.store.getStream(st.state.RLock, key)
 }
 
 func (st *StateRW) Put(key string, value []byte) error {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.put(st.store.mutexMap.Lock, key, value)
+	return st.store.put(st.state.Lock, key, value)
 }
 
 func (st *StateRW) PutStream(key string, r io.Reader) error {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.putStream(st.store.mutexMap.Lock, key, r)
+	return st.store.putStream(st.state.Lock, key, r)
 }
 
 func (st *StateRW) Has(key string) (bool, error) {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return false, ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.has(st.store.mutexMap.RLock, key)
+	return st.store.has(st.state.RLock, key)
 }
 
 func (st *StateRW) Delete(key string) error {
-	// Get state read lock
-	st.mutex.RLock()
-	defer st.mutex.RUnlock()
-
 	// Check not closed
 	if st.store == nil {
 		return ErrStateClosed
 	}
 
 	// Pass request to store
-	return st.store.delete(st.store.mutexMap.Lock, key)
+	return st.store.delete(st.state.Lock, key)
 }
 
 func (st *StateRW) Release() {
-	// Get state write lock
-	st.mutex.Lock()
-	defer st.mutex.Unlock()
-
-	// Release the store
-	if st.store != nil {
-		st.store.mutex.Unlock()
-		st.store = nil
-	}
+	st.state.UnlockMap()
+	st.store = nil
 }