Struct ExecutableEngineRegistrationConfig 

pub struct ExecutableEngineRegistrationConfig<B> { /* private fields */ }

Typed configuration for assembling an executable engine registration.

The backend, event domain, ingress contract, and optional cache owner are kept together with the shared provider metadata until the runtime creates the complete execution witness.

Examples

use std::sync::Arc;

use tenferro_runtime::{
    CoreCapabilityBundle, EngineId, EngineRegistrationMetadata,
    ExecutableEngineRegistrationConfig, EventDomainDriver, HardwareClassId,
    ImmediateEventDomainDriver, InputIngressContract, InputPlacementContract,
    InputSignatureContract, ProviderDeviceIdentity, ProviderId, ResidentOutputContract,
    RuntimeInputContract, StorageClass,
};

fn make_config<B>(backend: B) -> ExecutableEngineRegistrationConfig<B> {
    let engine_id = EngineId::new("example.engine.v1").unwrap();
    let provider = ProviderDeviceIdentity::new(
        ProviderId::new("example.provider").unwrap(),
        "device:0",
    )
    .unwrap();
    let hardware = HardwareClassId::new("example.hardware.v1").unwrap();
    let storage = StorageClass::new("example.storage.v1").unwrap();
    let metadata = EngineRegistrationMetadata::new(
        engine_id,
        provider,
        hardware,
        Arc::from([storage.clone()]),
        storage,
        CoreCapabilityBundle::default(),
    );
    let ingress = InputIngressContract::new(
        InputPlacementContract::new(|_, _| true),
        InputSignatureContract::new(|_, _, _, _| true),
        RuntimeInputContract::new(|_, _| true),
        ResidentOutputContract::new(|_, _| true),
    );
    let event_domain_driver: Arc<dyn EventDomainDriver> =
        Arc::new(ImmediateEventDomainDriver::new());
    ExecutableEngineRegistrationConfig::new(
        metadata,
        backend,
        event_domain_driver,
        ingress,
        None,
    )
}

let _ = make_config(());

Implementations

impl<B> ExecutableEngineRegistrationConfig<B>

pub fn new( metadata: EngineRegistrationMetadata, backend: B, event_domain_driver: Arc<dyn EventDomainDriver>, ingress: InputIngressContract, cache_owner: Option<Arc<dyn RuntimeCacheOwner>>, ) -> Self

Construct an executable registration descriptor.

Trait Implementations

impl<B> Debug for ExecutableEngineRegistrationConfig<B>

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

Formats the value using the given formatter.