Struct DecisionIngressRequest

Source

pub struct DecisionIngressRequest {
    pub request_id: DecisionRequestId,
    pub expected_revision: u64,
    pub mutation: DecisionMutation,
    pub command: Option<Box<CommandRequest>>,
}

Fields§

§request_id: DecisionRequestId§expected_revision: u64§mutation: DecisionMutation§command: Option<Box<CommandRequest>>

Implementations§

Source §

impl DecisionIngressRequest

Source

pub const fn new( request_id: DecisionRequestId, expected_revision: u64, mutation: DecisionMutation, ) -> DecisionIngressRequest

Examples found in repository ?

examples/uncertainty_resolution.rs (lines 107-111)

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

More examples

Hide additional examples

examples/decision_ticket.rs (lines 43-47)

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                    parent_ticket: None,
80                },
81            },
82        ),
83    )?;
84    canwu.step_canonical()?.expect("decision intake boundary");
85    Ok(())
86}
87
88fn refresh_aid_options(canwu: &mut Canwu, ids: DemoIds) -> Result<(), Box<dyn std::error::Error>> {
89    canwu.enqueue_decision(
90        canwu.time(),
91        0,
92        DecisionIngressRequest::new(
93            DecisionRequestId::new(3),
94            canwu.revision(),
95            DecisionMutation::ReplaceOptions {
96                ticket_id: DecisionTicketId::new(1),
97                expected_version: 1,
98                context: DecisionContext::new(
99                    "beiyang.aid-request.v1",
100                    json!({
101                        "requester": "warlord-a",
102                        "battle": "ongoing-front",
103                        "common_enemy": true,
104                        "route_confirmed": true
105                    }),
106                ),
107                options: vec![
108                    DecisionOption {
109                        action: DecisionAction::None,
110                        utility_inputs: BTreeMap::from([
111                            ("home_defense".to_owned(), 80),
112                            ("alliance".to_owned(), -40),
113                        ]),
114                        ..DecisionOption::new("decline", "Decline aid")
115                    },
116                    DecisionOption {
117                        action: DecisionAction::Command {
118                            command: serde_json::to_value(Command::OrderMovement {
119                                subject: EntityRef::Army(ids.army),
120                                destination: ids.eastern_territory,
121                                cargo: Vec::new(),
122                            })?,
123                        },
124                        utility_inputs: BTreeMap::from([
125                            ("home_defense".to_owned(), -20),
126                            ("alliance".to_owned(), 90),
127                        ]),
128                        ..DecisionOption::new("send-aid", "Send the neighboring army")
129                    },
130                ],
131            },
132        ),
133    )?;
134    canwu
135        .step_canonical()?
136        .expect("dynamic option refresh boundary");
137    Ok(())
138}

Source

pub fn with_command(self, command: CommandRequest) -> DecisionIngressRequest

Source

pub fn carries_random_evidence(&self) -> bool

Returns whether this request resolves a ticket with random draw evidence. Only a boundary ResolveDecisionRandomly directive may generate such a request; host-authored ingress cannot carry a draw.