Struct BoundaryRequest 

pub struct BoundaryRequest {
    pub at: SimTime,
    pub cadences: Vec<SystemCadence>,
}

Fields

at: SimTime

cadences: Vec<SystemCadence>

Implementations

impl BoundaryRequest

pub const fn at(at: SimTime) -> BoundaryRequest

Examples found in repository

examples/phased_boundary.rs (line 155)

fn main() -> Result<(), CanwuError> {
    let mut canwu = Canwu::demo(35)?;
    canwu.register_plugin(&SupplyPlugin)?;
    canwu.register_plugin(&DemandPlugin)?;

    let receipt = canwu
        .settle_boundary(BoundaryRequest::at(canwu.time()).with_cadence(SystemCadence::Daily))?;
    assert_eq!(receipt.allocations[0].granted, 6);
    assert_eq!(canwu.boundaries()[0].emissions.len(), 2);
    Ok(())
}

examples/governance_transition.rs (line 564)

fn main() -> Result<(), CanwuError> {
    let central = CentralPlugin;
    let treasury = TreasuryPlugin;
    let county = CountyPlugin;
    let plugins: [&dyn SimulationPlugin; 3] = [&central, &treasury, &county];
    let mut canwu =
        Canwu::new_with_plugins(11, Scenario::new(SimTime::EPOCH, Vec::new()), &plugins)?;

    canwu.enqueue_plugin_ingress(canwu_api::PluginIngressRequest::new(
        CENTRAL_PLUGIN,
        ISSUE_INGRESS,
        SimTime::EPOCH,
        json!({"order_id": ORDER_ID}),
    ))?;

    let first = canwu.settle_boundary(BoundaryRequest::at(SimTime::EPOCH))?;
    assert_eq!(first.generated_ingress.len(), 2);
    assert!(canwu.typed_domain_record(&order_reference()).is_some());
    assert!(canwu.typed_domain_record(&treasury_reference()).is_none());
    assert!(canwu.typed_domain_record(&county_reference()).is_none());

    let second = canwu.settle_boundary(BoundaryRequest::at(SimTime::EPOCH))?;
    assert_eq!(second.record_change_count, 2);
    assert!(canwu.typed_domain_record(&treasury_reference()).is_some());
    assert!(canwu.typed_domain_record(&county_reference()).is_some());

    let snapshot = canwu.snapshot_json()?;
    let restored = Canwu::from_snapshot_json_with_plugins(&snapshot, &plugins)?;
    let replayed = Canwu::replay_from_journal(&plugins, &canwu.replay_journal())?;
    assert_eq!(restored.snapshot(), canwu.snapshot());
    assert_eq!(replayed.snapshot(), canwu.snapshot());

    println!(
        "relief_order={} treasury_grain={} county_grain={} exact_replay=ok",
        ORDER_ID, 600, 600
    );
    Ok(())
}

examples/uncertainty_resolution.rs (line 142)

fn enqueue_ticket(
    canwu: &mut Canwu,
    ticket_id: DecisionTicketId,
    request_offset: u64,
    controller: DecisionControllerBinding,
) -> Result<(), CanwuError> {
    let now = canwu.time();
    let controller_id = controller.id.clone();
    canwu.enqueue_decision(
        now,
        0,
        DecisionIngressRequest::new(
            DecisionRequestId::new(request_offset),
            canwu.revision(),
            DecisionMutation::RegisterController { controller },
        ),
    )?;
    canwu.enqueue_decision(
        now,
        0,
        DecisionIngressRequest::new(
            DecisionRequestId::new(request_offset + 1),
            canwu.revision(),
            DecisionMutation::Open {
                ticket: DecisionTicketDraft {
                    id: ticket_id,
                    definition: "example.law-passage".to_owned(),
                    decision_maker: EntityRef::Person(Canwu::demo_ids().commander),
                    assigned_controller: controller_id,
                    summary: "Will the proposed law pass?".to_owned(),
                    context: DecisionContext::new(
                        "example.law-passage.v1",
                        json!({
                            "supporting_seats": 72,
                            "opposing_seats": 28,
                            "public_pressure": "high"
                        }),
                    ),
                    options: vec![
                        DecisionOption::new("pass", "Pass the law"),
                        DecisionOption::new("fail", "Reject the law"),
                    ],
                    deadline: None,
                },
            },
        ),
    )?;
    canwu.settle_boundary(canwu_api::BoundaryRequest::at(now))?;
    Ok(())
}

pub fn with_cadence(self, cadence: SystemCadence) -> BoundaryRequest

Examples found in repository

examples/phased_boundary.rs (line 155)

fn main() -> Result<(), CanwuError> {
    let mut canwu = Canwu::demo(35)?;
    canwu.register_plugin(&SupplyPlugin)?;
    canwu.register_plugin(&DemandPlugin)?;

    let receipt = canwu
        .settle_boundary(BoundaryRequest::at(canwu.time()).with_cadence(SystemCadence::Daily))?;
    assert_eq!(receipt.allocations[0].granted, 6);
    assert_eq!(canwu.boundaries()[0].emissions.len(), 2);
    Ok(())
}

Trait Implementations

impl Clone for BoundaryRequest

fn clone(&self) -> BoundaryRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoundaryRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BoundaryRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BoundaryRequest

impl PartialEq for BoundaryRequest

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for BoundaryRequest

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 BoundaryRequest