EntityIteratorBuilder

constellation

Struct EntityIteratorBuilder 

Source 
pub struct EntityIteratorBuilder<'a, R, W> { /* private fields */ }
Expand description

Provides methods for efficiently iterating through entity resources.

Implementations§

Source§

impl<'b, 'c, W0> EntityIteratorBuilder<'b, (), (&'c mut W0,)>
where W0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<&BitSet>>, &mut W0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, W0, W0Api> EntityIteratorBuilder<'b, (), (&'c mut W0,)>
where W0: EntityResource<Api = W0Api>, W0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, W0, W1> EntityIteratorBuilder<'b, (), (&'c mut W0, &'c mut W1)>
where W0: EntityResource, W1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, &BitSet>>>, &mut W0::Api, &mut W1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, W0, W0Api, W1, W1Api> EntityIteratorBuilder<'b, (), (&'c mut W0, &'c mut W1)>
where W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, W0, W1, W2> EntityIteratorBuilder<'b, (), (&'c mut W0, &'c mut W1, &'c mut W2)>
where W0: EntityResource, W1: EntityResource, W2: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>, &mut W0::Api, &mut W1::Api, &mut W2::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, W0, W0Api, W1, W1Api, W2, W2Api> EntityIteratorBuilder<'b, (), (&'c mut W0, &'c mut W1, &'c mut W2)>
where W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W2: EntityResource<Api = W2Api>, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi, W2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W2 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0> EntityIteratorBuilder<'b, (&'c R0,), ()>
where R0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<&BitSet>>, &R0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api> EntityIteratorBuilder<'b, (&'c R0,), ()>
where R0: EntityResource<Api = R0Api>, R0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, W0> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0,)>
where R0: EntityResource, W0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, &BitSet>>>, &R0::Api, &mut W0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, W0, W0Api> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0,)>
where R0: EntityResource<Api = R0Api>, W0: EntityResource<Api = W0Api>, R0Api: ComponentResourceApi, W0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, W0, W1> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0, &'c mut W1)>
where R0: EntityResource, W0: EntityResource, W1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &mut W0::Api, &mut W1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, W0, W0Api, W1, W1Api> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0, &'c mut W1)>
where R0: EntityResource<Api = R0Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, R0Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, W0, W1, W2> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0, &'c mut W1, &'c mut W2)>
where R0: EntityResource, W0: EntityResource, W1: EntityResource, W2: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &mut W0::Api, &mut W1::Api, &mut W2::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, W0, W0Api, W1, W1Api, W2, W2Api> EntityIteratorBuilder<'b, (&'c R0,), (&'c mut W0, &'c mut W1, &'c mut W2)>
where R0: EntityResource<Api = R0Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W2: EntityResource<Api = W2Api>, R0Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi, W2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W2 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1> EntityIteratorBuilder<'b, (&'c R0, &'c R1), ()>
where R0: EntityResource, R1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, &BitSet>>>, &R0::Api, &R1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1), ()>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, W0> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0,)>
where R0: EntityResource, R1: EntityResource, W0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &R1::Api, &mut W0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, W0, W0Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0,)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, W0: EntityResource<Api = W0Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, W0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, W0, W1> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0, &'c mut W1)>
where R0: EntityResource, R1: EntityResource, W0: EntityResource, W1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &R1::Api, &mut W0::Api, &mut W1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, W0, W0Api, W1, W1Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0, &'c mut W1)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, W0, W1, W3> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource, R1: EntityResource, W0: EntityResource, W1: EntityResource, W3: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &mut W0::Api, &mut W1::Api, &mut W3::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, W0, W0Api, W1, W1Api, W3, W2Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W3: EntityResource<Api = W2Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi, W2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W3 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), ()>
where R0: EntityResource, R1: EntityResource, R2: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &R1::Api, &R2::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), ()>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, W0> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0,)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, W0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &R1::Api, &R2::Api, &mut W0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, W0, W0Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0,)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, W0: EntityResource<Api = W0Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, W0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, W0, W1> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0, &'c mut W1)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, W0: EntityResource, W1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &R2::Api, &mut W0::Api, &mut W1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, W0, W0Api, W1, W1Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0, &'c mut W1)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, W0, W1, W3> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, W0: EntityResource, W1: EntityResource, W3: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>, BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &R2::Api, &mut W0::Api, &mut W1::Api, &mut W3::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, W0, W0Api, W1, W1Api, W3, W2Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W3: EntityResource<Api = W2Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi, W2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W3 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, R3> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), ()>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, R3: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, &BitSet>>>>, &R0::Api, &R1::Api, &R2::Api, &R3::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, R3, R3Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), ()>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, R3: EntityResource<Api = R3Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, R3Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R3 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, R3, W0> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0,)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, R3: EntityResource, W0: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &R2::Api, &R3::Api, &mut W0::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, R3, R3Api, W0, W0Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0,)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, R3: EntityResource<Api = R3Api>, W0: EntityResource<Api = W0Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, R3Api: ComponentResourceApi, W0Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R3 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, R3, W0, W1> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0, &'c mut W1)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, R3: EntityResource, W0: EntityResource, W1: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>, BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &R2::Api, &R3::Api, &mut W0::Api, &mut W1::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, R3, R3Api, W0, W0Api, W1, W1Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0, &'c mut W1)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, R3: EntityResource<Api = R3Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, R3Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R3 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Source§

