Trait rin::ecs::operators::TupleStorageEntities

pub trait TupleStorageEntities<'a, 'r, U> {
    type Storage: StorageRef<'r>;
    pub fn iter(self) -> StorageIter<'r, Self::Storage>
    where
        U: ReadOnlyOp<'a>;
    pub fn iter_mut(
        self
    ) -> StorageIterMut<'r, Self::Storage, <Self::Storage as StorageRef<'r>>::Component>;
    pub fn iter_for_entities<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesIter
    where
        E: IntoEntitiesIterator<'r, Self::Storage>,
        Self::Storage: ReadOnlyStorage;
    pub fn iter_for_entities_mut<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesIterMut
    where
        E: IntoEntitiesIterator<'r, Self::Storage>;
    pub fn iter_for_entities_opt<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesOptIter
    where
        E: IntoEntitiesIterator<'r, Self::Storage>,
        Self::Storage: ReadOnlyStorage;
    pub fn iter_for_entities_opt_mut<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesOptIterMut
    where
        E: IntoEntitiesIterator<'r, Self::Storage>;
    pub fn par_iter(self) -> ParStorageIter<'r, Self::Storage>;
    pub fn par_iter_for_entities<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesParIter
    where
        E: IntoEntitiesParIterator<'r, Self::Storage>,
        Self::Storage: ReadOnlyStorage;
    pub fn par_iter_for_entities_mut<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesParIterMut
    where
        E: IntoEntitiesParIterator<'r, Self::Storage>;
    pub fn par_iter_for_entities_opt<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesOptParIter
    where
        E: IntoEntitiesParIterator<'r, Self::Storage>,
        Self::Storage: ReadOnlyStorage;
    pub fn par_iter_for_entities_opt_mut<E>(
        self, 
        entities_iter: E
    ) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesOptParIterMut
    where
        E: IntoEntitiesParIterator<'r, Self::Storage>;
}

Associated Types

type Storage: StorageRef<'r>

Loading content...

Required methods

pub fn iter(self) -> StorageIter<'r, Self::Storage> where
    U: ReadOnlyOp<'a>, 

pub fn iter_mut(
    self
) -> StorageIterMut<'r, Self::Storage, <Self::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, Self::Storage>,
    Self::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, Self::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, Self::Storage>,
    Self::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, Self::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, Self::Storage>, 

pub fn par_iter(self) -> ParStorageIter<'r, Self::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, Self::Storage>,
    Self::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, Self::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, Self::Storage>,
    Self::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, Self::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, Self::Storage>, 

Loading content...

Implementations on Foreign Types

