store

type AggregateFn[R Row] = func(arena *Arena[R], agg *Value[R], val *Value[R]) *Value[R]

type AllOf[R Row] struct {
	Source []Operation[R]
	Value  ExecuteFn[R, Composite[R]]
}

type AllOfExecutor[R Row] interface {
	ExecuteAllOf(*Arena[R], AllOf[R]) (Result[R], bool)
}

type Allocator[V any] interface {
	New() *V
	Slice(int) []V
	Append(s []V, v ...V) []V
	// contains filtered or unexported methods
}

type AnyOf[R Row] []Operation[R]

type Arena[R Row] struct {
	// contains filtered or unexported fields
}

type Column[R Row, V any] interface {
	Get(R) (V, bool)
	GetAll(R) ([]V, bool)
	Set(R, V)
	Clear(R)
	ClearAll(R)
	Slot(int) Column[R, V]
	All() Iterator2[R, V]
	AllSlots() Iterator2[R, V]

	// Delete the whole column (including slots).
	Delete()
}

type Composite[R Row] interface {
	Set(int, *Value[R])
	AsValue(*Arena[R]) *Value[R]
}

type Const[R Row] struct {
	Value *Value[R]
}

type EmptyColumn[R Row, V any] struct{}

type EmptyCursor[R Row, V any] struct{}

type EmptyIterator[V any] struct{}

type EmptyIterator2[U, V any] struct{}

type EmptyResult[R Row] struct{}

type ExecuteFn[R Row, V any] = func(*Arena[R]) V

type GroupBy[R Row, K cmp.Ordered] struct {
	Source    Operation[R]
	Key       ExecuteFn[R, KeyFn[R, K]]
	Aggregate ExecuteFn[R, AggregateFn[R]]
}

type Iterator[V any] interface {
	Next() (V, bool)
	Stop()
}

type Iterator2[U, V any] interface {
	Next() (U, V, bool)
	Stop()
}

type Join[R Row] struct {
	Left, Right Operation[R]
	Join        ExecuteFn[R, JoinFn[R]]
}

type JoinFn[R Row] = func(arena *Arena[R], left, right *Value[R]) (*Value[R], bool)

type KeyFn[R Row, K any] = func(*Arena[R], *Value[R]) K

type Marshaller interface {
	cate.Marshaller
	cate.Unmarshaller
}

type Maybe[V any] struct {
	Value V
	Ok    bool
}

type None struct{}

type Operation[R Row] interface {
	Execute(*Arena[R], Store[R]) Result[R]
}

type Persister[R Row] interface {
	Persist(R, Store[R], WritableFS) error
	Restore(R, Store[R], WritableFS) error
}

type Read[R Row] struct {
	Type    reflect.Type
	Slot    int
	Default ExecuteFn[R, *Value[R]]
}

type ReadAll[R Row] struct {
	Type reflect.Type
}

type ReadExecutor[R Row] interface {
	ExecuteRead(*Arena[R], Read[R]) (Result[R], bool)
}

type Result[R Row] interface {
	Next(*Arena[R]) (*Value[R], bool)
	Stop()
}

type Row interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

type RowCursor[R Row] struct {
	// contains filtered or unexported fields
}

type RowManager[R Row] interface {
	ManagedRows(R, Store[R]) RowSet[R]
}

type RowSet[R Row] struct {
	// contains filtered or unexported fields
}

type Select[R Row] struct {
	Source Operation[R]
	Select ExecuteFn[R, SelectFn[R]]
}

type SelectFn[R Row] = func(*Arena[R], *Value[R]) (*Value[R], bool)

type SimpleValueSet[R Row, V any] struct {
	// contains filtered or unexported fields
}

type SingleValueIterator[V any] struct {
	Value V
	Ok    bool
}

type SliceIterator[V any] []V

type Store[R Row] interface {
	// For creates a new store scoped to the given rows.
	For(RowSet[R]) Store[R]

	// Rows returns the set of all populated rows. Rows is optimistic - the
	// presence of a row in the row set does not guarantee that row is
	// present in any column.
	Rows() RowSet[R]

	// Row iterates over the attributes of a row.
	Row(R) Iterator2[reflect.Type, any]

	// HasRow returns true if any column contains an entry for the given
	// row.
	HasRow(row R) bool

	// Columns iterates over all populated columns.
	Columns() Iterator[reflect.Type]

	// Column returns a specific column.
	Column(reflect.Type) Column[R, any]
}

type Value[R Row] struct {
	// contains filtered or unexported fields
}

type ValueKind int

type Without[R Row] struct {
	Source Operation[R]
}

type WritableFS interface {
	fs.FS
	Subdir(string) (WritableFS, error)
	Create(string) (WritableFile, error)
}

type WritableFile interface {
	fs.File
	io.Writer
}