Struct BoundarySystemContract 

pub struct BoundarySystemContract {
    pub name: String,
    pub phase: BoundaryPhase,
    pub cadence: SystemCadence,
    pub reads: Vec<StateKey>,
    pub writes: Vec<StateKey>,
    pub emits: Vec<String>,
    pub reservation_offers: Vec<StateKey>,
    pub reservation_requests: Vec<StateKey>,
    pub reservation_reads: Vec<ReservationRef>,
    pub random_streams: Vec<RandomStreamKey>,
    pub visibility: StateVisibility,
}

Fields

name: String

phase: BoundaryPhase

cadence: SystemCadence

reads: Vec<StateKey>

writes: Vec<StateKey>

emits: Vec<String>

reservation_offers: Vec<StateKey>

reservation_requests: Vec<StateKey>

reservation_reads: Vec<ReservationRef>

random_streams: Vec<RandomStreamKey>

visibility: StateVisibility

Implementations

impl BoundarySystemContract

pub fn new( name: impl Into<String>, phase: BoundaryPhase, cadence: SystemCadence, ) -> BoundarySystemContract

Examples found in repository

examples/phased_boundary.rs (lines 98-102)

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

Trait Implementations

impl Clone for BoundarySystemContract

fn clone(&self) -> BoundarySystemContract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoundarySystemContract

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BoundarySystemContract

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BoundarySystemContract

impl PartialEq for BoundarySystemContract

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for BoundarySystemContract

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 BoundarySystemContract