table

type AccessError struct {
	Index      int
	UpperBound int
}

type Accessor[T any] struct {
	// contains filtered or unexported fields
}

type BatchDeletionError struct {
	BatchOperationError
	Capacity int
}

type BatchOperationError struct {
	Count int
}

type DefaultTableEvents struct{}

type ElementType interface {
	ID() ElementTypeID
	Type() reflect.Type
	Size() uint32
}

type ElementTypeID uint32

type Entry interface {
	ID() EntryID
	Recycled() int
	Index() int
	Table() Table
}

type EntryID uint32

type EntryIndex interface {
	Entry(idx int) (Entry, error)
	NewEntries(count, previousTableLength int, tbl Table) ([]Entry, error)
	UpdateIndex(EntryID, int) error
	RecycleEntries(...EntryID) error
	Reset() error
	Entries() []Entry
	Recyclable() []Entry
}

type InvalidElementAccessError struct {
	ElementType       ElementType
	ValidElementTypes []ElementType
}

type InvalidEntryAccessError struct{}

type LockedAccessor[T any] struct {
	// contains filtered or unexported fields
}

type MaskComparer interface {
	ContainsAll(mask.Mask) bool
	ContainsAny(mask.Mask) bool
	ContainsNone(mask.Mask) bool
}

type Row reflect.Value

type RowIndex uint32

type Schema interface {
	Register(...ElementType)
	Registered() int
	Contains(ElementType) bool
	ContainsAll(...ElementType) bool
	RowIndexFor(ElementType) uint32
	RowIndexForID(ElementTypeID) uint32
}

type Table interface {
	TableReader
	TableWriter
	TableQuerier
	TableIterator
}

type TableBuilder interface {
	WithSchema(Schema) TableBuilder
	WithEntryIndex(EntryIndex) TableBuilder
	WithElementTypes(...ElementType) TableBuilder
	WithEvents(TableEvents) TableBuilder
	Build() (Table, error)
}

type TableEvents interface {
	OnBeforeEntriesCreated(count int) error
	OnAfterEntriesCreated(entries []Entry)
	OnBeforeEntriesDeleted(indices []int) error
	OnAfterEntriesDeleted(ids []EntryID)
}

type TableFactory interface {
	NewEntryIndex() EntryIndex
	// contains filtered or unexported methods
}

type TableInstantiationNilElementTypesError struct{}

type TableInstantiationNilSchemaError struct{}

type TableIterator interface {
	Rows() iter.Seq2[int, Row]
	ElementTypes() iter.Seq[ElementType]
}

type TableQuerier interface {
	Contains(ElementType) bool
	ContainsAll(...ElementType) bool
	ContainsAny(...ElementType) bool
	ContainsNone(...ElementType) bool
}

type TableReader interface {
	Entry(int) (Entry, error)
	Get(ElementType, int) (reflect.Value, error)
	Row(ElementType) (Row, error)
	Length() int
	RowCount() int
}

type TableSetter []struct {
	ElementType
	Values []any
}

type TableWriter interface {
	Set(ElementType, reflect.Value, int) error
	NewEntries(int) ([]Entry, error)
	DeleteEntries(...int) ([]EntryID, error)
	TransferEntries(Table, ...int) error
	Clear() error
}

type TransferEntryIndexMismatchError struct{}