Struct StateKey 

pub struct StateKey {
    pub namespace: String,
    pub name: String,
}

Fields

namespace: String

name: String

Implementations

impl StateKey

pub fn new(namespace: impl Into<String>, name: impl Into<String>) -> StateKey

Examples found in repository

examples/phased_boundary.rs (line 13)

fn grain_pool() -> ReservationPoolKey {
    ReservationPoolKey::new(
        StateKey::new("logistics", "grain"),
        EntityRef::Territory(TerritoryId::new(1)),
        "grain",
    )
}

fn offer_grain(
    _view: &SimulationView<'_>,
    _context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    Ok(BoundaryProposal {
        offers: vec![ReservationOffer {
            pool: grain_pool(),
            capacity: 10,
        }],
        ..BoundaryProposal::default()
    })
}

fn request_grain(
    _view: &SimulationView<'_>,
    _context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    Ok(BoundaryProposal {
        requests: vec![ReservationRequest {
            request: "daily-grain".to_owned(),
            pool: grain_pool(),
            quantity: 6,
            priority: 10,
            tie_break: "western-garrison".to_owned(),
        }],
        ..BoundaryProposal::default()
    })
}

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()
    })
}

struct SupplyPlugin;

impl SimulationPlugin for SupplyPlugin {
    fn name(&self) -> &'static str {
        "example-supply"
    }

    fn version(&self) -> &'static str {
        "1.0.0"
    }

    fn semantic_hash(&self) -> &'static str {
        "5fac3fb17e5f6fc4a3c85354908d84405bb569b5816631a91f70b759c156da07"
    }

    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut contract = BoundarySystemContract::new(
            "offer",
            BoundaryPhase::ReservationAndAllocation,
            SystemCadence::Daily,
        );
        contract.reservation_offers = vec![StateKey::new("logistics", "grain")];
        registrar.register_boundary_system(contract, offer_grain)
    }
}

struct DemandPlugin;

impl SimulationPlugin for DemandPlugin {
    fn name(&self) -> &'static str {
        "example-demand"
    }

    fn version(&self) -> &'static str {
        "1.0.0"
    }

    fn semantic_hash(&self) -> &'static str {
        "331b865359d4ac4a14c9bf90da665b82b4aa65ee63c195e331d8f1fa181e7029"
    }

    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut request = BoundarySystemContract::new(
            "request",
            BoundaryPhase::ReservationAndAllocation,
            SystemCadence::Daily,
        );
        request.reservation_requests = vec![StateKey::new("logistics", "grain")];
        registrar.register_boundary_system(request, request_grain)?;

        let mut apply = BoundarySystemContract::new(
            "apply",
            BoundaryPhase::DomainDeltaProposal,
            SystemCadence::Daily,
        );
        apply.writes = vec![StateKey::new("garrison", "grain")];
        apply.emits = vec!["grain_allocated".to_owned()];
        apply.reservation_reads = vec![ReservationRef::new(
            "example-demand",
            "request",
            "daily-grain",
        )];
        apply.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(apply, apply_grain)
    }

examples/plugin.rs (line 35)

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"),
    }])
}

impl SimulationPlugin for StancePlugin {
    fn name(&self) -> &'static str {
        "example-stance"
    }

    fn version(&self) -> &'static str {
        "1.0.0"
    }

    fn semantic_hash(&self) -> &'static str {
        "a33fb7c59ae5a17685bd94f99154c5423dc7bf70d3dbde6ef4daf73670a37d26"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        registrar.register_command(
            PluginActionDescriptor {
                name: "set_stance".to_owned(),
                description: "Set an army stance through an issuer-aware command".to_owned(),
                payload_schema: PayloadSchema::Object {
                    properties: BTreeMap::from([
                        (
                            "army".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::Integer,
                                required: true,
                            },
                        ),
                        (
                            "stance".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::String,
                                required: true,
                            },
                        ),
                    ]),
                    allow_additional: false,
                },
                reads: vec![StateKey::core_armies()],
                writes: vec![StateKey::new("military", "stance")],
            },
            set_stance,
        )
    }

pub fn core_people() -> StateKey

Core legacy person records. A phase-7 boundary system that declares this key as a write may propose BoundaryDirective::CreatePerson.

pub fn core_person_availability() -> StateKey

Core person life and custody state. A phase-7 or phase-10 boundary system that declares this key as a write may propose BoundaryDirective::SetPersonAvailability.

