Trait rin::ecs::operators::UnorderedData

pub trait UnorderedData<'a> {
    type Iter;
    type IterMut;
    type Components: 'static;
    type ComponentsRef;
    type Storage;
    pub fn query_mask<E>(entities: &E) -> Bitmask
    where
        E: EntitiesStorage;
    pub fn into_iter<E>(entities: &'a E) -> Self::Iter
    where
        E: EntitiesStorage;
    pub fn into_iter_mut<E>(entities: &'a E) -> Self::IterMut
    where
        E: EntitiesStorage;
    pub fn storage<E>(entities: &'a E) -> Option<Self::Storage>
    where
        E: EntitiesStorage;
}

Associated Types

type Iter

type IterMut

type Components: 'static

type ComponentsRef

type Storage

Loading content...

Required methods

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

pub fn into_iter<E>(entities: &'a E) -> Self::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(entities: &'a E) -> Self::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(entities: &'a E) -> Option<Self::Storage> where
    E: EntitiesStorage, 

Loading content...

Implementations on Foreign Types

impl<'a, U1, U2, U3, U4> UnorderedData<'a> for (U1, U2, U3, U4) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3, U4) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3, U4) as UnorderedData<'a>>::Storage, <(U1, U2, U3, U4) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components, <U4 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef, <U4 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef4<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage, <U4 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3, U4) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, U1, U2, U3, U4, U5, U6, U7, U8> UnorderedData<'a> for (U1, U2, U3, U4, U5, U6, U7, U8) where
    U8: UnorderedData<'a>,
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U5: UnorderedData<'a>,
    U6: UnorderedData<'a>,
    U7: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U5 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U6 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U7 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U8 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::Storage, <(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components, <U4 as UnorderedData<'a>>::Components, <U5 as UnorderedData<'a>>::Components, <U6 as UnorderedData<'a>>::Components, <U7 as UnorderedData<'a>>::Components, <U8 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef, <U4 as UnorderedData<'a>>::ComponentsRef, <U5 as UnorderedData<'a>>::ComponentsRef, <U6 as UnorderedData<'a>>::ComponentsRef, <U7 as UnorderedData<'a>>::ComponentsRef, <U8 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef8<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage, <U4 as UnorderedData<'a>>::Storage, <U5 as UnorderedData<'a>>::Storage, <U6 as UnorderedData<'a>>::Storage, <U7 as UnorderedData<'a>>::Storage, <U8 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3, U4, U5, U6, U7, U8) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, U1, U2, U3, U4, U5, U6, U7> UnorderedData<'a> for (U1, U2, U3, U4, U5, U6, U7) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U5: UnorderedData<'a>,
    U6: UnorderedData<'a>,
    U7: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U5 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U6 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U7 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::Storage, <(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components, <U4 as UnorderedData<'a>>::Components, <U5 as UnorderedData<'a>>::Components, <U6 as UnorderedData<'a>>::Components, <U7 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef, <U4 as UnorderedData<'a>>::ComponentsRef, <U5 as UnorderedData<'a>>::ComponentsRef, <U6 as UnorderedData<'a>>::ComponentsRef, <U7 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef7<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage, <U4 as UnorderedData<'a>>::Storage, <U5 as UnorderedData<'a>>::Storage, <U6 as UnorderedData<'a>>::Storage, <U7 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3, U4, U5, U6, U7) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, U1, U2, U3, U4, U5> UnorderedData<'a> for (U1, U2, U3, U4, U5) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U5: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U5 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3, U4, U5) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3, U4, U5) as UnorderedData<'a>>::Storage, <(U1, U2, U3, U4, U5) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components, <U4 as UnorderedData<'a>>::Components, <U5 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef, <U4 as UnorderedData<'a>>::ComponentsRef, <U5 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef5<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage, <U4 as UnorderedData<'a>>::Storage, <U5 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3, U4, U5) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, U1, U2, U3, U4, U5, U6> UnorderedData<'a> for (U1, U2, U3, U4, U5, U6) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U5: UnorderedData<'a>,
    U6: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U5 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U6 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::Storage, <(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components, <U4 as UnorderedData<'a>>::Components, <U5 as UnorderedData<'a>>::Components, <U6 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef, <U4 as UnorderedData<'a>>::ComponentsRef, <U5 as UnorderedData<'a>>::ComponentsRef, <U6 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef6<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage, <U4 as UnorderedData<'a>>::Storage, <U5 as UnorderedData<'a>>::Storage, <U6 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3, U4, U5, U6) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'a, U1, U2> UnorderedData<'a> for (U1, U2) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2) as UnorderedData<'a>>::Storage, <(U1, U2) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef2<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage>

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

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

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

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

