Struct DecisionOption

Source

pub struct DecisionOption {
    pub id: String,
    pub label: String,
    pub description: String,
    pub action: DecisionAction,
    pub utility_inputs: BTreeMap<String, i64>,
    pub blockers: Vec<String>,
    pub metadata: Value,
}

Fields§

§id: String§label: String§description: String§action: DecisionAction§utility_inputs: BTreeMap<String, i64>§blockers: Vec<String>§metadata: Value

Implementations§

Source §

impl DecisionOption

Source

pub fn new(id: impl Into<String>, label: impl Into<String>) -> DecisionOption

Examples found in repository ?

examples/uncertainty_resolution.rs (line 134)

95fn enqueue_ticket(
96    canwu: &mut Canwu,
97    ticket_id: DecisionTicketId,
98    request_offset: u64,
99    controller: DecisionControllerBinding,
100) -> Result<(), CanwuError> {
101    let now = canwu.time();
102    let controller_id = controller.id.clone();
103    canwu.enqueue_decision(
104        now,
105        0,
106        DecisionIngressRequest::new(
107            DecisionRequestId::new(request_offset),
108            canwu.revision(),
109            DecisionMutation::RegisterController { controller },
110        ),
111    )?;
112    canwu.enqueue_decision(
113        now,
114        0,
115        DecisionIngressRequest::new(
116            DecisionRequestId::new(request_offset + 1),
117            canwu.revision(),
118            DecisionMutation::Open {
119                ticket: DecisionTicketDraft {
120                    id: ticket_id,
121                    definition: "example.law-passage".to_owned(),
122                    decision_maker: EntityRef::Person(Canwu::demo_ids().commander),
123                    assigned_controller: controller_id,
124                    summary: "Will the proposed law pass?".to_owned(),
125                    context: DecisionContext::new(
126                        "example.law-passage.v1",
127                        json!({
128                            "supporting_seats": 72,
129                            "opposing_seats": 28,
130                            "public_pressure": "high"
131                        }),
132                    ),
133                    options: vec![
134                        DecisionOption::new("pass", "Pass the law"),
135                        DecisionOption::new("fail", "Reject the law"),
136                    ],
137                    deadline: None,
138                },
139            },
140        ),
141    )?;
142    canwu.settle_boundary(canwu_api::BoundaryRequest::at(now))?;
143    Ok(())
144}

More examples

Hide additional examples

examples/decision_ticket.rs (line 76)

29fn open_aid_request(canwu: &mut Canwu, ids: DemoIds) -> Result<(), Box<dyn std::error::Error>> {
30    let now = canwu.time();
31    let controller = DecisionControllerBinding::new(
32        "warlord-b-ai",
33        DecisionPolicyIdentity::new(DecisionPolicyKind::Utility, "aid-utility", "1"),
34        DecisionAuthority::Actor {
35            actor: ids.commander,
36        },
37    )
38    .with_command_subject(EntityRef::Army(ids.army));
39
40    canwu.enqueue_decision(
41        now,
42        0,
43        DecisionIngressRequest::new(
44            DecisionRequestId::new(1),
45            canwu.revision(),
46            DecisionMutation::RegisterController { controller },
47        ),
48    )?;
49    canwu.enqueue_decision(
50        now,
51        0,
52        DecisionIngressRequest::new(
53            DecisionRequestId::new(2),
54            canwu.revision(),
55            DecisionMutation::Open {
56                ticket: DecisionTicketDraft {
57                    id: DecisionTicketId::new(1),
58                    definition: "beiyang.request-military-aid".to_owned(),
59                    decision_maker: EntityRef::Person(ids.commander),
60                    assigned_controller: "warlord-b-ai".to_owned(),
61                    summary: "Neighboring warlord requests immediate military aid".to_owned(),
62                    context: DecisionContext::new(
63                        "beiyang.aid-request.v1",
64                        json!({
65                            "requester": "warlord-a",
66                            "battle": "ongoing-front",
67                            "common_enemy": true
68                        }),
69                    ),
70                    options: vec![DecisionOption {
71                        action: DecisionAction::None,
72                        utility_inputs: BTreeMap::from([
73                            ("home_defense".to_owned(), 80),
74                            ("alliance".to_owned(), -40),
75                        ]),
76                        ..DecisionOption::new("decline", "Decline aid")
77                    }],
78                    deadline: Some(now + SimDuration::days(2)),
79                },
80            },
81        ),
82    )?;
83    canwu.step_canonical()?.expect("decision intake boundary");
84    Ok(())
85}
86
87fn refresh_aid_options(canwu: &mut Canwu, ids: DemoIds) -> Result<(), Box<dyn std::error::Error>> {
88    canwu.enqueue_decision(
89        canwu.time(),
90        0,
91        DecisionIngressRequest::new(
92            DecisionRequestId::new(3),
93            canwu.revision(),
94            DecisionMutation::ReplaceOptions {
95                ticket_id: DecisionTicketId::new(1),
96                expected_version: 1,
97                context: DecisionContext::new(
98                    "beiyang.aid-request.v1",
99                    json!({
100                        "requester": "warlord-a",
101                        "battle": "ongoing-front",
102                        "common_enemy": true,
103                        "route_confirmed": true
104                    }),
105                ),
106                options: vec![
107                    DecisionOption {
108                        action: DecisionAction::None,
109                        utility_inputs: BTreeMap::from([
110                            ("home_defense".to_owned(), 80),
111                            ("alliance".to_owned(), -40),
112                        ]),
113                        ..DecisionOption::new("decline", "Decline aid")
114                    },
115                    DecisionOption {
116                        action: DecisionAction::Command {
117                            command: serde_json::to_value(Command::OrderMovement {
118                                subject: EntityRef::Army(ids.army),
119                                destination: ids.eastern_territory,
120                                cargo: Vec::new(),
121                            })?,
122                        },
123                        utility_inputs: BTreeMap::from([
124                            ("home_defense".to_owned(), -20),
125                            ("alliance".to_owned(), 90),
126                        ]),
127                        ..DecisionOption::new("send-aid", "Send the neighboring army")
128                    },
129                ],
130            },
131        ),
132    )?;
133    canwu
134        .step_canonical()?
135        .expect("dynamic option refresh boundary");
136    Ok(())
137}