storage

type Batch interface {
	// Put adds a new item to the batch.
	Put(Item) error

	// Delete adds a new delete operation to the batch.
	Delete(Item) error

	// Commit commits the batch.
	Commit() error
}

type Batcher interface {
	// Batch returns a new Batch.
	Batch(context.Context) (Batch, error)
}

type ChunkGetterDeleter interface {
	Getter
	Deleter
}

type ChunkState = int

type ChunkStore interface {
	io.Closer
	Getter
	Putter
	Deleter
	Hasser

	// Iterate over chunks in no particular order.
	Iterate(context.Context, IterateChunkFn) error
}

type Cloner interface {
	Clone() Item
}

type Deleter interface {
	// Delete a chunk by the given swarm.Address.
	Delete(context.Context, swarm.Address) error
}

type Descriptor struct {
	Address swarm.Address
	BinID   uint64
}

type Filter func(string, []byte) bool

type Getter interface {
	// Get a chunk by its swarm.Address. Returns the chunk associated with
	// the address alongside with its postage stamp, or a storage.ErrNotFound
	// if the chunk is not found.
	// If the chunk has multiple stamps, then the first stamp is returned in this
	// query. In order to deterministically get the stamp, use the GetterWithStamp
	// interface. If the chunk is not found storage.ErrNotFound will be returned.
	Get(context.Context, swarm.Address) (swarm.Chunk, error)
}

type GetterFunc func(context.Context, swarm.Address) (swarm.Chunk, error)

type Hasser interface {
	// Has checks whether a chunk exists in the store.
	Has(context.Context, swarm.Address) (bool, error)
}

type InMemTxRevertOpStore[K, V any] struct {
	// contains filtered or unexported fields
}

type Item interface {
	Key
	Marshaler
	Unmarshaler
	Cloner
	fmt.Stringer
}

type IterateChunkFn func(swarm.Chunk) (stop bool, err error)

type IterateFn func(Result) (bool, error)

type Key interface {
	// ID is the unique identifier of Item.
	ID() string

	// Namespace is used to separate similar items.
	// E.g.: can be seen as a table construct.
	Namespace() string
}

type Marshaler interface {
	Marshal() ([]byte, error)
}

type NoOpTxRevertOpStore[K, V any] struct{}

type Order int

type PullSubscriber interface {
	SubscribePull(ctx context.Context, bin uint8, since, until uint64) (c <-chan Descriptor, closed <-chan struct{}, stop func())
}

type PushReporter interface {
	Report(context.Context, swarm.Chunk, ChunkState) error
}

type PushSubscriber interface {
	SubscribePush(ctx context.Context) (c <-chan swarm.Chunk, stop func())
}

type Putter interface {
	// Put a chunk into the store alongside with its postage stamp.
	Put(context.Context, swarm.Chunk) error
}

type PutterFunc func(context.Context, swarm.Chunk) error

type Query struct {
	// Factory is a constructor passed by client
	// to construct new object for the result.
	Factory func() Item

	// Prefix indicates interest in an item
	// that contains this prefix in its ID.
	Prefix string

	// PrefixAtStart indicates that the
	// iteration should start at the prefix.
	PrefixAtStart bool

	// SkipFirst skips the first element in the iteration.
	SkipFirst bool

	// ItemProperty indicates a specific interest of an Item property.
	ItemProperty QueryItemProperty

	// Order denotes the order of iteration.
	Order Order

	// Filters represent further constraints on the iteration.
	Filters []Filter
}

type QueryItemProperty int

type ReadOnlyChunkStore interface {
	Getter
	Hasser
}

type Recoverer interface {
	Recover() error
}

type Repository interface {
	IndexStore() Store
	ChunkStore() ChunkStore

	NewTx(context.Context) (repo Repository, commit func() error, rollback func() error)
}

type Result struct {
	// ID is the Key.ID of the result Item.
	ID string

	// Size is the size of the result Item.
	Size int

	// Entry in the result Item.
	Entry Item
}

type SizeReporter interface {
	Size() (uint64, error)
	Capacity() uint64
}

type StateIterFunc func(key, val []byte) (stop bool, err error)

type StateStorer interface {
	io.Closer

	// Get unmarshalls object with the given key into the given obj.
	Get(key string, obj interface{}) error

	// Put inserts or updates the given obj stored under the given key.
	Put(key string, obj interface{}) error

	// Delete removes object form the store stored under the given key.
	Delete(key string) error

	// Iterate iterates over all keys with the given prefix and calls iterFunc.
	Iterate(prefix string, iterFunc StateIterFunc) error
}

type StateStorerCleaner interface {
	// Nuke the store so that only the bare essential entries are left.
	Nuke() error
}

type Store interface {
	io.Closer

	// Get unmarshalls object with the given Item.Key.ID into the given Item.
	Get(Item) error

	// Has reports whether the Item with the given Key.ID exists in the store.
	Has(Key) (bool, error)

	// GetSize returns the size of Item with the given Key.ID.
	GetSize(Key) (int, error)

	// Iterate executes the given IterateFn on this store.
	// The Result of the iteration will be affected by the given Query.
	Iterate(Query, IterateFn) error

	// Count returns the count of items in the
	// store that are in the same Key.Namespace.
	Count(Key) (int, error)

	// Put inserts or updates the given Item identified by its Key.ID.
	Put(Item) error

	// Delete removes the given Item form the store.
	// It will not return error if the key doesn't exist.
	Delete(Item) error
}

type Tx interface {
	// Commit commits the transaction.
	Commit() error

	// Rollback aborts the transaction.
	Rollback() error
}

type TxChunkStore interface {
	Tx
	ChunkStore

	NewTx(*TxState) TxChunkStore
}

type TxChunkStoreBase struct {
	*TxState
	ChunkStore
	// contains filtered or unexported fields
}

type TxOpCode string

type TxRevertFn[K, V any] func(K, V) error

type TxRevertOp[K, V any] struct {
	Origin   TxOpCode
	ObjectID string

	Key K
	Val V
}

type TxRevertOpStore[K, V any] interface {
	// Append appends a Revert operation to the store.
	Append(*TxRevertOp[K, V]) error
	// Revert executes all the revere operations
	// in the store in reverse order.
	Revert() error
	// Clean cleans the store.
	Clean() error
}

type TxState struct {
	// contains filtered or unexported fields
}

type TxStore interface {
	Tx
	Store

	NewTx(*TxState) TxStore
}

type TxStoreBase struct {
	*TxState
	Store
	// contains filtered or unexported fields
}

type Unmarshaler interface {
	Unmarshal([]byte) error
}