impl<'a, U1, U2, U3> UnorderedData<'a> for (U1, U2, U3) where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt, 

type Iter = StorageIter<'a, <(U1, U2, U3) as UnorderedData<'a>>::Storage>

type IterMut = StorageIterMut<'a, <(U1, U2, U3) as UnorderedData<'a>>::Storage, <(U1, U2, U3) as UnorderedData<'a>>::ComponentsRef>

type Components = (<U1 as UnorderedData<'a>>::Components, <U2 as UnorderedData<'a>>::Components, <U3 as UnorderedData<'a>>::Components)

type ComponentsRef = (<U1 as UnorderedData<'a>>::ComponentsRef, <U2 as UnorderedData<'a>>::ComponentsRef, <U3 as UnorderedData<'a>>::ComponentsRef)

type Storage = StorageRef3<'a, <U1 as UnorderedData<'a>>::Storage, <U2 as UnorderedData<'a>>::Storage, <U3 as UnorderedData<'a>>::Storage>

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

pub fn into_iter<E>(
    entities: &'a E
) -> <(U1, U2, U3) as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <(U1, U2, U3) as UnorderedData<'a>>::IterMut where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<(U1, U2, U3) as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

Loading content...

Implementors

impl<'a> UnorderedData<'a> for EntityWithPath<'a>

type Iter = FilterIter<'a, EntityWithPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type IterMut = FilterIter<'a, EntityWithPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type Components = (<Write<'a, Node> as UnorderedData<'a>>::Components, <Write<'a, Path> as UnorderedData<'a>>::Components, <ReadOption<'a, Speed> as UnorderedData<'a>>::Components, <ReadOption<'a, Delta> as UnorderedData<'a>>::Components, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Components, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Components, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Components)

type ComponentsRef = EntityWithPath<'a>

type Storage = FilterStorage<'a, EntityWithPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

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

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

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

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

impl<'a> UnorderedData<'a> for EntityWithPathMut<'a>

type Iter = FilterIter<'a, EntityWithPathMut<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <WriteOption<'a, Speed> as UnorderedData<'a>>::Storage, <WriteOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type IterMut = FilterIter<'a, EntityWithPathMut<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <WriteOption<'a, Speed> as UnorderedData<'a>>::Storage, <WriteOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type Components = (<Write<'a, Node> as UnorderedData<'a>>::Components, <Write<'a, Path> as UnorderedData<'a>>::Components, <WriteOption<'a, Speed> as UnorderedData<'a>>::Components, <WriteOption<'a, Delta> as UnorderedData<'a>>::Components, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Components, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Components, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Components)

type ComponentsRef = EntityWithPathMut<'a>

type Storage = FilterStorage<'a, EntityWithPathMut<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <WriteOption<'a, Speed> as UnorderedData<'a>>::Storage, <WriteOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <WriteOption<'a, SkinningUpToDate> as UnorderedData<'a>>::Storage, <Not<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

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

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

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

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

impl<'a> UnorderedData<'a> for EntityWithReynoldsPath<'a>

type Iter = FilterIter<'a, EntityWithReynoldsPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, Velocity> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <Read<'a, PathLookUpDistance> as UnorderedData<'a>>::Storage, <Read<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type IterMut = FilterIter<'a, EntityWithReynoldsPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, Velocity> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <Read<'a, PathLookUpDistance> as UnorderedData<'a>>::Storage, <Read<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

type Components = (<Write<'a, Node> as UnorderedData<'a>>::Components, <Write<'a, Path> as UnorderedData<'a>>::Components, <ReadOption<'a, Speed> as UnorderedData<'a>>::Components, <ReadOption<'a, Delta> as UnorderedData<'a>>::Components, <Write<'a, Velocity> as UnorderedData<'a>>::Components, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Components, <Read<'a, PathLookUpDistance> as UnorderedData<'a>>::Components, <Read<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Components)

type ComponentsRef = EntityWithReynoldsPath<'a>

type Storage = FilterStorage<'a, EntityWithReynoldsPath<'a>, (<Write<'a, Node> as UnorderedData<'a>>::Storage, <Write<'a, Path> as UnorderedData<'a>>::Storage, <ReadOption<'a, Speed> as UnorderedData<'a>>::Storage, <ReadOption<'a, Delta> as UnorderedData<'a>>::Storage, <Write<'a, Velocity> as UnorderedData<'a>>::Storage, <Write<'a, CurrentPosition> as UnorderedData<'a>>::Storage, <Read<'a, PathLookUpDistance> as UnorderedData<'a>>::Storage, <Read<'a, ReynoldsPathInfo> as UnorderedData<'a>>::Storage)>

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

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

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

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

impl<'a> UnorderedData<'a> for Entity

type Iter = EntitiesIter<'a>

type IterMut = EntitiesIter<'a>

type Components = Entity

type ComponentsRef = Entity

type Storage = &'a [(Entity, U256)]

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<Entity 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> UnorderedData<'a> for ReadOr<'a, (T1, T2)> where
    T2: Component + Send,
    T1: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>, 

type Iter = Iter2<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter2<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, LazyIndexGuard<'a>>

type Components = (T1, T2)

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>)

type Storage = StorageRef2<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, LazyIndexGuard<'a>>

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

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

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

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

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> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>, 

type Iter = Iter3<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter3<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, LazyIndexGuard<'a>>

type Components = (T1, T2, T3)

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>)

