Struct CompositeHandler 

pub struct CompositeHandler { /* private fields */ }

A composite handler that delegates to specialized handlers based on effect type

Implementations

impl CompositeHandler

pub fn new(device_id: DeviceId, execution_mode: ExecutionMode) -> Self

Create a new composite handler

pub fn for_testing(device_id: DeviceId) -> Self

Create a composite handler for testing

pub fn for_production(device_id: DeviceId) -> Self

Create a composite handler for production

pub fn for_simulation(device_id: DeviceId, seed: u64) -> Self

Create a composite handler for simulation

pub fn register_handler( &mut self, effect_type: EffectType, handler: Box<dyn Handler>, ) -> Result<(), CompositeError>

Register a handler for a specific effect type

pub fn register_all( &mut self, options: RegisterAllOptions, ) -> Result<(), RegistryError>

Register the default handler bundle.

Requires explicit opt-in for impure handlers via RegisterAllOptions.

pub fn unregister_handler( &mut self, effect_type: EffectType, ) -> Option<Box<dyn RegistrableHandler>>

Unregister a handler for a specific effect type

pub fn has_handler(&self, effect_type: EffectType) -> bool

Check if a handler is registered for an effect type

pub fn registered_effect_types(&self) -> Vec<EffectType>

Get all registered effect types

pub fn device_id(&self) -> DeviceId

Get the device ID

Trait Implementations

impl Handler for CompositeHandler

fn execute_effect<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, effect_type: EffectType, operation: &'life1 str, parameters: &'life2 [u8], ctx: &'life3 HandlerContext, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, HandlerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute an effect with serialized parameters and return serialized result

fn execute_session<'life0, 'life1, 'async_trait>( &'life0 self, session: LocalSessionType, ctx: &'life1 HandlerContext, ) -> Pin<Box<dyn Future<Output = Result<(), HandlerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a session type

fn supports_effect(&self, effect_type: EffectType) -> bool

Check if this handler supports a specific effect type

fn execution_mode(&self) -> ExecutionMode

Get the execution mode of this handler

fn supported_effects(&self) -> Vec<EffectType>

Get supported effect types