impl<'b, 'c, R0, R1, R2, R3, W0, W1, W3> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource, R1: EntityResource, R2: EntityResource, R3: EntityResource, W0: EntityResource, W1: EntityResource, W3: EntityResource,

Source

pub fn entities<'a, F, R>(&mut self, f: F) -> R
where F: FnOnce(EntityIter<'b, BitIter<BitSetAnd<BitSetAnd<&BitSet, BitSetAnd<&BitSet, &BitSet>>, BitSetAnd<BitSetAnd<&BitSet, &BitSet>, BitSetAnd<&BitSet, &BitSet>>>>>, &R0::Api, &R1::Api, &R2::Api, &R3::Api, &mut W0::Api, &mut W1::Api, &mut W3::Api) -> R + 'a,

Constructs an iterator which yields each entity with data stored in all given entity resources.

This function borrows each resource, preventing mutation of the resource for the duration of its’ scope. However, the user is provided with restricted APIs for each resource which may allow mutable access to entity data stored within the resource, without allowing any operations which would invalidate the entity iterator.

Source§

impl<'b, 'c, R0, R0Api, R1, R1Api, R2, R2Api, R3, R3Api, W0, W0Api, W1, W1Api, W3, W2Api> EntityIteratorBuilder<'b, (&'c R0, &'c R1, &'c R2, &'c R3), (&'c mut W0, &'c mut W1, &'c mut W3)>
where R0: EntityResource<Api = R0Api>, R1: EntityResource<Api = R1Api>, R2: EntityResource<Api = R2Api>, R3: EntityResource<Api = R3Api>, W0: EntityResource<Api = W0Api>, W1: EntityResource<Api = W1Api>, W3: EntityResource<Api = W2Api>, R0Api: ComponentResourceApi, R1Api: ComponentResourceApi, R2Api: ComponentResourceApi, R3Api: ComponentResourceApi, W0Api: ComponentResourceApi, W1Api: ComponentResourceApi, W2Api: ComponentResourceApi,

Source

pub fn components<'a, F>(&mut self, f: F)
where F: FnMut(Entity, &<<R0 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R1 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R2 as EntityResource>::Api as ComponentResourceApi>::Component, &<<R3 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W0 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W1 as EntityResource>::Api as ComponentResourceApi>::Component, &mut <<W3 as EntityResource>::Api as ComponentResourceApi>::Component) + 'a,

Constructs an iterator which yields the components associated with all entities which have data stored in all of the given resources.

Auto Trait Implementations§

§

impl<'a, R, W> Freeze for EntityIteratorBuilder<'a, R, W>
where R: Freeze, W: Freeze,

§

impl<'a, R, W> RefUnwindSafe for EntityIteratorBuilder<'a, R, W>
where R: RefUnwindSafe, W: RefUnwindSafe,

§

impl<'a, R, W> Send for EntityIteratorBuilder<'a, R, W>
where R: Send, W: Send,

§

impl<'a, R, W> Sync for EntityIteratorBuilder<'a, R, W>
where R: Sync, W: Sync,

§

impl<'a, R, W> Unpin for EntityIteratorBuilder<'a, R, W>
where R: Unpin, W: Unpin,

§

impl<'a, R, W> UnwindSafe for EntityIteratorBuilder<'a, R, W>
where R: UnwindSafe, W: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.