Enum aery::relation::CleanupPolicy

pub enum CleanupPolicy {
    Orphan,
    Counted,
    Recursive,
    Total,
}

Supported cleanup patterns. When entities have multiple relations with different cleanup policies each relation looks at the graph as if it were the only relation that existed. In effect the summation of their cleanup is applied.

Illustration

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

#[derive(Relation)]
struct O;

#[derive(Relation)]
#[aery(Recursive)]
struct R;

fn sys(world: &mut World) {
   let [e0, e1, e2, e3, e4, e5, e6] = std::array::from_fn(|_| world.spawn_empty().id());

   world.entity_mut(e1).set::<O>(e0).set::<R>(e0);

   world.entity_mut(e2).set::<O>(e0);
   world.entity_mut(e3).set::<O>(e1);

   world.entity_mut(e4).set::<O>(e1).set::<R>(e1);

   world.entity_mut(e5).set::<R>(e2);
   world.entity_mut(e6).set::<R>(e2);

   // Trigger cleanup
   world.entity_mut(e0).checked_despawn();

   for (entity, expected) in [
       (e0, false),
       (e1, false),
       (e2, true),
       (e3, true),
       (e4, false),
       (e5, true),
       (e6, true)
   ] {
       assert_eq!(world.get_entity(entity).is_some(), expected)
   }
}

Before cleanup:

flowchart BT E1 --R--> E0 E1 --O--> E0 E2 --O--> E0 E3 --O--> E1 E4 --R--> E1 E4 --O--> E1 E5 --R--> E2 E6 --R--> E2

After cleanup:

flowchart BT E3 E5 --R--> E2 E6 --R--> E2

Variants

Orphan

Will do no further cleanup.

Counted

Entities that are the target of counted relationships count the number of hosts they have. If it ever reaches zero they will delete themselves. This is effectively reference counting.

Recursive

When entities that are the target of recursive relationships are despawned they also recursively despawn their hosts. Unsetting does not trigger recursive cleanup.

Total

Total performs both counted and recursive cleanup.

Trait Implementations

impl Clone for CleanupPolicy

fn clone(&self) -> CleanupPolicy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for CleanupPolicy

fn eq(&self, other: &CleanupPolicy) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CleanupPolicy

impl Eq for CleanupPolicy

impl StructuralPartialEq for CleanupPolicy