type Storage = StorageRef3<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, LazyIndexGuard<'a>>

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOr<'a, (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> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3, T4)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    T4: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>,
    <T4 as Component>::Storage: for<'s> Storage<'s, T4>, 

type Iter = Iter4<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter4<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, LazyIndexGuard<'a>>

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

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>, Option<<<T4 as Component>::Storage as Storage<'a, T4>>::Get>)

type Storage = StorageRef4<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, LazyIndexGuard<'a>>

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOr<'a, (T1, T2, T3, T4)> 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> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3, T4, T5)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    T4: Component + Send,
    T5: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>,
    <T4 as Component>::Storage: for<'s> Storage<'s, T4>,
    <T5 as Component>::Storage: for<'s> Storage<'s, T5>, 

type Iter = Iter5<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter5<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, LazyIndexGuard<'a>>

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

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>, Option<<<T4 as Component>::Storage as Storage<'a, T4>>::Get>, Option<<<T5 as Component>::Storage as Storage<'a, T5>>::Get>)

type Storage = StorageRef5<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, LazyIndexGuard<'a>>

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOr<'a, (T1, T2, T3, T4, T5)> 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, T3, T4, T5, T6> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3, T4, T5, T6)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    T4: Component + Send,
    T5: Component + Send,
    T6: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>,
    <T4 as Component>::Storage: for<'s> Storage<'s, T4>,
    <T5 as Component>::Storage: for<'s> Storage<'s, T5>,
    <T6 as Component>::Storage: for<'s> Storage<'s, T6>, 

