Struct StateKey

Source

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

Fields§

§namespace: String§name: String

Implementations§

Source §

impl StateKey

Source

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

Examples found in repository ?

examples/phased_boundary.rs (line 13)

11fn grain_pool() -> ReservationPoolKey {
12    ReservationPoolKey::new(
13        StateKey::new("logistics", "grain"),
14        EntityRef::Territory(TerritoryId::new(1)),
15        "grain",
16    )
17}
18
19fn offer_grain(
20    _view: &SimulationView<'_>,
21    _context: &BoundaryContext,
22) -> Result<BoundaryProposal, CanwuError> {
23    Ok(BoundaryProposal {
24        offers: vec![ReservationOffer {
25            pool: grain_pool(),
26            capacity: 10,
27        }],
28        ..BoundaryProposal::default()
29    })
30}
31
32fn request_grain(
33    _view: &SimulationView<'_>,
34    _context: &BoundaryContext,
35) -> Result<BoundaryProposal, CanwuError> {
36    Ok(BoundaryProposal {
37        requests: vec![ReservationRequest {
38            request: "daily-grain".to_owned(),
39            pool: grain_pool(),
40            quantity: 6,
41            priority: 10,
42            tie_break: "western-garrison".to_owned(),
43        }],
44        ..BoundaryProposal::default()
45    })
46}
47
48fn apply_grain(
49    view: &SimulationView<'_>,
50    _context: &BoundaryContext,
51) -> Result<BoundaryProposal, CanwuError> {
52    let reservation = ReservationRef::new("example-demand", "request", "daily-grain");
53    let allocation = view.reservation(&reservation)?.ok_or_else(|| {
54        CanwuError::new(
55            ErrorCode::InvalidBoundary,
56            "the declared grain reservation did not produce allocation evidence",
57        )
58    })?;
59    let territory = EntityRef::Territory(TerritoryId::new(1));
60    Ok(BoundaryProposal {
61        directives: vec![
62            BoundaryDirective::SetComponent {
63                state: StateKey::new("garrison", "grain"),
64                entity: territory.clone(),
65                component: "daily_grant".to_owned(),
66                value: Value::from(allocation.granted),
67                summary: format!(
68                    "Granted {} grain to the western garrison",
69                    allocation.granted
70                ),
71            },
72            BoundaryDirective::Emit {
73                event_type: "grain_allocated".to_owned(),
74                summary: "The daily grain allocation settled".to_owned(),
75                affected: vec![territory],
76            },
77        ],
78        ..BoundaryProposal::default()
79    })
80}
81
82struct SupplyPlugin;
83
84impl SimulationPlugin for SupplyPlugin {
85    fn name(&self) -> &'static str {
86        "example-supply"
87    }
88
89    fn version(&self) -> &'static str {
90        "1.0.0"
91    }
92
93    fn semantic_hash(&self) -> &'static str {
94        "5fac3fb17e5f6fc4a3c85354908d84405bb569b5816631a91f70b759c156da07"
95    }
96
97    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
98        let mut contract = BoundarySystemContract::new(
99            "offer",
100            BoundaryPhase::ReservationAndAllocation,
101            SystemCadence::Daily,
102        );
103        contract.reservation_offers = vec![StateKey::new("logistics", "grain")];
104        registrar.register_boundary_system(contract, offer_grain)
105    }
106}
107
108struct DemandPlugin;
109
110impl SimulationPlugin for DemandPlugin {
111    fn name(&self) -> &'static str {
112        "example-demand"
113    }
114
115    fn version(&self) -> &'static str {
116        "1.0.0"
117    }
118
119    fn semantic_hash(&self) -> &'static str {
120        "331b865359d4ac4a14c9bf90da665b82b4aa65ee63c195e331d8f1fa181e7029"
121    }
122
123    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
124        let mut request = BoundarySystemContract::new(
125            "request",
126            BoundaryPhase::ReservationAndAllocation,
127            SystemCadence::Daily,
128        );
129        request.reservation_requests = vec![StateKey::new("logistics", "grain")];
130        registrar.register_boundary_system(request, request_grain)?;
131
132        let mut apply = BoundarySystemContract::new(
133            "apply",
134            BoundaryPhase::DomainDeltaProposal,
135            SystemCadence::Daily,
136        );
137        apply.writes = vec![StateKey::new("garrison", "grain")];
138        apply.emits = vec!["grain_allocated".to_owned()];
139        apply.reservation_reads = vec![ReservationRef::new(
140            "example-demand",
141            "request",
142            "daily-grain",
143        )];
144        apply.visibility = StateVisibility::SameBoundary;
145        registrar.register_boundary_system(apply, apply_grain)
146    }

