Struct legion::query::ChunkView

pub struct ChunkView<'a, F: Fetch> { /* fields omitted */ }

Provides access to slices of components for entities which have the same component layout.

A single index in any of the slices contained in a chunk belong to the same entity.

Implementations

impl<'a, F: Fetch> ChunkView<'a, F>

pub fn archetype(&self) -> &Archetype

Returns the archetype that all entities in the chunk belong to.

pub fn component_slice<T: Component>(&self) -> Option<&[T]>

Returns a slice of components.

May return None if the chunk’s view does not declare access to the component type.

pub fn component_slice_mut<T: Component>(&mut self) -> Option<&mut [T]>

Returns a mutable slice of components.

May return None if the chunk’s view does not declare access to the component type.

pub fn into_components(self) -> F::Data

Converts the chunk into a tuple of its inner slices.

Examples

let mut query = <(Entity, Read<A>, Write<B>, TryRead<C>, TryWrite<D>)>::query();
for chunk in query.iter_chunks_mut(&mut world) {
    let slices: (&[Entity], &[A], &mut [B], Option<&[C]>, Option<&mut [D]>) =
        chunk.into_components();
}

pub fn get_components(&self) -> F::Data where
    F: ReadOnlyFetch, 

Converts the chunk into a tuple of its inner slices.

Only usable with views whose elements are all read-only.

Examples

let mut query = <(Entity, Read<A>, TryRead<B>)>::query();
for chunk in query.iter_chunks_mut(&mut world) {
    let slices: (&[Entity], &[A], Option<&[B]>) = chunk.get_components();
}

pub fn into_iter_entities(
    self
) -> impl Iterator<Item = (Entity, <F as IntoIndexableIter>::Item)> + 'a where
    <F as IntoIndexableIter>::IntoIter: 'a, 

Converts the chunk into an iterator which yields tuples of (Entity, components).

Trait Implementations

impl<'a, F: Fetch> IntoIterator for ChunkView<'a, F>

type IntoIter = <F as IntoIndexableIter>::IntoIter

Which kind of iterator are we turning this into?

type Item = <F as IntoIndexableIter>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, F: Fetch> IntoParallelIterator for ChunkView<'a, F>

type Iter = Par<<F as IntoIndexableIter>::IntoIter>

The parallel iterator type that will be created.

type Item = <<F as IntoIndexableIter>::IntoIter as TrustedRandomAccess>::Item

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.