Struct SimulationView 

pub struct SimulationView<'a> { /* private fields */ }

Implementations

impl SimulationView<'_>

pub const fn time(&self) -> SimTime

pub fn army(&self, id: ArmyId) -> Result<Option<&Army>, CanwuError>

Examples found in repository

examples/plugin.rs (line 22)

fn set_stance(
    view: &SimulationView<'_>,
    context: &CommandContext,
    payload: &Value,
) -> Result<Vec<SystemDirective>, CanwuError> {
    let army = ArmyId::new(
        payload
            .get("army")
            .and_then(Value::as_u64)
            .expect("payload was validated before the handler ran"),
    );
    let Some(army_state) = view.army(army)? else {
        return Err(CanwuError::new(
            ErrorCode::ArmyNotFound,
            format!("army {army} was not found"),
        ));
    };
    if context.issuer != Issuer::Actor(army_state.commander) {
        return Err(CanwuError::new(
            ErrorCode::InvalidAuthority,
            "only the army commander may set its stance",
        ));
    }
    Ok(vec![SystemDirective::SetComponent {
        state: StateKey::new("military", "stance"),
        entity: EntityRef::Army(army),
        component: "stance".to_owned(),
        value: payload["stance"].clone(),
        summary: format!("Army {army} changed stance"),
    }])
}

pub fn person(&self, id: PersonId) -> Result<Option<&Person>, CanwuError>

pub fn government( &self, id: GovernmentId, ) -> Result<Option<&Government>, CanwuError>

pub fn territory( &self, id: TerritoryId, ) -> Result<Option<&Territory>, CanwuError>

pub fn route(&self, id: RouteId) -> Result<Option<&Route>, CanwuError>

pub fn actor_knowledge( &self, actor: PersonId, ) -> Result<Option<&ActorKnowledge>, CanwuError>

pub fn command( &self, id: CommandId, ) -> Result<Option<&CommandRecord>, CanwuError>

Resolves an exact command ID from the retained runtime journal in O(1).

A command that has already been sealed into a live archive is not available through this view and returns None.

pub fn event(&self, id: EventId) -> Result<Option<&SimEvent>, CanwuError>

Resolves an exact event ID from the retained runtime journal in O(1).

An event that has already been sealed into a live archive is not available through this view and returns None.

pub fn ingress( &self, id: IngressId, ) -> Result<Option<&IngressRecord>, CanwuError>

pub fn domain_record( &self, reference: &DomainRecordRef, ) -> Result<Option<&DomainRecord>, CanwuError>

pub fn typed_domain_record<T>( &self, reference: &TypedDomainRecordRef<T>, ) -> Result<Option<&DomainRecord>, CanwuError>

where T: DomainRecordType,

pub fn proposed_domain_record( &self, reference: &DomainRecordRef, ) -> Result<Option<&DomainRecord>, CanwuError>

pub fn proposed_typed_domain_record<T>( &self, reference: &TypedDomainRecordRef<T>, ) -> Result<Option<&DomainRecord>, CanwuError>

where T: DomainRecordType,

pub fn reservation( &self, reservation: &ReservationRef, ) -> Result<Option<&ReservationAllocation>, CanwuError>

Examples found in repository

examples/phased_boundary.rs (line 53)

fn apply_grain(
    view: &SimulationView<'_>,
    _context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    let reservation = ReservationRef::new("example-demand", "request", "daily-grain");
    let allocation = view.reservation(&reservation)?.ok_or_else(|| {
        CanwuError::new(
            ErrorCode::InvalidBoundary,
            "the declared grain reservation did not produce allocation evidence",
        )
    })?;
    let territory = EntityRef::Territory(TerritoryId::new(1));
    Ok(BoundaryProposal {
        directives: vec![
            BoundaryDirective::SetComponent {
                state: StateKey::new("garrison", "grain"),
                entity: territory.clone(),
                component: "daily_grant".to_owned(),
                value: Value::from(allocation.granted),
                summary: format!(
                    "Granted {} grain to the western garrison",
                    allocation.granted
                ),
            },
            BoundaryDirective::Emit {
                event_type: "grain_allocated".to_owned(),
                summary: "The daily grain allocation settled".to_owned(),
                affected: vec![territory],
            },
        ],
        ..BoundaryProposal::default()
    })
}

pub fn random_range( &self, stream: &RandomStreamKey, upper_exclusive: u64, purpose: &str, ) -> Result<u64, CanwuError>

pub fn component( &self, state: &StateKey, entity: &EntityRef, component: &str, ) -> Result<Option<&Value>, CanwuError>

pub fn proposed_component( &self, state: &StateKey, entity: &EntityRef, component: &str, ) -> Result<Option<&Value>, CanwuError>