Struct rin::ecs::operators::HasOr

pub struct HasOr<T> { /* fields omitted */ }

Matches entities that have any of the passed components with read only access to those components

It returns an element per component being None those that don’t exist for that entity

for (has_pos, has_vel) in entities.iter_for::<HasOr<(Position, Velocity)>>(){
    if has_pos {
    }

    if has_vel {
    }
}

Matches all entities that have a Position a Velocity or both. pos and vel will be None for entities that don’t have Position or Velocity respectively

Trait Implementations

impl<T1, T2> DataAccesses for HasOr<(T1, T2)>

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

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

impl<T1, T2, T3, T4, T5> DataAccesses for HasOr<(T1, T2, T3, T4, T5)>

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

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

impl<T1, T2, T3, T4> DataAccesses for HasOr<(T1, T2, T3, T4)>

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

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

impl<T1, T2, T3, T4, T5, T6, T7> DataAccesses for HasOr<(T1, T2, T3, T4, T5, T6, T7)>

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

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

impl<T1, T2, T3> DataAccesses for HasOr<(T1, T2, T3)>

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

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

impl<T1, T2, T3, T4, T5, T6> DataAccesses for HasOr<(T1, T2, T3, T4, T5, T6)>

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

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

impl<T1, T2, T3, T4, T5, T6, T7, T8> DataAccesses for HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)>

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

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

impl<'_, T1, T2, T3, T4, T5, T6, T7, T8> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B, <T8 as Bools>::B)> for HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B, <T8 as Bools>::B)
) -> HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)>

impl<'_, T1, T2, T3, T4, T5, T6, T7> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B)> for HasOr<(T1, T2, T3, T4, T5, T6, T7)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B)
) -> HasOr<(T1, T2, T3, T4, T5, T6, T7)>

impl<'_, T1, T2, T3, T4, T5, T6> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B)> for HasOr<(T1, T2, T3, T4, T5, T6)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B)
) -> HasOr<(T1, T2, T3, T4, T5, T6)>

impl<'_, T1, T2, T3, T4, T5> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B)> for HasOr<(T1, T2, T3, T4, T5)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B)
) -> HasOr<(T1, T2, T3, T4, T5)>

impl<'_, T1, T2, T3, T4> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B)> for HasOr<(T1, T2, T3, T4)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B)
) -> HasOr<(T1, T2, T3, T4)>

impl<'_, T1, T2, T3> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B)> for HasOr<(T1, T2, T3)>

pub fn from_component(
    (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B)
) -> HasOr<(T1, T2, T3)>

impl<'_, T1, T2> FromComponent<'_, (<T1 as Bools>::B, <T2 as Bools>::B)> for HasOr<(T1, T2)>

pub fn from_component((<T1 as Bools>::B, <T2 as Bools>::B)) -> HasOr<(T1, T2)>

impl<'a, T1, T2, T3> UnorderedData<'a> for HasOr<(T1, T2, T3)> where
    T3: 'static,
    T2: 'static,
    T1: 'static, 

type Iter = IntoIter3<'a, T1, T2, T3>

type IterMut = IntoIter3<'a, T1, T2, T3>

type Components = (T1, T2, T3)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B)

type Storage = StorageRef3<'a, T1, T2, T3, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2, T3, T4> UnorderedData<'a> for HasOr<(T1, T2, T3, T4)> where
    T3: 'static,
    T2: 'static,
    T1: 'static,
    T4: 'static, 

type Iter = IntoIter4<'a, T1, T2, T3, T4>

type IterMut = IntoIter4<'a, T1, T2, T3, T4>

type Components = (T1, T2, T3, T4)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B)

type Storage = StorageRef4<'a, T1, T2, T3, T4, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3, T4)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2, T3, T4, T5, T6> UnorderedData<'a> for HasOr<(T1, T2, T3, T4, T5, T6)> where
    T3: 'static,
    T2: 'static,
    T1: 'static,
    T4: 'static,
    T5: 'static,
    T6: 'static, 

