Struct rin::ecs::operators::URef

pub struct URef<'a, T, R> where
    T: OneToOneComponent<'a>,  { /* fields omitted */ }

Matches a component in another entity referenced through a component that Derefs to an Entity:

Entity A                           Entity C
Component(Entity) ───────────────► AnotherCompoenent

Entity B                           Entity D
Component(Entity) ───────────────► AnotherCompoenent

Allows to create OneToOne relations between entities components.

In the following example we create 2 entities that reference their geometry from other entities.

References have to implement OneToOneComponent.

As opposed to Ref and NToOneComponent this operator returns a plain iterator for write access to the referenced component since OneToOneComponent ensures that the references are unique and so the iterator won’t ever access the same component mutably more than once.

#[derive(Debug)]
struct Vertex;
#[derive(OneToOneComponent, Debug, Hash)]
struct GeometryRef(Entity);

#[derive(Component, Debug)]
struct Geometry(Vec<Vertex>);

#[derive(Component, Debug)]
struct Position{x: f32, y: f32};

let mut world = World::new();
let geometry1 = world.new_entity().add(Geometry(vec![Vertex, Vertex, Vertex])).build();
let geometry2 = world.new_entity().add(Geometry(vec![Vertex, Vertex, Vertex])).build();
let a = world.new_entity()
    .add(GeometryRef(geometry1))
    .add(Position{x: 0.0, y: 0.0})
    .build();
let b = world.new_entity()
    .add(GeometryRef(geometry2))
    .add(Position{x: 0.0, y: 0.0})
    .build();
for geometry in world.iter_for_mut::<URef<GeometryRef, Write<Geometry>>>() {

}

Trait Implementations

impl<'a, T, R> DataAccesses for URef<'a, T, R> where
    T: OneToOneComponent<'a>,
    R: DataAccesses, 

pub fn reads() -> Vec<TypeId, Global>

pub fn writes() -> Vec<TypeId, Global>

impl<'a, T, R> Deref for URef<'a, T, R> where
    T: OneToOneComponent<'a>,
    R: UnorderedData<'a>, 

type Target = R

The resulting type after dereferencing.

pub fn deref(&self) -> &R

Dereferences the value.

impl<'a, T, R> DerefMut for URef<'a, T, R> where
    T: OneToOneComponent<'a>,
    R: UnorderedData<'a>, 

pub fn deref_mut(&mut self) -> &mut R

Mutably dereferences the value.

impl<'a, T, R> FromComponent<'a, <R as UnorderedData<'a>>::ComponentsRef> for URef<'a, T, R> where
    T: OneToOneComponent<'a>,
    R: UnorderedData<'a> + FromComponent<'a, <R as UnorderedData<'a>>::ComponentsRef>, 

pub fn from_component(
    component: <R as UnorderedData<'a>>::ComponentsRef
) -> URef<'a, T, R>

impl<'a, T, R> UnorderedData<'a> for URef<'a, T, R> where
    T: OneToOneComponent<'a> + Component,
    R: UnorderedData<'a>,
    <T as Component>::Storage: for<'s> Storage<'s, T>,
    <<T as Component>::Storage as Storage<'a, T>>::Get: Borrow<T>, 

type Iter = RefIter<'a, <URef<'a, T, R> as UnorderedData<'a>>::Storage>

type IterMut = RefIter<'a, <URef<'a, T, R> as UnorderedData<'a>>::Storage>

type Components = <R as UnorderedData<'a>>::Components

type ComponentsRef = <R as UnorderedData<'a>>::ComponentsRef

type Storage = RefStorage<'a, ReadGuardRef<'a, <T as Component>::Storage>, T, <R as UnorderedData<'a>>::Storage, <R as UnorderedData<'a>>::Components, URefData, LazyIndexGuard<'a>>

pub fn query_mask<E>(entities: &E) -> Bitmask where
    E: EntitiesStorage, 

pub fn into_iter<E>(
    entities: &'a E
) -> <URef<'a, T, R> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <URef<'a, T, R> as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<URef<'a, T, R> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T, R> SafeIter<'a> for URef<'a, T, R> where
    T: OneToOneComponent<'a>,
    R: SafeIter<'a>, 

impl<'a, T, R> SafeStreamingIter<'a> for URef<'a, T, R> where
    T: OneToOneComponent<'a>,