Struct PeriodicTimeTrigger 

pub struct PeriodicTimeTrigger { /* private fields */ }

Trigger criterion for regular simulation time intervals.

PeriodicTimeTrigger observes the simulation clock and emits repeatedly at a configured period and execution phase.

Construction

PeriodicTimeTrigger::every(period)
PeriodicTimeTrigger::every_with_phase(period, phase)
PeriodicTimeTrigger::every(period).with_phase(phase) // Equivalent to `every_with_phase`
PeriodicTimeTrigger::every(period).start_with_delay(delay)
PeriodicTimeTrigger::every(period).start_at(start_time)

Observation

The observation data passed to TriggerCriterion::emit_with is PeriodicTimeTriggerEvent. It contains the simulation time observed when the scheduled periodic plan runs, the configured period, and the phase used to schedule it:

pub struct PeriodicTimeTriggerEvent {
    pub time: f64,
    pub period: f64,
    pub phase: ExecutionPhase,
}

Semantics

This trigger uses the same rescheduling behavior as periodic plans: when the scheduled callback runs, the next occurrence is scheduled at current_time + period if there are still plans in the queue. Unlike Context::add_periodic_plan_with_phase, the first occurrence is seeded explicitly so it can start at the current time, after a delay, or at an absolute simulation time.

By default, the first occurrence is scheduled at context.get_current_time() when the trigger is installed, and the execution phase is ExecutionPhase::Normal.

The period must be positive, finite, and not NaN. A delay must be non-negative, finite, and not NaN. An absolute start time must be finite and not NaN; the context validates at trigger installation that it is not in the past. Builder inputs are converted to f64 before these checks are applied.

Since time is monotonic, this criterion does not use Direction or TriggerMode. It emits whenever its periodic schedule executes. If several plans are scheduled for the same time, the selected ExecutionPhase controls phase ordering.

Example

use ixa::{Context, ExecutionPhase, IxaEvent};
use ixa::triggers::{ContextTriggersExt, PeriodicTimeTrigger, TriggerCriterion};

#[derive(IxaEvent)]
struct ReportTimeReached {
    time: f64,
    period: f64,
    phase: ExecutionPhase,
}

let mut context = Context::new();

context.register_trigger(
    PeriodicTimeTrigger::every(7.0)
        .with_phase(ExecutionPhase::Last)
        .start_with_delay(7.0)
        .emit_with(|observation| ReportTimeReached {
            time: observation.time,
            period: observation.period,
            phase: observation.phase,
        }),
);

context.subscribe_to_event(|_context, _event: ReportTimeReached| {
    // collect periodic reports
});

Implementations

impl PeriodicTimeTrigger

pub fn every(period: impl Into<f64>) -> Self

pub fn every_with_phase(period: impl Into<f64>, phase: ExecutionPhase) -> Self

pub fn with_phase(self, phase: ExecutionPhase) -> Self

pub fn start_with_delay(self, delay: impl Into<f64>) -> Self

pub fn start_at(self, start_time: impl Into<f64>) -> Self

Trait Implementations

impl TriggerCriterion for PeriodicTimeTrigger

type Observation = PeriodicTimeTriggerEvent

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.