pub fn core_governments() -> StateKey

pub fn core_territories() -> StateKey

pub fn core_routes() -> StateKey

pub fn core_armies() -> StateKey

Examples found in repository

examples/plugin.rs (line 80)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        registrar.register_command(
            PluginActionDescriptor {
                name: "set_stance".to_owned(),
                description: "Set an army stance through an issuer-aware command".to_owned(),
                payload_schema: PayloadSchema::Object {
                    properties: BTreeMap::from([
                        (
                            "army".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::Integer,
                                required: true,
                            },
                        ),
                        (
                            "stance".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::String,
                                required: true,
                            },
                        ),
                    ]),
                    allow_additional: false,
                },
                reads: vec![StateKey::core_armies()],
                writes: vec![StateKey::new("military", "stance")],
            },
            set_stance,
        )
    }

pub fn core_knowledge() -> StateKey

pub fn core_commands() -> StateKey

pub fn core_events() -> StateKey

pub fn core_ingress() -> StateKey

Examples found in repository

examples/governance_transition.rs (line 449)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_record::<ReliefOrderRecord>();
        schema.payload_schema = object_schema(&[
            ("order_id", PayloadValueType::String),
            ("issued_by", PayloadValueType::String),
            ("treasury_system", PayloadValueType::String),
            ("treasury_version", PayloadValueType::Integer),
            ("treasury_disposition", PayloadValueType::String),
            ("treasury_hash", PayloadValueType::String),
            ("county_system", PayloadValueType::String),
            ("county_version", PayloadValueType::Integer),
            ("county_disposition", PayloadValueType::String),
            ("county_hash", PayloadValueType::String),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(issue_descriptor())?;

        let mut publish = BoundarySystemContract::new(
            "publish-order",
            BoundaryPhase::DomainDeltaProposal,
            SystemCadence::EventDriven,
        );
        publish.reads = vec![order_state(), StateKey::core_ingress()];
        publish.writes = vec![order_state()];
        publish.plugin_ingress_targets = vec![
            canwu_api::PluginIngressTarget {
                target_plugin: TREASURY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
            canwu_api::PluginIngressTarget {
                target_plugin: COUNTY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
        ];
        publish.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(publish, publish_order)?;

        let mut audit = BoundarySystemContract::new(
            "audit-order",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::EventDriven,
        );
        audit.reads = vec![
            order_state(),
            treasury_state(),
            county_state(),
            StateKey::core_ingress(),
        ];
        registrar.register_boundary_system(audit, audit_order)
    }
}

struct TreasuryPlugin;

impl SimulationPlugin for TreasuryPlugin {
    fn name(&self) -> &'static str {
        TREASURY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000302"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<TreasuryActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-treasury",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![treasury_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_treasury)
    }
}

struct CountyPlugin;

impl SimulationPlugin for CountyPlugin {
    fn name(&self) -> &'static str {
        COUNTY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000303"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<CountyActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-county",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![county_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_county)
    }

pub fn core_decisions() -> StateKey

Current decision controllers, tickets, and request outcomes.

Examples found in repository

examples/uncertainty_resolution.rs (line 90)

    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut contract = BoundarySystemContract::new(
            "resolve-random-decision",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::Daily,
        );
        contract.reads = vec![StateKey::core_decisions()];
        contract.random_streams = vec![decision_stream()];
        registrar.register_boundary_system(contract, random_resolution_system)
    }

pub fn core_domain_records() -> StateKey

Administrative read access to current plugin-owned domain records.

pub fn core_evidence() -> StateKey

Retained or archived boundary and random-draw evidence identities.

pub fn core_transitions() -> StateKey

Pending transition manifests and the transition audits of the current boundary. A phase-7, phase-10, or phase-12 boundary system that declares this key as a write may propose BoundaryDirective::RegisterTransitionManifest; a phase-10 system that declares it may propose BoundaryDirective::StageTransitionWrite. Reading manifests or audits requires declaring it as a read, and a reader sees only those its plugin coordinates or participates in.

Trait Implementations

impl Clone for StateKey

fn clone(&self) -> StateKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StateKey

fn deserialize<__D>( __deserializer: __D, ) -> Result<StateKey, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StateKey

impl Ord for StateKey

fn cmp(&self, other: &StateKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for StateKey

fn eq(&self, other: &StateKey) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for StateKey

fn partial_cmp(&self, other: &StateKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for StateKey

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StateKey