Struct rinecs::operators::Sto

pub struct Sto<'a, S: UnorderedData<'a>>(_, _);

Used as a argument in storages systems, wraps the storage for an operator or query

#[system_storages(name = "System")]
fn system(mut pos: Sto<Write<Pos>>, vel: Sto<Read<Vel>>) {
    for (pos, vel) in (&mut pos, &vel).iter_mut(){
        pos.0 += vel.0
    }
}

An Sto of any operator can be directly iterated calling iter on it or combined with other storages to iterate only over those entities that match the full query.

To combine bmore than one storage one can use a tuple of them or a tuple of references to them in case they’ll be used more than once. Write operators or tuple of operators need a mutable reference.

#[system_storages(name = "System")]
fn system(mut pos: Sto<Write<Pos>>, vel: Sto<Read<Vel>>) {
    for (pos, vel) in (&mut pos, &vel).iter_mut(){
        pos.0 += vel.0
    }
    for pos in pos.iter_mut(){
        // ...
    }
}

Implementations

impl<'a, S: UnorderedData<'a>> Sto<'a, S>

pub fn new(storage: Option<S::Storage>, entities: Entities<'a>) -> Self

pub fn unwrap(self) -> Self

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: StorageRef<'r> + ReadOnlyStorage, 

pub fn get(
    &'r self,
    entity: &Entity
) -> Option<<S::Storage as StorageRef<'r>>::Component>

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: StorageRef<'r>, 

pub fn get_mut(
    &'r mut self,
    entity: &Entity
) -> Option<<S::Storage as StorageRef<'r>>::Component>

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: OptionStorage<'r>,
    S::Storage: IntoSendStorage<'r>,
    <S::Storage as IntoSendStorage<'r>>::SendStorage: ReadOnlyStorage, 

pub fn iter(&'r self) -> <S::Storage as OptionStorage<'r>>::Iter

pub fn iter_for_entities<E>(&'r self, entities_iter: E) -> E::IntoEntitiesIter where
    E: IntoEntitiesIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn iter_for_entities_opt<E>(
    &'r self,
    entities_iter: E
) -> E::IntoEntitiesOptIter where
    E: IntoEntitiesIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn as_send_storage(
    &'r self
) -> SendSto<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage> where
    S::Storage: 'r, 

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: OptionStorageMut<'r>,
    S::Storage: IntoSendStorage<'r>, 

pub fn iter_mut(&'r mut self) -> <S::Storage as OptionStorageMut<'r>>::IterMut

pub fn iter_for_entities_mut<E>(
    &'r mut self,
    entities_iter: E
) -> E::IntoEntitiesIterMut where
    E: IntoEntitiesIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn iter_for_entities_opt_mut<E>(
    &'r mut self,
    entities_iter: E
) -> E::IntoEntitiesOptIterMut where
    E: IntoEntitiesIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn as_send_storage_mut(
    &'r mut self
) -> SendSto<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage> where
    S::Storage: 'r, 

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: ParOptionStorage<'r>,
    S::Storage: IntoSendStorage<'r>,
    <S::Storage as IntoSendStorage<'r>>::SendStorage: ReadOnlyStorage, 

pub fn par_iter(&'r self) -> <S::Storage as ParOptionStorage<'r>>::ParIter

pub fn par_iter_for_entities<E>(
    &'r self,
    entities_iter: E
) -> E::IntoEntitiesParIter where
    E: IntoEntitiesParIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn par_iter_for_entities_opt<E>(
    &'r self,
    entities_iter: E
) -> E::IntoEntitiesOptParIter where
    E: IntoEntitiesParIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

impl<'a, 'r, S> Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: ParOptionStorageMut<'r>,
    S::Storage: IntoSendStorage<'r>, 

pub fn par_iter_mut(
    &'r mut self
) -> <S::Storage as ParOptionStorageMut<'r>>::ParIterMut

pub fn par_iter_for_entities_mut<E>(
    &'r mut self,
    entities_iter: E
) -> E::IntoEntitiesParIterMut where
    E: IntoEntitiesParIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

pub fn par_iter_for_entities_opt_mut<E>(
    &'r mut self,
    entities_iter: E
) -> E::IntoEntitiesOptParIterMut where
    E: IntoEntitiesParIterator<'r, <S::Storage as IntoSendStorage<'r>>::SendStorage>, 

Trait Implementations

impl<'a, U1, U2> IntoStorages for Sto<'a, (U1, U2)> where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U1::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>)

fn into_storages(self) -> Self::Storages

impl<'a, U1, U2, U3> IntoStorages for Sto<'a, (U1, U2, U3)> where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U1::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>,
    U3::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>)

fn into_storages(self) -> Self::Storages

impl<'a, U1, U2, U3, U4> IntoStorages for Sto<'a, (U1, U2, U3, U4)> where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U1::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>,
    U3::Storage: FastIndexExt + StorageRef<'a>,
    U4::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>, Sto<'a, U4>)

fn into_storages(self) -> Self::Storages

impl<'a, U1, U2, U3, U4, U5> IntoStorages for Sto<'a, (U1, U2, U3, U4, U5)> where
    U1: UnorderedData<'a>,
    U2: UnorderedData<'a>,
    U3: UnorderedData<'a>,
    U4: UnorderedData<'a>,
    U5: UnorderedData<'a>,
    U1::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>,
    U3::Storage: FastIndexExt + StorageRef<'a>,
    U4::Storage: FastIndexExt + StorageRef<'a>,
    U5::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>, Sto<'a, U4>, Sto<'a, U5>)

fn into_storages(self) -> Self::Storages

impl<'a, U1, U2, U3, U4, U5, U6> IntoStorages for Sto<'a, (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::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>,
    U3::Storage: FastIndexExt + StorageRef<'a>,
    U4::Storage: FastIndexExt + StorageRef<'a>,
    U5::Storage: FastIndexExt + StorageRef<'a>,
    U6::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>, Sto<'a, U4>, Sto<'a, U5>, Sto<'a, U6>)

fn into_storages(self) -> Self::Storages

impl<'a, U1, U2, U3, U4, U5, U6, U7> IntoStorages for Sto<'a, (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::Storage: FastIndexExt + StorageRef<'a>,
    U2::Storage: FastIndexExt + StorageRef<'a>,
    U3::Storage: FastIndexExt + StorageRef<'a>,
    U4::Storage: FastIndexExt + StorageRef<'a>,
    U5::Storage: FastIndexExt + StorageRef<'a>,
    U6::Storage: FastIndexExt + StorageRef<'a>,
    U7::Storage: FastIndexExt + StorageRef<'a>, 

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>, Sto<'a, U4>, Sto<'a, U5>, Sto<'a, U6>, Sto<'a, U7>)

fn into_storages(self) -> Self::Storages

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

type Storages = (Sto<'a, U1>, Sto<'a, U2>, Sto<'a, U3>, Sto<'a, U4>, Sto<'a, U5>, Sto<'a, U6>, Sto<'a, U7>, Sto<'a, U8>)

fn into_storages(self) -> Self::Storages

impl<'r, 'a, S> StorageEntitiesExt<'a, S> for &'r mut Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: StorageRef<'r> + IntoSendStorage<'r>, 

type Component = <S::Storage as StorageRef<'r>>::Component

type IntoStorage = <S::Storage as IntoSendStorage<'r>>::SendStorage

fn into_storage(self) -> Option<Self::IntoStorage>

fn entities(&self) -> &Entities<'a>

fn get(self, entity: &Entity) -> Option<Self::Component>

impl<'a, 'r, S> StorageEntitiesExt<'a, S> for &'r Sto<'a, S> where
    S: UnorderedData<'a>,
    S::Storage: StorageRef<'r> + IntoSendStorage<'r> + ReadOnlyStorage + 'r, 

type Component = <S::Storage as StorageRef<'r>>::Component

type IntoStorage = <S::Storage as IntoSendStorage<'r>>::SendStorage

fn into_storage(self) -> Option<Self::IntoStorage>

fn entities(&self) -> &Entities<'a>

fn get(self, entity: &Entity) -> Option<Self::Component>

impl<'a, S> StorageWrapper for Sto<'a, S> where
    S: UnorderedData<'a>, 

type Storage = <S as UnorderedData<'a>>::Storage

type Data = S