sorted

type BatchMutation interface {
	Set(key, value string)
	Delete(key string)
}

type Entry struct {
	Key, Value string
}

type Iterator interface {
	// Next moves the iterator to the next key/value pair.
	// It returns false when the iterator is exhausted.
	Next() bool

	// Key returns the key of the current key/value pair.
	// Only valid after a call to Next returns true.
	Key() string

	// KeyBytes returns the key as bytes. The returned bytes
	// should not be written and are invalid after the next call
	// to Next or Close.
	// TODO(bradfitz): rename this and change it to return a
	// mem.RO instead?
	KeyBytes() []byte

	// Value returns the value of the current key/value pair.
	// Only valid after a call to Next returns true.
	Value() string

	// ValueBytes returns the value as bytes. The returned bytes
	// should not be written and are invalid after the next call
	// to Next or Close.
	// TODO(bradfitz): rename this and change it to return a
	// mem.RO instead?
	ValueBytes() []byte

	// Close closes the iterator and returns any accumulated error. Exhausting
	// all the key/value pairs in a table is not considered to be an error.
	// It is valid to call Close multiple times. Other methods should not be
	// called after the iterator has been closed.
	Close() error
}

type KeyValue interface {
	// Get gets the value for the given key. It returns ErrNotFound if the DB
	// does not contain the key.
	Get(key string) (string, error)

	Set(key, value string) error

	// Delete deletes keys. Deleting a non-existent key does not return an error.
	Delete(key string) error

	BeginBatch() BatchMutation
	CommitBatch(b BatchMutation) error

	// Find returns an iterator positioned before the first key/value pair
	// whose key is 'greater than or equal to' the given key. There may be no
	// such pair, in which case the iterator will return false on Next.
	//
	// The optional end value specifies the exclusive upper
	// bound. If the empty string, the iterator returns keys
	// where "key >= start".
	// If non-empty, the iterator returns keys where
	// "key >= start && key < endHint".
	//
	// Any error encountered will be implicitly returned via the iterator. An
	// error-iterator will yield no key/value pairs and closing that iterator
	// will return that error.
	//
	// An iterator may or may not observe writes made after Find returns;
	// implementations differ. Callers needing a consistent view across
	// several reads should use TransactionalReader, if implemented.
	Find(start, end string) Iterator

	// Close is a polite way for the server to shut down the storage.
	// Implementations should never lose data after a Set, Delete,
	// or CommmitBatch, though.
	Close() error
}

type Mutation interface {
	Key() string
	Value() string
	IsDelete() bool
}

type NeedWipeError struct {
	Msg string
}

type ReadTransaction interface {
	Get(key string) (string, error)
	Find(start, end string) Iterator

	// End the transaction.
	Close() error
}

type ReindexSession interface {
	KeyValue

	// Finish(true) durably commits all remaining writes and marks the index
	// complete, returning any previously encountered storage error as well.
	// Finish(false), or Close, aborts the pending group and leaves the index
	// marked incomplete; earlier committed groups may remain. In either
	// case Finish releases the session's resources, not the underlying KV.
	// A failed build's Index and caches must be discarded, not reused.
	Finish(success bool) error
}

type Reindexer interface {
	KeyValue

	// BeginReindex atomically discards the old rows and durably marks the
	// index incomplete. No other access to this storage is allowed until
	// the returned session is finished. An interrupted build must not be
	// accepted on an ordinary reopen; it requires another reindex or Wipe.
	BeginReindex() (ReindexSession, error)
}

type TransactionalReader interface {
	KeyValue

	// BeginReadTx begins a read-only transaction.
	BeginReadTx() ReadTransaction
}

type Wiper interface {
	KeyValue

	// Wipe removes all key/value pairs, and resets the storage to a blank state.
	// For a given storage, when NewKeyValue returns a NeedWipeError, Wipe
	// should be implemented so that it fixes the returned KeyValue.
	Wipe() error
}