common

type BlockKind byte

type BoundaryKind uint8

type BufferPoolFetcher struct {
	Fetcher
	// contains filtered or unexported fields
}

type ChecksumType byte

type DefaultComparer struct{}

type DiskfileNum int64

type Fetcher interface {
	Load() []byte
	// Release freed associated resources. Release should always success
	// and can be called multiple times without causing error.
	Release()
}

type IChecksum interface {
	Checksum(block []byte, auxiliary byte) uint32
}

type IComparer interface {
	// Compare returns -1, 0, or +1 depending on whether a is 'less than', 'equal
	// to' or 'greater than' b.
	//
	// A key a is less than b if a's prefix is byte-wise less than b's prefix, or if
	// the prefixes are equal and a's suffix is less than b's suffix
	Compare(a, b []byte) int

	// Separator returns a sequence of bytes x such that a <= x && x < b,
	// where 'less than' is consistent with Compare.
	// Trivial implementation is just simply returns "a", however we try to return
	// a shorter "x" to reduce the SSTable size
	//
	// Use case: Use for creating an index key that separate 2 blocks
	Separator(a, b []byte) []byte

	// Successor returns a sequence of bytes x such that x >= b, where
	// 'less than' is consistent with Compare.
	// Trivial implementation is just simply return "b", however we try to return
	// a shorter "x" to reduce the SSTable size
	//
	// Use case: Use to create an index key of the last block in a SSTable
	Successor(b []byte) []byte

	// Split return the prefix of a given key
	//
	// Use case: Uses to separate the actual user key and MVCC id
	// in the internalKey.UserKey
	Split(b []byte) int

	// Name of the comparer will be persisted within the Manifest
	Name() string

	// AbbreviatedKey returns a fixed length prefix of a user key such that
	//
	//	AbbreviatedKey(a) < AbbreviatedKey(b) implies a < b, and
	//	AbbreviatedKey(a) > AbbreviatedKey(b) implies a > b.
	//
	// If AbbreviatedKey(a) == AbbreviatedKey(b), an additional comparison is
	// required to determine if the two keys are actually equal.
	//
	// This helps optimize indexed batch comparisons for cache locality. If a Split
	// function is specified, AbbreviatedKey usually returns the first eight bytes
	// of the user key prefix in the order that gives the correct ordering.
	AbbreviatedKey(key []byte) []byte
}

type InternalIterator[T any] interface {
	InternalSeeker[T]

	// First moves the iterator the first key/value pair.
	First() *T

	// Last moves the iterator the last key/value pair.
	Last() *T

	// Next moves the iterator to the next key/value pair
	Next() *T

	// Prev moves the iterator to the previous key/value pair.
	Prev() *T

	// 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.
	Close() error
	IsClosed() bool
}

type InternalKV struct {
	K InternalKey
	V InternalLazyValue
}

type InternalKey struct {
	UserKey []byte
	Trailer InternalKeyTrailer
}

type InternalKeyTrailer uint64

type InternalLazyValue struct {
	ValueSource   ValueSource
	BufferFetcher *BufferPoolFetcher
	CacheFetcher  Fetcher
}

type InternalSeeker[T any] interface {
	// SeekGTE moves the iterator to the first key/value pair whose key ≥ to the given key.
	SeekGTE(key []byte) *T

	// SeekPrefixGTE moves the iterator to the first key/value pair whose key >= to the given key.
	// that has the defined prefix for faster looking up
	SeekPrefixGTE(prefix, key []byte) *T

	// SeekLTE moves the iterator to the last key/value pair whose key ≤ to the given key.
	SeekLTE(key []byte) *T
}

type InternalWriter interface {
	// Add adds a key-value pair to the sstable.
	Add(key InternalKey, value []byte) error
	// Close finishes writing the table and closes the underlying file that the table was written to.
	Close() error
}

type KeyKind byte

type Logger interface {
	Infof(format string, args ...any)
	Errorf(format string, args ...any)
	Fatalf(format string, args ...any)
}

type ObjectType byte

type SeqNum uint64

type UserKeyBound struct {
	Start []byte
	End   UserKeyBoundary
}

type UserKeyBoundary struct {
	Key  []byte
	Kind BoundaryKind
}

type ValueSource byte