Struct SimpleProcessor 

pub struct SimpleProcessor<CFG: Config, TR, TA: TransformAttempt, TAC, CA: ConsumeAttempt, CAC, DB> { /* private fields */ }

Trait Implementations

impl<CFG, TR, TA, TAC, CA, CAC, DB> Processor for SimpleProcessor<CFG, TR, TA, TAC, CA, CAC, DB>

where CFG: Config<KeyType = String, ValueType = Vec<u8>> + Send + Sync + 'static, TR: TransformRequest, TA: TransformAttempt<TransformRequestIdentifier = TR::Identifier, CallArgsType = TR::Input, ReturnType = TR::Output>, TAC: TransformAttemptCreator<TransformRequest = TR, TransformAttempt = TA, Input = TR::Input, Output = TR::Output>, CA: ConsumeAttempt<TransformRequestIdentifier = TR::Identifier, TransformAttemptIdentifier = TA::Identifier, ConsumeVal = TR::Output>, CAC: ConsumeAttemptCreator<TransformAttempt = TA, ConsumeAttempt = CA, Output = TR::Output>, DB: Database<TransformRequest = TR, TransformAttempt = TA, ConsumeAttempt = CA, Input = TR::Input, Output = TR::Output>,

type Config = CFG

type ConsumeAttempt = CA

type ConsumeAttemptCreator = CAC

type Database = DB

type Input = <TR as TransformRequest>::Input

type Output = <TR as TransformRequest>::Output

type ProcessorError = ProcessorError

type TransformAttempt = TA

type TransformAttemptCreator = TAC

type TransformRequest = TR

fn new<'async_trait>( init_config: Arc<Mutex<CFG>>, database: Self::Database, transform_attempt_creator: Self::TransformAttemptCreator, consume_attempt_creator: Self::ConsumeAttemptCreator, ) -> Pin<Box<dyn Future<Output = (Self, ProcessorHandles<TR, TA, CA>)> + Send + 'async_trait>>

where Self: 'async_trait,

fn processor_loop<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

The main processing loop for the processor. This is where the main processing logic would go It would typically involve receiving TransfomRequests from emitter, processing them, halting the emitter when necessary, and sending results to the consumer etc.