db

type Batch interface {
	KeyValueWriter
	BatchWriter

	// ValueSize retrieves the amount of data queued up for writing.
	ValueSize() int

	// Reset resets the batch for reuse.
	Reset()

	// Replay replays the batch contents.
	Replay(w KeyValueWriter) error
}

type BatchWithID struct {
	ID int32
	B  BatchWriter
}

type BatchWriter interface {
	// Write flushes any accumulated data to disk.
	Write() error
	// Load loads given slice into the batch.
	Load(data []byte) error
	// Dump dumps the batch into a byte slice.
	Dump() []byte
}

type Batcher interface {
	// NewBatch creates a write-only database that buffers changes to its host db
	// until a final write is called.
	NewBatch() Batch

	// NewBatchWithSize creates a write-only database batch with pre-allocated buffer.
	NewBatchWithSize(size int) Batch
}

type Compacter interface {
	// Compact flattens the underlying data store for the given key range. In essence,
	// deleted and overwritten versions are discarded, and the data is rearranged to
	// reduce the cost of operations needed to access them.
	//
	// A nil start is treated as a key before all keys in the data store; a nil limit
	// is treated as a key after all keys in the data store. If both is nil then it
	// will compact entire data store.
	Compact(start []byte, limit []byte) error
}

type DB interface {
	KeyValueReader
	KeyValueWriter
	KeyValueStater
	Batcher
	Snapshotter
	Compacter
	Iteratee
	io.Closer
}

type DBPool struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Iteratee interface {
	// NewIterator creates a binary-alphabetical iterator over a subset
	// of database content with a particular key prefix, starting at a particular
	// initial key (or after, if it does not exist).
	//
	// Note: This method assumes that the prefix is NOT part of the start, so there's
	// no need for the caller to prepend the prefix to the start
	NewIterator(prefix []byte, start []byte) Iterator

	// NewIteratorWithRange creates an iterator over a domain of keys in ascending order. The caller must call
	NewIteratorWithRange(start []byte, limit []byte) (Iterator, error)
}

type Iterator interface {
	Next() bool

	// Error returns any accumulated error. Exhausting all the key/value pairs
	// is not considered to be an error.
	Error() error

	// Key returns the key of the current key/value pair, or nil if done. The caller
	// should not modify the contents of the returned slice, and its contents may
	// change on the next call to Next.
	Key() []byte

	// Value returns the value of the current key/value pair, or nil if done. The
	// caller should not modify the contents of the returned slice, and its contents
	// may change on the next call to Next.
	Value() []byte

	// Release releases associated resources. Release should always succeed and can
	// be called multiple times without causing error.
	Release()
}

type KeyValueReader interface {
	// Has retrieves if a key is present in the key-value data store.
	Has(key []byte) (bool, error)

	// Get retrieves the given key if it's present in the key-value data store.
	Get(key []byte) ([]byte, error)
}

type KeyValueStater interface {
	// Stat returns a particular internal stat of the database.
	Stat(property string) (string, error)

	// Stats returns a map of property values for all keys and the size of the cache.
	Stats() (map[string]string, error)
}

type KeyValueWriter interface {
	// Put inserts the given value into the key-value data store.
	Put(key []byte, value []byte) error

	// Delete removes the key from the key-value data store.
	Delete(key []byte) error
}

type LBatch struct {
	DB    *LDB
	Batch *leveldb.Batch
	// contains filtered or unexported fields
}

type LDB struct {
	Id int32
	DB *leveldb.DB
}

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

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

type Replayer struct {
	Writer  KeyValueWriter
	Failure error
}

type Snapshot interface {
	KeyValueReader

	// Release releases associated resources. Release should always succeed and can
	// be called multiple times without causing error.
	Release()
}

type Snapshotter interface {
	// NewSnapshot creates a database snapshot based on the current state.
	// The created snapshot will not be affected by all following mutations
	// happened on the database.
	// Note don't forget to release the snapshot once it's used up, otherwise
	// the stale data will never be cleaned up by the underlying compactor.
	NewSnapshot() (Snapshot, error)
}