Enum aery::for_each::JCF

pub enum JCF {
    Continue,
    FastForward(usize),
    Exit,
}

Control flow enum for Join operations.

Variants

Continue

Continue iterating permutations of matches.

FastForward(usize)

Skip permutations until the nth join is advanced to the next match. Useful for multiple joins to avoid unnecessary permutation iteration. Fast forwarding is an O(1) operation.

FastForward Illustration:

use bevy::prelude::*;
use aery::prelude::*;

#[derive(Component)]
struct A;

#[derive(Component)]
struct B(usize);

#[derive(Component)]
struct C(usize);

#[derive(Component)]
struct D(usize);

#[derive(Relation)]
struct R0;

#[derive(Relation)]
struct R1;

#[derive(Relation)]
struct R2;

fn setup(world: &mut World) {
    let a = world.spawn(A).id();

    for n in 0..3 {
        world.spawn(B(n)).set::<R0>(a);
        world.spawn(C(n)).set::<R1>(a);
        world.spawn(D(n)).set::<R2>(a);
    }
}

fn fast_forward(
    a: Query<(&A, Relations<(R0, R1, R2)>)>,
    b: Query<&B>,
    c: Query<&C>,
    d: Query<&D>
) {
    for (_, edges) in a.iter() {
        edges
            .join::<R0>(&b)
            .join::<R1>(&c)
            .join::<R2>(&d)
            .for_each(|(b, c, d)| {
                if c.0 == 1 { return JCF::FastForward(1) }
                println!("({}, {}, {})", b.0, c.0, d.0);
                JCF::Continue
            });
    }
}

Output:

    (0, 0, 0)
    (0, 0, 1)
    (0, 0, 2)
//  Skipped:
//  (0, 1, 0)
//  (0, 1, 1)
//  (0, 1, 2)
    (0, 2, 0)
    (0, 2, 1)
    (0, 2, 2)
    (1, 0, 0)
    (1, 0, 1)
    (1, 0, 2)
//  Skipped:
//  (1, 1, 0)
//  (1, 1, 1)
//  (1, 1, 2)
    (1, 2, 0)
    (1, 2, 1)
    (1, 2, 2)
    (2, 0, 0)
    (2, 0, 1)
    (2, 0, 2)
//  Skipped:
//  (2, 1, 0)
//  (2, 1, 1)
//  (2, 1, 2)
    (2, 2, 0)
    (2, 2, 1)
    (2, 2, 2)

Exit

Terminate the loop.

Trait Implementations

impl From<()> for JCF

fn from(_: ()) -> Self

Converts to this type from the input type.