Struct QueryParManyIter 

pub struct QueryParManyIter<'w, 's, D, F, E>
where
    D: IterQueryData,
    F: QueryFilter,
    E: EntityEquivalent,
{ /* private fields */ }

A parallel iterator over the unique query items generated from an Entity list.

This struct is created by the Query::par_iter_many method.

Implementations

impl<'w, 's, D, F, E> QueryParManyIter<'w, 's, D, F, E>

where D: ReadOnlyQueryData, F: QueryFilter, E: EntityEquivalent + Sync,

pub fn batching_strategy( self, strategy: BatchingStrategy, ) -> QueryParManyIter<'w, 's, D, F, E>

Changes the batching strategy used when iterating.

For more information on how this affects the resultant iteration, see BatchingStrategy.

pub fn for_each<FN>(self, func: FN)

where FN: Fn(<D as QueryData>::Item<'w, 's>) + Send + Sync + Clone,

Runs func on each query result in parallel.

Panics

If the ComputeTaskPool is not initialized. If using this from a query that is being initialized and run from the ECS scheduler, this should never panic.

pub fn for_each_init<FN, INIT, T>(self, init: INIT, func: FN)

where FN: Fn(&mut T, <D as QueryData>::Item<'w, 's>) + Send + Sync + Clone, INIT: Fn() -> T + Sync + Send + Clone,

Runs func on each query result in parallel on a value returned by init.

init may be called multiple times per thread, and the values returned may be discarded between tasks on any given thread. Callers should avoid using this function as if it were a parallel version of Iterator::fold.

Example

use bevy_utils::Parallel;
use crate::{bevy_ecs::prelude::{Component, Res, Resource, Entity}, bevy_ecs::system::Query};
use bevy_platform::prelude::Vec;

#[derive(Component)]
struct T;

#[derive(Resource)]
struct V(Vec<Entity>);

impl<'a> IntoIterator for &'a V {
// ...
}

fn system(query: Query<&T>, entities: Res<V>){
    let mut queue: Parallel<usize> = Parallel::default();
    // queue.borrow_local_mut() will get or create a thread_local queue for each task/thread;
    query.par_iter_many(&entities).for_each_init(|| queue.borrow_local_mut(),|local_queue, item| {
        **local_queue += some_expensive_operation(item);
    });

    // collect value from every thread
    let final_value: usize = queue.iter_mut().map(|v| *v).sum();
}

Panics

If the ComputeTaskPool is not initialized. If using this from a query that is being initialized and run from the ECS scheduler, this should never panic.