Trait LendingIterator 

pub trait LendingIterator: for<'a> Lifetime<'a> {
    // Required method
    fn next(&mut self) -> Option<<Self as Lifetime<'_>>::Item>;

    // Provided method
    fn for_each<F>(self, f: F)
       where Self: Sized,
             F: FnMut(<Self as Lifetime<'_>>::Item) { ... }
}

A trait similar to Iterator, where the returned Items only live until next is called again.

See also: https://sabrinajewson.org/blog/the-better-alternative-to-lifetime-gats

Examples

Unlike the regular Iterators the LendingIterator does not support for loops. A while let loop can be used instead:

while let Some(item) = iter.next() {
    println!("{item:?}");
}

See Query for more examples, since it is the only type currently implementing LendingIterator.

Required Methods

fn next(&mut self) -> Option<<Self as Lifetime<'_>>::Item>

Advances the iterator and returns the next value.

The value’s lifetime ends before next is called again.

Provided Methods

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(<Self as Lifetime<'_>>::Item),

Calls a closure on each element of the iterator.

This is an alternative to using a LendingIterator in a while let loop.

Examples

See Query for more examples, since it is the only type currently implementing LendingIterator.

use checs::{ComponentVec, IntoQuery, LendingIterator};

let ints: ComponentVec<i32> = ComponentVec::new();
let mut floats: ComponentVec<f32> = ComponentVec::new();

let query = (&ints, &mut floats).into_query();

query.for_each(|(entity, (int, float))| {
    println!("{entity:?}: ({int}, {float})");
});

Examples found in repository

examples/basic.rs (lines 45-47)

fn main() {
    let mut world = world::World::<Storage>::new();

    // Create entities with initial components.
    // Either manually...
    let player = world.spawn();
    world.insert(player, Position { x: 0, y: 0 });
    world.insert(player, Visible);
    world.insert(player, Health(80));

    // ...or by using the `spawn` macro...
    let _obstacle = checs::spawn!(world, Position { x: 1, y: 1 }, Visible);
    let _trap = checs::spawn!(world, Position { x: 2, y: 1 });

    // ...or by using `spawn_with`.
    let _enemy = world.spawn_with((Position { x: 1, y: 4 }, Visible, Health(100)));

    let storage = world.storage_mut();

    // Create a query over all entities that have `Position`, `Health`, and
    // `Visible` components.
    let query = (&storage.positions, &mut storage.healths, &storage.visibles).into_query();

    query.for_each(|(_, (_, h, _))| {
        h.0 += 10;
    });

    println!();

    let query = (&storage.positions, &storage.healths, &storage.visibles).into_query();

    query.for_each(|(e, (p, h, v))| {
        println!("{e:?} is {v:?} at ({}, {}) with {} HP", p.x, p.y, h.0);
    });
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Iter, C> LendingIterator for Query<Iter, C>

where Iter: Iterator<Item = Entity>, C: GetRefOrMut,