type Iter = Iter6<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter6<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, LazyIndexGuard<'a>>

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

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>, Option<<<T4 as Component>::Storage as Storage<'a, T4>>::Get>, Option<<<T5 as Component>::Storage as Storage<'a, T5>>::Get>, Option<<<T6 as Component>::Storage as Storage<'a, T6>>::Get>)

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

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOr<'a, (T1, T2, T3, T4, T5, T6)> 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<'a, T1, T2, T3, T4, T5, T6, T7> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3, T4, T5, T6, T7)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    T4: Component + Send,
    T5: Component + Send,
    T6: Component + Send,
    T7: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>,
    <T4 as Component>::Storage: for<'s> Storage<'s, T4>,
    <T5 as Component>::Storage: for<'s> Storage<'s, T5>,
    <T6 as Component>::Storage: for<'s> Storage<'s, T6>,
    <T7 as Component>::Storage: for<'s> Storage<'s, T7>, 

type Iter = Iter7<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, T7, ReadGuardRef<'a, <T7 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter7<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, T7, ReadGuardRef<'a, <T7 as Component>::Storage>, LazyIndexGuard<'a>>

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

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>, Option<<<T4 as Component>::Storage as Storage<'a, T4>>::Get>, Option<<<T5 as Component>::Storage as Storage<'a, T5>>::Get>, Option<<<T6 as Component>::Storage as Storage<'a, T6>>::Get>, Option<<<T7 as Component>::Storage as Storage<'a, T7>>::Get>)

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

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

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

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

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOr<'a, (T1, T2, T3, T4, T5, T6, T7)> 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, T6, T7, T8> UnorderedData<'a> for ReadOr<'a, (T1, T2, T3, T4, T5, T6, T7, T8)> where
    T3: Component + Send,
    T2: Component + Send,
    T1: Component + Send,
    T4: Component + Send,
    T5: Component + Send,
    T6: Component + Send,
    T7: Component + Send,
    T8: Component + Send,
    <T1 as Component>::Storage: for<'s> Storage<'s, T1>,
    <T2 as Component>::Storage: for<'s> Storage<'s, T2>,
    <T3 as Component>::Storage: for<'s> Storage<'s, T3>,
    <T4 as Component>::Storage: for<'s> Storage<'s, T4>,
    <T5 as Component>::Storage: for<'s> Storage<'s, T5>,
    <T6 as Component>::Storage: for<'s> Storage<'s, T6>,
    <T7 as Component>::Storage: for<'s> Storage<'s, T7>,
    <T8 as Component>::Storage: for<'s> Storage<'s, T8>, 

type Iter = Iter8<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, T7, ReadGuardRef<'a, <T7 as Component>::Storage>, T8, ReadGuardRef<'a, <T8 as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter8<'a, T1, ReadGuardRef<'a, <T1 as Component>::Storage>, T2, ReadGuardRef<'a, <T2 as Component>::Storage>, T3, ReadGuardRef<'a, <T3 as Component>::Storage>, T4, ReadGuardRef<'a, <T4 as Component>::Storage>, T5, ReadGuardRef<'a, <T5 as Component>::Storage>, T6, ReadGuardRef<'a, <T6 as Component>::Storage>, T7, ReadGuardRef<'a, <T7 as Component>::Storage>, T8, ReadGuardRef<'a, <T8 as Component>::Storage>, LazyIndexGuard<'a>>

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

type ComponentsRef = (Option<<<T1 as Component>::Storage as Storage<'a, T1>>::Get>, Option<<<T2 as Component>::Storage as Storage<'a, T2>>::Get>, Option<<<T3 as Component>::Storage as Storage<'a, T3>>::Get>, Option<<<T4 as Component>::Storage as Storage<'a, T4>>::Get>, Option<<<T5 as Component>::Storage as Storage<'a, T5>>::Get>, Option<<<T6 as Component>::Storage as Storage<'a, T6>>::Get>, Option<<<T7 as Component>::Storage as Storage<'a, T7>>::Get>, Option<<<T8 as Component>::Storage as Storage<'a, T8>>::Get>)

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

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

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

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

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

impl<'a, T> UnorderedData<'a> for Has<T> where
    T: 'static, 

type Iter = Repeat<()>

type IterMut = Repeat<()>

type Components = T

type ComponentsRef = ()

type Storage = StorageHas<'a, T>

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

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

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

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

impl<'a, T> UnorderedData<'a> for HasOption<T> where
    T: 'static, 

type Iter = IterHasOption<'a, T>

