Struct EntityCountTrigger 

pub struct EntityCountTrigger<E: Entity> { /* private fields */ }

Trigger criterion for the count of entities of a given type.

EntityCountTrigger observes EntityCreatedEvent for a single entity type and emits when the total number of entities of that type increases to the configured threshold.

Construction

EntityCountTrigger::<E>::increases_to(threshold)

Observation

The observation data passed to TriggerCriterion::emit_with is EntityCountTriggerEvent:

pub struct EntityCountTriggerEvent<E: Entity> {
    pub entity_id: EntityId<E>,
    pub count: usize,
}

Semantics

As entities can only be created, not destroyed, the count of entities is monotonic. Thus, this criterion does not use Direction or TriggerMode.

• It fires when a creation makes the count equal to the threshold.
• The observed count always equals the threshold the trigger was created with.
• If the entity population already equals or exceeds the threshold before the trigger is registered, it will never emit.
• A threshold of 0 will not be reached by an entity creation and is therefore not allowed.

Example

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

define_entity!(Case);

// The event records which case caused us to reach the threshold and
// the value of the threshold itself (as `count`).
#[derive(IxaEvent)]
struct SecondCase {
    case_id: EntityId<Case>,
    count: usize,
}

let mut context = Context::new();

context.register_trigger(
    EntityCountTrigger::increases_to(2)
        .emit_with(|observation| SecondCase {
            case_id: observation.entity_id,
            count: observation.count,
        }),
);

context.subscribe_to_event(|_context, _event: SecondCase| {
    // respond when the second Case entity is created
});

Implementations

impl<E: Entity> EntityCountTrigger<E>

pub fn increases_to(threshold: usize) -> Self

Trait Implementations

impl<E: Entity> TriggerCriterion for EntityCountTrigger<E>

type Observation = EntityCountTriggerEvent<E>

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.