Struct Column 

pub struct Column { /* private fields */ }

A type-erased contiguous container for data of a homogeneous type.

Conceptually, a Column is very similar to a type-erased Box<[T]>. It also stores the change detection ticks for its components, kept in two separate contiguous buffers internally. An element shares its data across these buffers by using the same index (i.e. the entity at row 3 has it’s data at index 3 and its change detection ticks at index 3).

Like many other low-level storage types, Column has a limited and highly unsafe interface. It’s highly advised to use higher level types and their safe abstractions instead of working directly with Column.

For performance reasons, Column does not store its capacity and length. This type is used by Table and ComponentSparseSet, where the corresponding capacity and length can be found.

Implementations

impl Column

pub fn with_capacity(component_info: &ComponentInfo, capacity: usize) -> Self

Create a new Column with the given capacity.

pub unsafe fn get_data_slice<T>(&self, len: usize) -> &[UnsafeCell<T>]

Get a slice to the data stored in this Column.

Safety

• T must match the type of data that’s stored in this Column
• len must match the actual length of this column (number of elements stored)

pub unsafe fn get_added_ticks_slice(&self, len: usize) -> &[UnsafeCell<Tick>]

Get a slice to the added ticks in this Column.

Safety

• len must match the actual length of this column (number of elements stored)

pub unsafe fn get_changed_ticks_slice(&self, len: usize) -> &[UnsafeCell<Tick>]

Get a slice to the changed ticks in this Column.

Safety

• len must match the actual length of this column (number of elements stored)

pub unsafe fn get_changed_by_slice( &self, len: usize, ) -> MaybeLocation<&[UnsafeCell<&'static Location<'static>>]>

Get a slice to the calling locations that last changed each value in this Column

Safety

• len must match the actual length of this column (number of elements stored)

pub unsafe fn get_data_unchecked(&self, row: TableRow) -> Ptr<'_>

Fetches a read-only reference to the data at row. This does not do any bounds checking.

Safety

• row must be within the range [0, self.len()).
• no other mutable reference to the data of the same row can exist at the same time

pub unsafe fn get_changed_by_unchecked( &self, row: TableRow, ) -> MaybeLocation<&UnsafeCell<&'static Location<'static>>>

Fetches the calling location that last changed the value at row.

This function does not do any bounds checking.

Safety

row must be within the range [0, self.len()).

pub unsafe fn get_added_tick_unchecked( &self, row: TableRow, ) -> &UnsafeCell<Tick>

Fetches the “added” change detection tick for the value at row. This function does not do any bounds checking.

Safety

row must be within the range [0, self.len()).

pub unsafe fn get_changed_tick_unchecked( &self, row: TableRow, ) -> &UnsafeCell<Tick>

Fetches the “changed” change detection tick for the value at row This function does not do any bounds checking.

Safety

row must be within the range [0, self.len()).

pub unsafe fn get_ticks_unchecked(&self, row: TableRow) -> ComponentTicks

Fetches the change detection ticks for the value at row. This function does not do any bounds checking.

Safety

row must be within the range [0, self.len()).

pub fn get_drop(&self) -> Option<unsafe fn(OwningPtr<'_>)>

Returns the drop function for elements of the column, or None if they don’t need to be dropped.

pub fn get_summary_tick(&self) -> Option<&AtomicTick>

Returns a reference to the summary tick for this column, if the component that this column is associated with has a summary tick.

The summary tick stores the most recent changed timestamp that was written to any component instance of this column. “Most recent” here refers to the wall clock.

Be careful when using this value, as it’s easy to misuse. Because multiple systems with different ticks can be concurrently writing to a single column, and because “most recent” is in reference to wall clock time, there may be ticks in the column that are logically later than the summary tick. It’s therefore incorrect to assume that the summary tick represents the latest tick stored in the column.

Importantly, however, this situation can only occur when multiple systems are actually concurrently writing to a column. This can only happen when both systems are writing to a column with sparse queries. Systems that iterate over components with dense iteration have immutable or exclusive access to the columns corresponding to those components in the tables that they iterate over (and this fact is what makes contiguous iteration safe to begin with). So, for a dense query, we can guarantee that if the last_run tick for that query is t, then if the summary tick has a value earlier than t, then there have been no changes to the column values. Again, this is only true for dense iteration.

Trait Implementations

impl Debug for Column

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.