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 knowledge_records( &self, holder: KnowledgeHolderRef, query: &KnowledgeQuery, ) -> Result<KnowledgeQueryResult, CanwuError>

Queries holder-relative records for an omniscient plugin system.

This enforces the declared canwu.core.knowledge read and returns an owned projection. It is not an actor-facing authorization API.

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

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

An archived command remains valid identity evidence, but its payload is no longer available through this view: lookup returns ErrorCode::EvidenceContentUnavailable. None means the ID has neither retained content nor a committed archive receipt.

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

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

An archived event remains valid identity evidence, but its payload is no longer available through this view: lookup returns ErrorCode::EvidenceContentUnavailable. None means the ID has neither retained content nor a committed archive receipt.

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 proposed_domain_record_version( &self, reference: &DomainRecordRef, ) -> Result<Option<DomainRecordVersionRef>, CanwuError>

Returns the exact evidence reference assigned to a domain-record version proposed earlier in the current boundary.

pub fn domain_record_version_evidence_exists( &self, reference: &DomainRecordVersionRef, ) -> Result<bool, CanwuError>

Returns whether an exact domain-record version reference is valid at this proposal-visible cut.

This validates both the record identity/version and its establishment source. Earlier same-boundary proposals are considered before retained or archived runtime evidence.

pub fn domain_records_of_kind( &self, kind: &DomainRecordKind, limit: usize, ) -> Result<Vec<DomainRecord>, CanwuError>

Returns a bounded, deterministic projection of records of one kind.

Same-boundary overlays take precedence over current state. Records are ordered by their canonical reference, so result order is replay stable.

pub fn domain_records_of_kind_after( &self, kind: &DomainRecordKind, after: Option<&DomainRecordRef>, limit: usize, ) -> Result<Vec<DomainRecord>, CanwuError>

Returns one bounded deterministic page of records after a canonical record-reference cursor.

The cursor is exclusive and must name the same kind. This keeps plugin scans bounded without imposing a 10,000-record lifetime ceiling on a domain kind. Same-boundary overlays retain the same precedence as Self::domain_records_of_kind.

pub fn knowledge_changes_by_correlation( &self, plugin: &str, producer_correlation: &str, ) -> Result<Vec<BoundaryKnowledgeChange>, CanwuError>

Finds committed knowledge changes produced with an exact correlation.

This supports next-boundary operation finalization without granting a plugin unrestricted access to unrelated knowledge payloads.

pub fn knowledge_changes_by_correlation_prefix( &self, plugin: &str, producer_correlation_prefix: &str, ) -> Result<Vec<BoundaryKnowledgeChange>, CanwuError>

Finds committed knowledge changes whose producer correlation begins with a deterministic operation prefix.

The prefix remains plugin-scoped. This is intended for bounded multi-holder operation finalization where every holder batch must keep a unique full correlation value.

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 random_range_for_operation( &self, stream: &RandomStreamKey, evidence: EvidenceRef, operation_kind: &str, application_operation_id: &str, target: RandomOperationTarget, draw_slot: u32, 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>