type IterMut = IterHasOption<'a, T>

type Components = T

type ComponentsRef = bool

type Storage = StorageHasOption<'a, T>

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

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

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

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

impl<'a, T> UnorderedData<'a> for Not<'a, T> where
    T: 'static, 

type Iter = Repeat<()>

type IterMut = Repeat<()>

type Components = T

type ComponentsRef = ()

type Storage = StorageNot<'a, T>

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

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

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

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

impl<'a, T> UnorderedData<'a> for Read<'a, T> where
    T: Component,
    ReadGuardRef<'a, <T as Component>::Storage>: IntoIter,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = IterOptionWrapper<<ReadGuardRef<'a, <T as Component>::Storage> as IntoIter>::Iter>

type IterMut = IterOptionWrapper<<ReadGuardRef<'a, <T as Component>::Storage> as IntoIter>::Iter>

type Components = T

type ComponentsRef = <<T as Component>::Storage as Storage<'a, T>>::Get

type Storage = StorageRead<'a, T, ReadGuardRef<'a, <T as Component>::Storage>>

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

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

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

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

impl<'a, T> UnorderedData<'a> for ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = IterOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

type IterMut = IterOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

type Components = T

type ComponentsRef = Option<<<T as Component>::Storage as Storage<'a, T>>::Get>

type Storage = StorageOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

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

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

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

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

impl<'a, T> UnorderedData<'a> for Write<'a, T> where
    T: Component,
    WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>: IntoIterMut,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = IterOptionWrapper<<WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard> as IntoIterMut>::IterMut>

type IterMut = IterOptionWrapper<<WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard> as IntoIterMut>::IterMut>

type Components = T

type ComponentsRef = <<T as Component>::Storage as Storage<'a, T>>::GetMut

type Storage = StorageWrite<'a, <T as Component>::Storage, <Write<'a, T> as UnorderedData<'a>>::Components, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>

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

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

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

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

impl<'a, T> UnorderedData<'a> for WriteOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = IterOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>

type IterMut = IterOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>

type Components = T

type ComponentsRef = Option<<<T as Component>::Storage as Storage<'a, T>>::GetMut>

type Storage = StorageOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>

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

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

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

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

impl<'a, T, Not> UnorderedData<'a> for ReadNot<'a, T, Not> where
    Not: 'static,
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = Iter<'a, T, Not, ReadGuardRef<'a, <T as Component>::Storage>, LazyIndexGuard<'a>>

type IterMut = Iter<'a, T, Not, ReadGuardRef<'a, <T as Component>::Storage>, LazyIndexGuard<'a>>

type Components = T

type ComponentsRef = <<T as Component>::Storage as Storage<'a, T>>::Get

type Storage = StorageReadNot<'a, T, ReadGuardRef<'a, <T as Component>::Storage>, Not, LazyIndexGuard<'a>>

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

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

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <ReadNot<'a, T, Not> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

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

impl<'a, T, R> UnorderedData<'a> for Ref<'a, T, R> where
    T: Deref<Target = Entity> + NToOneComponent<'a>,
    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, <Ref<'a, T, R> as UnorderedData<'a>>::Storage>

type IterMut = RefIterMut<'a, <Ref<'a, T, R> as UnorderedData<'a>>::Storage, <Ref<'a, T, R> as UnorderedData<'a>>::ComponentsRef>

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, RefData, LazyIndexGuard<'a>>

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

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

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

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

impl<'a, T, R> UnorderedData<'a> for RefN<'a, T, R> where
    T: OneToNComponent,
    R: UnorderedData<'a> + 'a,
    <R as UnorderedData<'a>>::Storage: StorageRef<'a>,
    <T as Component>::Storage: for<'b> OneToNStorage<'b, T>, 

type Iter = RefIntoIter<'a, T, R>

type IterMut = RefIntoIterMut<'a, T, R>

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

type ComponentsRef = RefCollection<'a, T, <<R as UnorderedData<'a>>::Storage as StorageRef<'a>>::Component>

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

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

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

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

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

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, 

Loading content...