Struct constellation::EntityIteratorBuilder

pub struct EntityIteratorBuilder<'a, R, W> { /* fields omitted */ }

Provides methods for efficiently iterating through entity resources.

Methods

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

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.

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

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.

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

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.

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, 

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.

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

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.

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, 

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.

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

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.

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

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.

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

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.

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, 

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.

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

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.

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, 

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.

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, 

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.

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, 

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.

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

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.

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, 

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.

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

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.

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, 

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.