Struct PluginRegistrar 

pub struct PluginRegistrar<'a> { /* private fields */ }

Implementations

impl PluginRegistrar<'_>

pub fn register_archive_reachability_participant( &mut self, handler: fn(&SimulationView<'_>, &dyn PluginArchiveObjectProvider, &mut ArchiveReachabilityManifest) -> Result<(), CanwuError>, ) -> Result<(), CanwuError>

pub fn register_owner_authorized_maintenance_participant( &mut self, handler: fn(&SimulationView<'_>, &OwnerAuthorizedMaintenanceRequest, OwnerAuthorizedParticipantRole) -> Result<OwnerAuthorizedParticipantDraft, CanwuError>, ) -> Result<(), CanwuError>

pub fn register_maintenance_dependency_resolver( &mut self, target_namespace: impl Into<String>, ) -> Result<(), CanwuError>

pub fn register_record_schema( &mut self, schema: DomainRecordSchema, ) -> Result<(), CanwuError>

Examples found in repository

examples/governance_transition.rs (line 441)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_record::<ReliefOrderRecord>();
        schema.payload_schema = object_schema(&[
            ("order_id", PayloadValueType::String),
            ("issued_by", PayloadValueType::String),
            ("treasury_system", PayloadValueType::String),
            ("treasury_version", PayloadValueType::Integer),
            ("treasury_disposition", PayloadValueType::String),
            ("treasury_hash", PayloadValueType::String),
            ("county_system", PayloadValueType::String),
            ("county_version", PayloadValueType::Integer),
            ("county_disposition", PayloadValueType::String),
            ("county_hash", PayloadValueType::String),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(issue_descriptor())?;

        let mut publish = BoundarySystemContract::new(
            "publish-order",
            BoundaryPhase::DomainDeltaProposal,
            SystemCadence::EventDriven,
        );
        publish.reads = vec![order_state(), StateKey::core_ingress()];
        publish.writes = vec![order_state()];
        publish.plugin_ingress_targets = vec![
            canwu_api::PluginIngressTarget {
                target_plugin: TREASURY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
            canwu_api::PluginIngressTarget {
                target_plugin: COUNTY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
        ];
        publish.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(publish, publish_order)?;

        let mut audit = BoundarySystemContract::new(
            "audit-order",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::EventDriven,
        );
        audit.reads = vec![
            order_state(),
            treasury_state(),
            county_state(),
            StateKey::core_ingress(),
        ];
        registrar.register_boundary_system(audit, audit_order)
    }
}

struct TreasuryPlugin;

impl SimulationPlugin for TreasuryPlugin {
    fn name(&self) -> &'static str {
        TREASURY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000302"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<TreasuryActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-treasury",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![treasury_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_treasury)
    }
}

struct CountyPlugin;

impl SimulationPlugin for CountyPlugin {
    fn name(&self) -> &'static str {
        COUNTY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000303"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<CountyActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-county",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![county_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_county)
    }

pub fn register_knowledge_schema( &mut self, schema: PluginKnowledgeSchema, ) -> Result<(), CanwuError>

pub fn register_schema(&mut self, schema: TypeSchema) -> Result<(), CanwuError>

pub fn register_event_audience( &mut self, event_type: impl Into<String>, audience: EventAudience, ) -> Result<(), CanwuError>

Declares the player-facing audience for one emitted plugin event type.

This policy is persisted in the plugin descriptor and is independent from the plugin system subscription graph. Event types without a declaration remain private to player-facing projections.

pub fn register_system( &mut self, contract: SystemContract, handler: fn(&SimulationView<'_>, &SimEvent) -> Result<Vec<SystemDirective>, CanwuError>, ) -> Result<(), CanwuError>

pub fn register_boundary_system( &mut self, contract: BoundarySystemContract, handler: fn(&SimulationView<'_>, &BoundaryContext) -> Result<BoundaryProposal, CanwuError>, ) -> Result<(), CanwuError>

Examples found in repository

examples/phased_boundary.rs (line 104)

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

examples/uncertainty_resolution.rs (line 92)

    fn register(&self, registrar: &mut canwu_api::PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut contract = BoundarySystemContract::new(
            "resolve-random-decision",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::Daily,
        );
        contract.reads = vec![StateKey::core_decisions()];
        contract.random_streams = vec![decision_stream()];
        registrar.register_boundary_system(contract, random_resolution_system)
    }

examples/governance_transition.rs (line 462)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_record::<ReliefOrderRecord>();
        schema.payload_schema = object_schema(&[
            ("order_id", PayloadValueType::String),
            ("issued_by", PayloadValueType::String),
            ("treasury_system", PayloadValueType::String),
            ("treasury_version", PayloadValueType::Integer),
            ("treasury_disposition", PayloadValueType::String),
            ("treasury_hash", PayloadValueType::String),
            ("county_system", PayloadValueType::String),
            ("county_version", PayloadValueType::Integer),
            ("county_disposition", PayloadValueType::String),
            ("county_hash", PayloadValueType::String),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(issue_descriptor())?;

        let mut publish = BoundarySystemContract::new(
            "publish-order",
            BoundaryPhase::DomainDeltaProposal,
            SystemCadence::EventDriven,
        );
        publish.reads = vec![order_state(), StateKey::core_ingress()];
        publish.writes = vec![order_state()];
        publish.plugin_ingress_targets = vec![
            canwu_api::PluginIngressTarget {
                target_plugin: TREASURY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
            canwu_api::PluginIngressTarget {
                target_plugin: COUNTY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
        ];
        publish.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(publish, publish_order)?;

        let mut audit = BoundarySystemContract::new(
            "audit-order",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::EventDriven,
        );
        audit.reads = vec![
            order_state(),
            treasury_state(),
            county_state(),
            StateKey::core_ingress(),
        ];
        registrar.register_boundary_system(audit, audit_order)
    }
}

struct TreasuryPlugin;

impl SimulationPlugin for TreasuryPlugin {
    fn name(&self) -> &'static str {
        TREASURY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000302"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<TreasuryActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-treasury",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![treasury_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_treasury)
    }
}

struct CountyPlugin;

impl SimulationPlugin for CountyPlugin {
    fn name(&self) -> &'static str {
        COUNTY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000303"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<CountyActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-county",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![county_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_county)
    }

pub fn register_command( &mut self, descriptor: PluginActionDescriptor, handler: fn(&SimulationView<'_>, &CommandContext, &Value) -> Result<Vec<SystemDirective>, CanwuError>, ) -> Result<(), CanwuError>

Examples found in repository

examples/plugin.rs (lines 57-84)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        registrar.register_command(
            PluginActionDescriptor {
                name: "set_stance".to_owned(),
                description: "Set an army stance through an issuer-aware command".to_owned(),
                payload_schema: PayloadSchema::Object {
                    properties: BTreeMap::from([
                        (
                            "army".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::Integer,
                                required: true,
                            },
                        ),
                        (
                            "stance".to_owned(),
                            PayloadProperty {
                                value_type: PayloadValueType::String,
                                required: true,
                            },
                        ),
                    ]),
                    allow_additional: false,
                },
                reads: vec![StateKey::core_armies()],
                writes: vec![StateKey::new("military", "stance")],
            },
            set_stance,
        )
    }

pub fn register_ingress( &mut self, descriptor: PluginIngressDescriptor, ) -> Result<(), CanwuError>

Examples found in repository

examples/governance_transition.rs (line 442)

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_record::<ReliefOrderRecord>();
        schema.payload_schema = object_schema(&[
            ("order_id", PayloadValueType::String),
            ("issued_by", PayloadValueType::String),
            ("treasury_system", PayloadValueType::String),
            ("treasury_version", PayloadValueType::Integer),
            ("treasury_disposition", PayloadValueType::String),
            ("treasury_hash", PayloadValueType::String),
            ("county_system", PayloadValueType::String),
            ("county_version", PayloadValueType::Integer),
            ("county_disposition", PayloadValueType::String),
            ("county_hash", PayloadValueType::String),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(issue_descriptor())?;

        let mut publish = BoundarySystemContract::new(
            "publish-order",
            BoundaryPhase::DomainDeltaProposal,
            SystemCadence::EventDriven,
        );
        publish.reads = vec![order_state(), StateKey::core_ingress()];
        publish.writes = vec![order_state()];
        publish.plugin_ingress_targets = vec![
            canwu_api::PluginIngressTarget {
                target_plugin: TREASURY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
            canwu_api::PluginIngressTarget {
                target_plugin: COUNTY_PLUGIN.to_owned(),
                packet_type: EXECUTE_INGRESS.to_owned(),
            },
        ];
        publish.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(publish, publish_order)?;

        let mut audit = BoundarySystemContract::new(
            "audit-order",
            BoundaryPhase::StrategicAggregation,
            SystemCadence::EventDriven,
        );
        audit.reads = vec![
            order_state(),
            treasury_state(),
            county_state(),
            StateKey::core_ingress(),
        ];
        registrar.register_boundary_system(audit, audit_order)
    }
}

struct TreasuryPlugin;

impl SimulationPlugin for TreasuryPlugin {
    fn name(&self) -> &'static str {
        TREASURY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000302"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<TreasuryActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-treasury",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![treasury_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_treasury)
    }
}

struct CountyPlugin;

impl SimulationPlugin for CountyPlugin {
    fn name(&self) -> &'static str {
        COUNTY_PLUGIN
    }

    fn version(&self) -> &'static str {
        "1"
    }

    fn semantic_hash(&self) -> &'static str {
        "0000000000000000000000000000000000000000000000000000000000000303"
    }

    fn register(&self, registrar: &mut PluginRegistrar<'_>) -> Result<(), CanwuError> {
        let mut schema = DomainRecordSchema::for_entity::<CountyActionRecord>();
        schema.payload_schema = object_schema(&[
            ("status", PayloadValueType::String),
            ("grain_units", PayloadValueType::Integer),
        ]);
        registrar.register_record_schema(schema)?;
        registrar.register_ingress(execute_descriptor())?;
        let mut prepare = BoundarySystemContract::new(
            "prepare-county",
            BoundaryPhase::HistoricalCandidateEvaluation,
            SystemCadence::EventDriven,
        );
        prepare.reads = vec![order_state(), StateKey::core_ingress()];
        prepare.writes = vec![county_state()];
        prepare.visibility = StateVisibility::SameBoundary;
        registrar.register_boundary_system(prepare, prepare_county)
    }

pub fn register_internal_ingress( &mut self, descriptor: PluginIngressDescriptor, ) -> Result<PluginIngressPermit, CanwuError>

Registers an ingress that cannot be authored through the ordinary host API and returns the opaque capability required to enqueue it.

pub fn register_internal_ingress_with_archive_retention( &mut self, descriptor: PluginIngressDescriptor, namespace: impl Into<String>, object_id_json_pointers: Vec<String>, ) -> Result<PluginIngressPermit, CanwuError>

Registers an internal ingress whose single retained archive root must equal every declared JSON-pointer field in its payload.