type Iter = IntoIter6<'a, T1, T2, T3, T4, T5, T6>

type IterMut = IntoIter6<'a, T1, T2, T3, T4, T5, T6>

type Components = (T1, T2, T3, T4, T5, T6)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B)

type Storage = StorageRef6<'a, T1, T2, T3, T4, T5, T6, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3, T4, T5, T6)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2> UnorderedData<'a> for HasOr<(T1, T2)> where
    T2: 'static,
    T1: 'static, 

type Iter = IntoIter2<'a, T1, T2>

type IterMut = IntoIter2<'a, T1, T2>

type Components = (T1, T2)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B)

type Storage = StorageRef2<'a, T1, T2, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2, T3, T4, T5, T6, T7, T8> UnorderedData<'a> for HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)> where
    T3: 'static,
    T2: 'static,
    T1: 'static,
    T4: 'static,
    T5: 'static,
    T6: 'static,
    T7: 'static,
    T8: 'static, 

type Iter = IntoIter8<'a, T1, T2, T3, T4, T5, T6, T7, T8>

type IterMut = IntoIter8<'a, T1, T2, T3, T4, T5, T6, T7, T8>

type Components = (T1, T2, T3, T4, T5, T6, T7, T8)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B, <T8 as Bools>::B)

type Storage = StorageRef8<'a, T1, T2, T3, T4, T5, T6, T7, T8, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2, T3, T4, T5> UnorderedData<'a> for HasOr<(T1, T2, T3, T4, T5)> where
    T3: 'static,
    T2: 'static,
    T1: 'static,
    T4: 'static,
    T5: 'static, 

type Iter = IntoIter5<'a, T1, T2, T3, T4, T5>

type IterMut = IntoIter5<'a, T1, T2, T3, T4, T5>

type Components = (T1, T2, T3, T4, T5)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B)

type Storage = StorageRef5<'a, T1, T2, T3, T4, T5, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3, T4, T5)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, T1, T2, T3, T4, T5, T6, T7> UnorderedData<'a> for HasOr<(T1, T2, T3, T4, T5, T6, T7)> where
    T3: 'static,
    T2: 'static,
    T1: 'static,
    T4: 'static,
    T5: 'static,
    T6: 'static,
    T7: 'static, 

type Iter = IntoIter7<'a, T1, T2, T3, T4, T5, T6, T7>

type IterMut = IntoIter7<'a, T1, T2, T3, T4, T5, T6, T7>

type Components = (T1, T2, T3, T4, T5, T6, T7)

type ComponentsRef = (<T1 as Bools>::B, <T2 as Bools>::B, <T3 as Bools>::B, <T4 as Bools>::B, <T5 as Bools>::B, <T6 as Bools>::B, <T7 as Bools>::B)

type Storage = StorageRef7<'a, T1, T2, T3, T4, T5, T6, T7, LazyIndexGuard<'a>>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6, T7)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <HasOr<(T1, T2, T3, T4, T5, T6, T7)> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<HasOr<(T1, T2, T3, T4, T5, T6, T7)> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'_, T1, T2, T3, T4, T5, T6> SafeIter<'_> for HasOr<(T1, T2, T3, T4, T5, T6)>

impl<'_, T1, T2, T3, T4> SafeIter<'_> for HasOr<(T1, T2, T3, T4)>

impl<'_, T1, T2, T3, T4, T5> SafeIter<'_> for HasOr<(T1, T2, T3, T4, T5)>

impl<'_, T1, T2> SafeIter<'_> for HasOr<(T1, T2)>

impl<'_, T1, T2, T3> SafeIter<'_> for HasOr<(T1, T2, T3)>

impl<'_, T1, T2, T3, T4, T5, T6, T7, T8> SafeIter<'_> for HasOr<(T1, T2, T3, T4, T5, T6, T7, T8)>

impl<'_, T1, T2, T3, T4, T5, T6, T7> SafeIter<'_> for HasOr<(T1, T2, T3, T4, T5, T6, T7)>