Struct PropertyChangeTrigger 

pub struct PropertyChangeTrigger<E, P>
where
    E: Entity,
    P: Property<E>,
{ /* private fields */ }

Trigger criterion for writes to an entity property with particular previous and/or current values.

PropertyChangeTrigger observes PropertyChangeEvent for a specific entity/property pair and emits when a property write matches its configured previous value, current value, or both.

Construction

PropertyChangeTrigger::<E, P>::from(from)
PropertyChangeTrigger::<E, P>::to(to)
PropertyChangeTrigger::<E, P>::from_to(from, to)
PropertyChangeTrigger::<E, P>::from(from).once()
PropertyChangeTrigger::<E, P>::from(from).repeating()

Observation

The observation data passed to TriggerCriterion::emit_with is PropertyChangeTriggerEvent. It contains the entity ID, the previous property value, the current property value, and the selected TriggerMode with which the trigger was created:

pub struct PropertyChangeTriggerEvent<E, P>
where
    E: Entity,
    P: Property<E>,
{
    pub entity_id: EntityId<E>,
    pub previous: P,
    pub current: P,
    pub mode: TriggerMode,
}

Semantics

By default, the criterion uses TriggerMode::Repeating and emits for every matching property write. Call PropertyChangeTrigger::once to emit only for the first matching write, or PropertyChangeTrigger::repeating to return to the default repeating behavior.

A from constraint matches event.previous; a to constraint matches event.current; from_to requires both. Property writes are eventful even when the old and new values are equal. For example, PropertyChangeTrigger::to(Alive(false)) can match a write that sets Alive(false) when the entity was already Alive(false), and PropertyChangeTrigger::from_to(Alive(false), Alive(false)) matches that no-op write exactly.

Example

use ixa::{Context, ContextEntitiesExt, define_entity, define_property, IxaEvent};
use ixa::entity::EntityId;
use ixa::triggers::{ContextTriggersExt, PropertyChangeTrigger, TriggerCriterion};

define_entity!(Person);
define_property!(struct Alive(bool), Person, default_const = Alive(true));

#[derive(IxaEvent)]
struct FirstDeath {
    person: EntityId<Person>
}

let mut context = Context::new();

context.register_trigger(
    PropertyChangeTrigger::from_to(Alive(true), Alive(false))
        .once()
        .emit_with(|observation| FirstDeath {
            person: observation.entity_id
        }),
);

context.subscribe_to_event(|_context, _event: FirstDeath| {
    // respond when a person changes from alive to dead
});

Implementations

impl<E, P> PropertyChangeTrigger<E, P>

where E: Entity, P: Property<E>,

pub fn from(from: P) -> Self

pub fn to(to: P) -> Self

pub fn from_to(from: P, to: P) -> Self

pub fn once(self) -> Self

pub fn repeating(self) -> Self

Trait Implementations

impl<E, P> TriggerCriterion for PropertyChangeTrigger<E, P>

where E: Entity, P: Property<E>,

type Observation = PropertyChangeTriggerEvent<E, P>

The data that represents what is observed when the criterion is met. This data is passed to the handler installed for this criterion.

fn install<F>(self, context: &mut Context, on_match: F)

where F: Fn(&mut Context, Self::Observation) + 'static,

Install the criterion’s monitoring logic in context.

fn emit_with<Ev, F>(self, make_event: F) -> Trigger<Self, Ev, F>

where Ev: IxaEvent, F: Fn(Self::Observation) -> Ev + 'static,

Bind this criterion to a constructor for a concrete user event.

fn emit_default<Ev>(self) -> Trigger<Self, Ev, impl Fn(Self::Observation) -> Ev>

where Ev: IxaEvent + Default,

Bind this criterion to a default-valued concrete user event.

fn emit_value<Ev>( self, event: Ev, ) -> Trigger<Self, Ev, impl Fn(Self::Observation) -> Ev>

where Ev: IxaEvent,

Bind this criterion to a constant concrete user event value.