More examples

Hide additional examples

examples/plugin.rs (line 35)

11fn set_stance(
12    view: &SimulationView<'_>,
13    context: &CommandContext,
14    payload: &Value,
15) -> Result<Vec<SystemDirective>, CanwuError> {
16    let army = ArmyId::new(
17        payload
18            .get("army")
19            .and_then(Value::as_u64)
20            .expect("payload was validated before the handler ran"),
21    );
22    let Some(army_state) = view.army(army)? else {
23        return Err(CanwuError::new(
24            ErrorCode::ArmyNotFound,
25            format!("army {army} was not found"),
26        ));
27    };
28    if context.issuer != Issuer::Actor(army_state.commander) {
29        return Err(CanwuError::new(
30            ErrorCode::InvalidAuthority,
31            "only the army commander may set its stance",
32        ));
33    }
34    Ok(vec![SystemDirective::SetComponent {
35        state: StateKey::new("military", "stance"),
36        entity: EntityRef::Army(army),
37        component: "stance".to_owned(),
38        value: payload["stance"].clone(),
39        summary: format!("Army {army} changed stance"),
40    }])
41}
42
43impl SimulationPlugin for StancePlugin {
44    fn name(&self) -> &'static str {
45        "example-stance"
46    }
47
48    fn version(&self) -> &'static str {
49        "1.0.0"
50    }
51
52    fn semantic_hash(&self) -> &'static str {
53        "a33fb7c59ae5a17685bd94f99154c5423dc7bf70d3dbde6ef4daf73670a37d26"
54    }
55
56    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
57        registrar.register_command(
58            PluginActionDescriptor {
59                name: "set_stance".to_owned(),
60                description: "Set an army stance through an issuer-aware command".to_owned(),
61                payload_schema: PayloadSchema::Object {
62                    properties: BTreeMap::from([
63                        (
64                            "army".to_owned(),
65                            PayloadProperty {
66                                value_type: PayloadValueType::Integer,
67                                required: true,
68                            },
69                        ),
70                        (
71                            "stance".to_owned(),
72                            PayloadProperty {
73                                value_type: PayloadValueType::String,
74                                required: true,
75                            },
76                        ),
77                    ]),
78                    allow_additional: false,
79                },
80                reads: vec![StateKey::core_armies()],
81                writes: vec![StateKey::new("military", "stance")],
82            },
83            set_stance,
84        )
85    }

Source

pub fn core_armies() -> StateKey

Examples found in repository ?

examples/plugin.rs (line 80)

56    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
57        registrar.register_command(
58            PluginActionDescriptor {
59                name: "set_stance".to_owned(),
60                description: "Set an army stance through an issuer-aware command".to_owned(),
61                payload_schema: PayloadSchema::Object {
62                    properties: BTreeMap::from([
63                        (
64                            "army".to_owned(),
65                            PayloadProperty {
66                                value_type: PayloadValueType::Integer,
67                                required: true,
68                            },
69                        ),
70                        (
71                            "stance".to_owned(),
72                            PayloadProperty {
73                                value_type: PayloadValueType::String,
74                                required: true,
75                            },
76                        ),
77                    ]),
78                    allow_additional: false,
79                },
80                reads: vec![StateKey::core_armies()],
81                writes: vec![StateKey::new("military", "stance")],
82            },
83            set_stance,
84        )
85    }