Struct MultiEngineRouter 

pub struct MultiEngineRouter<Policy, Effects> { /* private fields */ }

Implementations

impl<Policy, Effects> MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

pub fn new( local_node_id: NodeId, policy_engine: Policy, effects: Effects, topology: Observation<Configuration>, policy_inputs: RoutingPolicyInputs, ) -> Self

pub fn register_engine( &mut self, extension: Box<dyn RouterManagedEngine>, ) -> Result<(), RouteError>

pub fn ingest_shared_topology_observation( &mut self, topology: &Arc<Observation<Configuration>>, )

pub fn ingest_topology_observation( &mut self, topology: Observation<Configuration>, )

pub fn ingest_policy_inputs(&mut self, inputs: RoutingPolicyInputs)

pub fn ingest_transport_observation( &mut self, observation: &TransportObservation, ) -> Result<(), RouteError>

pub fn recover_checkpointed_routes(&mut self) -> Result<usize, RouteError>

pub fn effects(&self) -> &Effects

pub fn effects_mut(&mut self) -> &mut Effects

pub fn local_node_id(&self) -> NodeId

pub fn registered_engine_ids(&self) -> Vec<RoutingEngineId>

pub fn registered_engine_capabilities( &self, engine_id: &RoutingEngineId, ) -> Option<RoutingEngineCapabilities>

pub fn active_route(&self, route_id: &RouteId) -> Option<&MaterializedRoute>

pub fn active_route_count(&self) -> usize

pub fn active_routes_snapshot(&self) -> Vec<MaterializedRoute>

pub fn engine_analysis_snapshot( &self, engine_id: &RoutingEngineId, ) -> Option<Box<dyn Any>>

pub fn activate_route_without_tick( &mut self, objective: &RoutingObjective, ) -> Result<MaterializedRoute, RouteError>

Proof-bearing action: selects, admits, materializes, and publishes one canonical route using the current policy inputs without advancing time.

Trait Implementations

impl<Policy, Effects> Router for MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

fn activate_route( &mut self, objective: RoutingObjective, ) -> Result<MaterializedRoute, RouteError>

fn route_commitments( &self, route_id: &RouteId, ) -> Result<Vec<RouteCommitment>, RouteError>

fn reselect_route( &mut self, route_id: &RouteId, _trigger: RouteMaintenanceTrigger, ) -> Result<MaterializedRoute, RouteError>

fn transfer_route_lease( &mut self, route_id: &RouteId, handoff: RouteSemanticHandoff, ) -> Result<MaterializedRoute, RouteError>

impl<Policy, Effects> RouterEngineRegistry for MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

fn register_engine( &mut self, extension: Box<dyn RouterManagedEngine>, ) -> Result<(), RouteError>

fn registered_engine_ids(&self) -> Vec<RoutingEngineId>

fn registered_engine_capabilities( &self, engine_id: &RoutingEngineId, ) -> Option<RoutingEngineCapabilities>

impl<Policy, Effects> RoutingControlPlane for MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

fn activate_route( &mut self, objective: RoutingObjective, ) -> Result<MaterializedRoute, RouteError>

fn maintain_route( &mut self, route_id: &RouteId, trigger: RouteMaintenanceTrigger, ) -> Result<RouterMaintenanceOutcome, RouteError>

fn advance_round(&mut self) -> Result<RouterRoundOutcome, RouteError>

Synchronous router round: consume explicit host-delivered ingress that was queued through router ingestion APIs, refresh engine-wide adaptive state, expire leases, and report canonical mutation plus host-facing progress hints.

impl<Policy, Effects> RoutingDataPlane for MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

fn forward_payload( &mut self, route_id: &RouteId, payload: &[u8], ) -> Result<(), RouteError>

fn observe_route_health( &self, route_id: &RouteId, ) -> Result<Observation<RouteHealth>, RouteError>

Health reads are observational. They must not silently become canonical route truth without an explicit control-plane publication step.

impl<Policy, Effects> RoutingMiddleware for MultiEngineRouter<Policy, Effects>

where Policy: PolicyEngine, Effects: TimeEffects + OrderEffects + StorageEffects + RouteEventLogEffects,

fn ingest_topology_observation(&mut self, topology: Observation<Configuration>)

fn ingest_policy_inputs(&mut self, inputs: RoutingPolicyInputs)

fn ingest_transport_observation( &mut self, observation: &TransportObservation, ) -> Result<(), RouteError>

fn recover_checkpointed_routes(&mut self) -> Result<usize, RouteError>