Trait Model 

pub trait Model {
    type Agent: Agent;
    type Space: Space;
    type Properties;
    type Rng: RngCore;
    type AgentRef<'a>: Deref<Target = Self::Agent>
       where Self: 'a;
    type AgentRefMut<'a>: DerefMut<Target = Self::Agent>
       where Self: 'a;

    // Required methods
    fn time(&self) -> Time;
    fn rng_mut(&self) -> impl DerefMut<Target = Self::Rng> + '_;
    fn space(&self) -> &Self::Space;
    fn properties(&self) -> &Self::Properties;
    fn properties_mut(&mut self) -> &mut Self::Properties;
    fn agent(&self, id: AgentId) -> Option<Self::AgentRef<'_>>;
    fn agent_mut(&self, id: AgentId) -> Option<Self::AgentRefMut<'_>>;

    // Provided method
    fn has_id(&self, id: AgentId) -> bool { ... }
}

The abstract model interface.

Provides read access to the simulation state (time, space, properties, agents) and mutable access to the RNG. Concrete model types add stepping methods.

Generic Associated Types

AgentRef and AgentRefMut are GATs that allow models using interior mutability (e.g. RefCell) to return borrowed references without requiring &mut self for agent access.

Required Associated Types

type Agent: Agent

The agent type stored in this model.

type Space: Space

The space type used by this model.

type Properties

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

type Rng: RngCore

The random number generator type.

type AgentRef<'a>: Deref<Target = Self::Agent> where Self: 'a

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

type AgentRefMut<'a>: DerefMut<Target = Self::Agent> where Self: 'a

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

Required Methods

fn time(&self) -> Time

Current simulation time.

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

Mutable access to the model’s RNG.

Takes &self (not &mut self) because the RNG is stored behind interior mutability, allowing agent step functions to use it without borrowing the entire model exclusively.

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.

Provided Methods

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

Check whether an agent with the given ID exists.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

type Space = S

type Properties = Props

type Rng = R

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

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

impl<S, A, Store, Props, R, Sch> Model for StandardModel<S, A, Store, Props, R, Sch>

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

type Agent = A

type Space = S

type Properties = Props

type Rng = R

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

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