Struct ComponentVec 

pub struct ComponentVec<T> { /* private fields */ }

A densely packed growable array for associating entities with components.

Examples

use checs::ComponentVec;

let mut entities = checs::entity::Allocator::new();

let e0 = entities.alloc();
let e1 = entities.alloc();
let e2 = entities.alloc();
let e3 = entities.alloc();

let mut vec = ComponentVec::new();
vec.insert(e0, 42);
vec.insert(e1, 17);
vec.insert(e2, 99);
assert_eq!(vec.len(), 3);

assert_eq!(vec.get(e0), Some(&42));
assert_eq!(vec.contains(e1), true);
assert_eq!(vec.get_mut(e2), Some(&mut 99));
assert_eq!(vec.get(e3), None);

assert_eq!(vec.remove(e2), Some(99));
assert_eq!(vec.get(e2), None);

for (entity, int) in &vec {
    println!("{entity:?}: {int}");
}

Implementations

impl<T> ComponentVec<T>

pub fn new() -> Self

Constructs a new empty ComponentVec<T>.

The vector will not allocate until elements are pushed onto it.

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its ‘length’.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn contains(&self, entity: Entity) -> bool

Returns true if the vector contains a component for the entity.

pub fn get(&self, entity: Entity) -> Option<&T>

Returns a reference to the entity’s component, or None if the entity does not have that component.

pub fn get_mut(&mut self, entity: Entity) -> Option<&mut T>

Returns a mutable reference to an entity’s component, or None if the entity does not have that component.

pub fn insert(&mut self, entity: Entity, component: T) -> Option<T>

Adds a component to the entity.

If the entity already had that component its value is updated and the old value is returned.

pub fn remove(&mut self, entity: Entity) -> Option<T>

Removes a component from the entity and returns the component.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted into the vector.

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator that yields entities and their components as references.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that yields entities and their components as mutable references.

Trait Implementations

impl<T> Default for ComponentVec<T>

fn default() -> ComponentVec<T>

Returns the “default value” for a type.

impl<'a, T> IntoIterator for &'a ComponentVec<T>

type IntoIter = Zip<Copied<Iter<'a, Entity>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

type Item = (Entity, &'a T)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut ComponentVec<T>

type IntoIter = Zip<Copied<Iter<'a, Entity>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

type Item = (Entity, &'a mut T)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoQuery<'a> for &'a ComponentVec<T>

where T: 'a,

type Query = Zip<Copied<Iter<'a, Entity>>, Iter<'a, T>>

The type of the query.

fn into_query(self) -> Self::Query

Creates a query from a value.

impl<'a, T> IntoQuery<'a> for &'a mut ComponentVec<T>

where T: 'a,

type Query = Zip<Copied<Iter<'a, Entity>>, IterMut<'a, T>>

The type of the query.

fn into_query(self) -> Self::Query

Creates a query from a value.

impl<'a, T> IntoRefOrMut<'a> for &'a ComponentVec<T>

type Components = &'a [T]

The type of slice containing the components. Either a shared or a mutable reference.

fn into_ref_or_mut(self) -> RefOrMut<'a, Self::Components>

Converts self into a RefOrMut.

impl<'a, T> IntoRefOrMut<'a> for &'a mut ComponentVec<T>

type Components = &'a mut [T]

The type of slice containing the components. Either a shared or a mutable reference.

fn into_ref_or_mut(self) -> RefOrMut<'a, Self::Components>

Converts self into a RefOrMut.