Struct EventQueueModel 

pub struct EventQueueModel<S, A, Store, Props, R>
where
    A: Agent,
    S: Space,
    Store: AgentStore<A>,
    R: RngCore,
{ /* private fields */ }

Continuous-time agent-based model driven by an event queue.

Type Parameters

• S - space type
• A - agent type implementing Agent
• Store - agent container implementing AgentStore<A>
• Props - user-defined model properties (use () if unused)
• R - RNG type

Example

let actions: Vec<fn(&mut MyAgent, &mut EventContext<...>)> = vec![tick_action];
let mut model = EventQueueModel::new(store, space, (), rng, actions);
model.add_event(agent_id, 0, 1.0); // fire action 0 at t+1.0
model.step_until(100.0);

Implementations

impl<S, A, Store, Props, R> EventQueueModel<S, A, Store, Props, R>

where A: PositionedAgent, S: SpaceInteraction<A>, Store: AgentStore<A>, R: RngCore,

pub fn insert_positioned_agent( &mut self, agent: A, ) -> Result<(), InteractionError<S::Error>>

Insert a positioned agent into both the store and the space atomically.

pub fn remove_positioned_agent( &mut self, id: AgentId, ) -> Result<Option<A>, InteractionError<S::Error>>

Remove a positioned agent from both the store and the space atomically.

pub fn move_positioned_agent( &mut self, id: AgentId, new_position: A::Position, ) -> Result<(), InteractionError<S::Error>>

Move a positioned agent, updating both the agent value and spatial index.

pub fn validate_space_index(&self) -> Result<(), InteractionError<S::Error>>

Validate that all stored agents are represented by the spatial index.

pub fn step_event_spatial(&mut self) -> Result<bool, InteractionError<S::Error>>

Process the next event and apply deferred add/remove actions to both the agent store and spatial index.

pub fn step_until_spatial( &mut self, t_end: f64, ) -> Result<(), InteractionError<S::Error>>

Process all events up to and including time t_end with spatially consistent deferred lifecycle updates.

pub fn run_events_spatial( &mut self, n: usize, ) -> Result<(), InteractionError<S::Error>>

Process up to n events with spatially consistent lifecycle updates.

impl<S, A, Store, Props, R> EventQueueModel<S, A, Store, Props, R>

where A: Agent, S: Space, Store: AgentStore<A>, R: RngCore,

pub fn new( agents: Store, space: S, properties: Props, rng: R, actions: Vec<fn(&mut A, &mut EventContext<'_, S, A, Props, R>)>, ) -> Self

Create a new EventQueueModel.

Arguments

• agents - pre-populated agent store.
• space - the simulation space.
• properties - user-defined model properties.
• rng - seeded random number generator.
• actions - vector of event-action functions, indexed by event_idx.

pub fn time_f64(&self) -> f64

Current model time as f64.

pub fn rng_mut(&self) -> RefMut<'_, R>

Mutable access to the model’s RNG (via RefCell).

pub fn space(&self) -> &S

Immutable reference to the simulation space.

pub fn space_mut(&mut self) -> &mut S

Mutable reference to the simulation space.

pub fn properties(&self) -> &Props

Immutable reference to user-defined properties.

pub fn properties_mut(&mut self) -> &mut Props

Mutable reference to user-defined properties.

pub fn agent(&self, id: AgentId) -> Option<Ref<'_, A>>

Borrow an agent immutably by ID.

pub fn agent_mut(&self, id: AgentId) -> Option<RefMut<'_, A>>

Borrow an agent mutably by ID.

pub fn insert_agent(&mut self, agent: A) -> Result<(), A>

Insert an agent into the store.

Returns Err(agent) if an agent with the same ID already exists.

pub fn remove_agent(&mut self, id: AgentId) -> Option<A>

Remove an agent by ID, returning it if found.

Events targeting this agent will be silently skipped when they fire.

pub fn next_id(&mut self) -> AgentId

Generate the next unused agent ID (monotonically increasing).

pub fn add_event(&mut self, agent_id: AgentId, event_idx: usize, dt: f64)

Schedule a new event at self.time + dt.

Panics

Panics if dt is negative, NaN, or infinite.

pub fn queue_len(&self) -> usize

Number of events currently in the queue.

pub fn queue_is_empty(&self) -> bool

Returns true if the event queue is empty.

pub fn peek_time(&self) -> Option<f64>

Peek at the timestamp of the next (earliest) event, if any.

pub fn step_event(&mut self) -> bool

Process the next event in the queue.

Returns true if an event was popped (even if the target agent was removed), false if the queue was empty.

pub fn step_until(&mut self, t_end: f64)

Process all events up to and including time t_end.

After this call, self.time_f64() == t_end. Events scheduled after t_end remain in the queue.

pub fn run_events(&mut self, n: usize)

Process up to n events from the queue.

Stops early if the queue is exhausted.

Trait Implementations

impl<S, A, Store, Props, R> Model for EventQueueModel<S, A, Store, Props, R>

where A: Agent, S: Space, Store: AgentStore<A>, R: RngCore,

type Agent = A

The agent type stored in this model.

type Space = S

The space type used by this model.

type Properties = Props

User-defined model properties (can be () if unused).

type Rng = R

The random number generator type.

type AgentRef<'a> = Ref<'a, A> where Self: 'a

Borrowed reference to an agent (may be Ref<'a, A> for RefCell-based stores).

type AgentRefMut<'a> = RefMut<'a, A> where Self: 'a

Mutably borrowed reference to an agent (may be RefMut<'a, A>).

fn time(&self) -> Time

Current simulation time.

fn rng_mut(&self) -> impl DerefMut<Target = Self::Rng> + '_

Mutable access to the model’s RNG.

fn space(&self) -> &Self::Space

Immutable reference to the simulation space.

fn properties(&self) -> &Self::Properties

Immutable reference to user-defined properties.

fn properties_mut(&mut self) -> &mut Self::Properties

Mutable reference to user-defined properties.

fn agent(&self, id: AgentId) -> Option<Self::AgentRef<'_>>

Look up an agent by ID, returning a borrowed reference.

fn agent_mut(&self, id: AgentId) -> Option<Self::AgentRefMut<'_>>

Look up an agent by ID, returning a mutably borrowed reference.

fn has_id(&self, id: AgentId) -> bool

Check whether an agent with the given ID exists.