Trait aery::operations::Traverse

pub trait Traverse<E, I>
where
    E: Borrow<Entity>,
    I: IntoIterator<Item = E>,
{
    // Required methods
    fn traverse<Edge: EdgeSide>(&self, starts: I) -> TraverseAnd<&Self, Edge, I>;
    fn traverse_mut<Edge: EdgeSide>(
        &mut self,
        starts: I
    ) -> TraverseAnd<&mut Self, Edge, I>;
}

Traverse a query in breadth first order. Query must be in the form Query<(Q, Relations<RS>)> to use this API.

Examples

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

#[derive(Component)]
struct A;

#[derive(Component)]
struct B;

#[derive(Component)]
struct C;

#[derive(Component)]
struct D;

#[derive(Relation)]
struct R0;

#[derive(Relation)]
struct R1;

fn traversals(
    mut abcs: Query<((&A, &mut B, &C), Relations<(R0, R1)>)>,
    ds: Query<&D>,
    starts: Query<Entity, Root<R0>>
) {
    // descent
    abcs.traverse::<R0>(starts.iter()).for_each(|(a, b, c), _| {
        // ..
    });

    // ascent
    abcs.traverse::<Up<R0>>(starts.iter()).for_each(|(a, b, c), _| {
        // ..
    });

    // mut access
    abcs.traverse_mut::<R0>(starts.iter()).for_each(|(a, b, c), _| {
        // ..
    });

    // with joins
    abcs.traverse::<R0>(starts.iter()).for_each(|(a, b, c), edges| {
        edges.join::<R1>(&ds).for_each(|d| {
            // ..
        });
    });
}

Required Methods

fn traverse<Edge: EdgeSide>(&self, starts: I) -> TraverseAnd<&Self, Edge, I>

Traverse along an edge.

fn traverse_mut<Edge: EdgeSide>( &mut self, starts: I ) -> TraverseAnd<&mut Self, Edge, I>

Traverse along an edge with mut access.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<E, I, D, RS, F> Traverse<E, I> for Query<'_, '_, (D, Relations<RS>), F>

where E: Borrow<Entity>, I: IntoIterator<Item = E>, D: QueryData, F: QueryFilter, RS: RelationSet,

fn traverse<Edge: EdgeSide>(&self, starts: I) -> TraverseAnd<&Self, Edge, I>

fn traverse_mut<Edge: EdgeSide>( &mut self, starts: I ) -> TraverseAnd<&mut Self, Edge, I>

Implementors