impl<'a, 'r, S1, U1, S2, U2, S3, U3, S4, U4, S5, U5, S6, U6, S7, U7> TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)> for (S1, S2, S3, S4, S5, S6, S7) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    U4: UnorderedData<'a> + 'r,
    U5: UnorderedData<'a> + 'r,
    U6: UnorderedData<'a> + 'r,
    U7: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S4: StorageEntitiesExt<'a, U4> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    S5: StorageEntitiesExt<'a, U5> + 'r,
    S6: StorageEntitiesExt<'a, U6> + 'r,
    S7: StorageEntitiesExt<'a, U7> + 'r,
    <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,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>,
    <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage: StorageRef<'r>,
    <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage: StorageRef<'r>,
    <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage: StorageRef<'r>,
    <S7 as StorageEntitiesExt<'a, U7>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef7<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage, <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage, <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage, <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage, <S7 as StorageEntitiesExt<'a, U7>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage, <<(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2, S3, U3, S4, U4, S5, U5, S6, U6> TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)> for (S1, S2, S3, S4, S5, S6) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    U4: UnorderedData<'a> + 'r,
    U5: UnorderedData<'a> + 'r,
    U6: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S4: StorageEntitiesExt<'a, U4> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    S5: StorageEntitiesExt<'a, U5> + 'r,
    S6: StorageEntitiesExt<'a, U6> + 'r,
    <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,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>,
    <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage: StorageRef<'r>,
    <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage: StorageRef<'r>,
    <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef6<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage, <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage, <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage, <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage, <<(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2, S3, U3, S4, U4, S5, U5, S6, U6, S7, U7, S8, U8> TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)> for (S1, S2, S3, S4, S5, S6, S7, S8) where
    'a: 'r,
    U8: UnorderedData<'a> + 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    U4: UnorderedData<'a> + 'r,
    U5: UnorderedData<'a> + 'r,
    U6: UnorderedData<'a> + 'r,
    U7: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S4: StorageEntitiesExt<'a, U4> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    S5: StorageEntitiesExt<'a, U5> + 'r,
    S6: StorageEntitiesExt<'a, U6> + 'r,
    S7: StorageEntitiesExt<'a, U7> + 'r,
    S8: StorageEntitiesExt<'a, U8> + 'r,
    <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,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>,
    <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage: StorageRef<'r>,
    <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage: StorageRef<'r>,
    <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage: StorageRef<'r>,
    <S7 as StorageEntitiesExt<'a, U7>>::IntoStorage: StorageRef<'r>,
    <S8 as StorageEntitiesExt<'a, U8>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef8<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage, <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage, <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage, <S6 as StorageEntitiesExt<'a, U6>>::IntoStorage, <S7 as StorageEntitiesExt<'a, U7>>::IntoStorage, <S8 as StorageEntitiesExt<'a, U8>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage, <<(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>,
    <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5, S6, S7, S8) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5, U6, U7, U8)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2> TupleStorageEntities<'a, 'r, (U1, U2)> for (S1, S2) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef2<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage, <<(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>,
    <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>,
    <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>,
    <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>,
    <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2) as TupleStorageEntities<'a, 'r, (U1, U2)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2, S3, U3, S4, U4, S5, U5> TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)> for (S1, S2, S3, S4, S5) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    U4: UnorderedData<'a> + 'r,
    U5: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S4: StorageEntitiesExt<'a, U4> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    S5: StorageEntitiesExt<'a, U5> + 'r,
    <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,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>,
    <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage: StorageRef<'r>,
    <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef5<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage, <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage, <S5 as StorageEntitiesExt<'a, U5>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage, <<(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>,
    <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>,
    <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>,
    <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>,
    <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4, S5) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4, U5)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2, S3, U3> TupleStorageEntities<'a, 'r, (U1, U2, U3)> for (S1, S2, S3) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef3<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage, <<(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>,
    <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>,
    <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>,
    <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>,
    <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3) as TupleStorageEntities<'a, 'r, (U1, U2, U3)>>::Storage>, 

impl<'a, 'r, S1, U1, S2, U2, S3, U3, S4, U4> TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)> for (S1, S2, S3, S4) where
    'a: 'r,
    U1: UnorderedData<'a> + 'r,
    U2: UnorderedData<'a> + 'r,
    U3: UnorderedData<'a> + 'r,
    U4: UnorderedData<'a> + 'r,
    S2: StorageEntitiesExt<'a, U2> + 'r,
    S3: StorageEntitiesExt<'a, U3> + 'r,
    S4: StorageEntitiesExt<'a, U4> + 'r,
    S1: StorageEntitiesExt<'a, U1> + 'r,
    <U1 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U2 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U3 as UnorderedData<'a>>::Storage: FastIndexExt,
    <U4 as UnorderedData<'a>>::Storage: FastIndexExt,
    <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage: StorageRef<'r>,
    <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage: StorageRef<'r>,
    <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage: StorageRef<'r>,
    <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage: StorageRef<'r>, 

type Storage = StorageRef4<'a, <S1 as StorageEntitiesExt<'a, U1>>::IntoStorage, <S2 as StorageEntitiesExt<'a, U2>>::IntoStorage, <S3 as StorageEntitiesExt<'a, U3>>::IntoStorage, <S4 as StorageEntitiesExt<'a, U4>>::IntoStorage>

pub fn iter(
    self
) -> StorageIter<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>

pub fn iter_mut(
    self
) -> StorageIterMut<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage, <<(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage as StorageRef<'r>>::Component>

pub fn iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>,
    <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>, 

pub fn iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>,
    <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage: ReadOnlyStorage, 

pub fn iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>, 

pub fn par_iter(
    self
) -> ParStorageIter<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>

pub fn par_iter_for_entities<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>,
    <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>, 

pub fn par_iter_for_entities_opt<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>,
    <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage: ReadOnlyStorage, 

pub fn par_iter_for_entities_opt_mut<E>(
    self,
    entities_iter: E
) -> <E as IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>>::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <(S1, S2, S3, S4) as TupleStorageEntities<'a, 'r, (U1, U2, U3, U4)>>::Storage>, 

Loading content...

Implementors

Loading content...