Struct SparkGenericModuleDispatcher 

pub struct SparkGenericModuleDispatcher<Message, Response, CancellationMessage: SparkChannelCancellationTrait, Error> {
    pub sender: Sender<SparkGenericModuleMessage<Message, Response, CancellationMessage, Error>>,
    /* private fields */
}

A dispatcher for module types.

Fields

sender: Sender<SparkGenericModuleMessage<Message, Response, CancellationMessage, Error>>

The sender for the module dispatcher.

Implementations

impl<Message, Response, CancellationMessage, Error> SparkGenericModuleDispatcher<Message, Response, CancellationMessage, Error>

where Error: Error + Send + Sync + 'static, CancellationMessage: SparkChannelCancellationTrait,

pub const fn new( sender: Sender<SparkGenericModuleMessage<Message, Response, CancellationMessage, Error>>, ) -> Self

Creates a new module dispatcher.

Examples found in repository

examples/example_listener.rs (line 139)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set up the channel
    let (tx, rx) = mpsc::channel::<
        SparkGenericModuleMessage<
            CalculatorMessage,
            CalculationResult,
            CalculatorCancellationToken,
            SparkChannelError,
        >,
    >(100);

    // Create the cancellation token
    let is_cancelled = Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Create our handler
    let handler = CalculatorHandler {
        is_cancelled: Arc::clone(&is_cancelled),
    };

    // Create the dispatcher for clients to use
    let dispatcher = SparkGenericModuleDispatcher::new(tx);

    // Spawn the server in a separate task
    let server_handle = tokio::spawn(async move {
        run_module_server(handler, rx).await;
        println!("Server has shut down");
    });

    // Use the client dispatcher to send requests and commands

    // Send a request and get the response
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Add(5, 3)).await;

    match &result {
        Ok(calc_result) => println!("Add result: {}", calc_result.0),
        Err(e) => println!("Add error: {}", e),
    }

    // Send another request
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Multiply(4, 7)).await;

    match &result {
        Ok(calc_result) => println!("Multiply result: {}", calc_result.0),
        Err(e) => println!("Multiply error: {}", e),
    }

    // Send a command (fire and forget)
    let command_result: Result<(), SparkChannelError> = dispatcher
        .send_command::<_, Result<_, SparkChannelError>>(CalculatorMessage::Error(42))
        .await;

    println!("Command result: {:?}", command_result);

    // Wait a bit to see the output
    tokio::time::sleep(Duration::from_millis(100)).await;

    // Send a shutdown message
    let cancellation_token = CalculatorCancellationToken(CancellationToken::new());

    let _ = dispatcher
        .sender
        .send(SparkGenericModuleMessage::Shutdown(cancellation_token))
        .await;

    // Wait for server to shutdown
    let _ = server_handle.await;

    Ok(())
}

pub async fn request<Req>(&self, request: Req) -> Result<Response, Error>

where Req: Into<Message> + Send + 'static, Response: 'static + Send + AsRef<dyn Any + Send>, Result<Response, Error>: IntoResult<Response, Error, Output = Result<Response, Error>>, Error: Debug + Send + Sync + From<String> + From<&'static str>,

Sends a request and get typed response using your callback pattern.

Examples found in repository

examples/example_listener.rs (line 151)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set up the channel
    let (tx, rx) = mpsc::channel::<
        SparkGenericModuleMessage<
            CalculatorMessage,
            CalculationResult,
            CalculatorCancellationToken,
            SparkChannelError,
        >,
    >(100);

    // Create the cancellation token
    let is_cancelled = Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Create our handler
    let handler = CalculatorHandler {
        is_cancelled: Arc::clone(&is_cancelled),
    };

    // Create the dispatcher for clients to use
    let dispatcher = SparkGenericModuleDispatcher::new(tx);

    // Spawn the server in a separate task
    let server_handle = tokio::spawn(async move {
        run_module_server(handler, rx).await;
        println!("Server has shut down");
    });

    // Use the client dispatcher to send requests and commands

    // Send a request and get the response
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Add(5, 3)).await;

    match &result {
        Ok(calc_result) => println!("Add result: {}", calc_result.0),
        Err(e) => println!("Add error: {}", e),
    }

    // Send another request
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Multiply(4, 7)).await;

    match &result {
        Ok(calc_result) => println!("Multiply result: {}", calc_result.0),
        Err(e) => println!("Multiply error: {}", e),
    }

    // Send a command (fire and forget)
    let command_result: Result<(), SparkChannelError> = dispatcher
        .send_command::<_, Result<_, SparkChannelError>>(CalculatorMessage::Error(42))
        .await;

    println!("Command result: {:?}", command_result);

    // Wait a bit to see the output
    tokio::time::sleep(Duration::from_millis(100)).await;

    // Send a shutdown message
    let cancellation_token = CalculatorCancellationToken(CancellationToken::new());

    let _ = dispatcher
        .sender
        .send(SparkGenericModuleMessage::Shutdown(cancellation_token))
        .await;

    // Wait for server to shutdown
    let _ = server_handle.await;

    Ok(())
}

pub async fn send_command<C, R>(&self, command: C) -> R::Output

where C: Into<Message> + Send + 'static, R: IntoResult<(), Error>, Error: From<&'static str>,

Send a command (fire and forget).

Examples found in repository

examples/example_listener.rs (line 169)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set up the channel
    let (tx, rx) = mpsc::channel::<
        SparkGenericModuleMessage<
            CalculatorMessage,
            CalculationResult,
            CalculatorCancellationToken,
            SparkChannelError,
        >,
    >(100);

    // Create the cancellation token
    let is_cancelled = Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Create our handler
    let handler = CalculatorHandler {
        is_cancelled: Arc::clone(&is_cancelled),
    };

    // Create the dispatcher for clients to use
    let dispatcher = SparkGenericModuleDispatcher::new(tx);

    // Spawn the server in a separate task
    let server_handle = tokio::spawn(async move {
        run_module_server(handler, rx).await;
        println!("Server has shut down");
    });

    // Use the client dispatcher to send requests and commands

    // Send a request and get the response
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Add(5, 3)).await;

    match &result {
        Ok(calc_result) => println!("Add result: {}", calc_result.0),
        Err(e) => println!("Add error: {}", e),
    }

    // Send another request
    let result: Result<CalculationResult, SparkChannelError> =
        dispatcher.request(CalculatorMessage::Multiply(4, 7)).await;

    match &result {
        Ok(calc_result) => println!("Multiply result: {}", calc_result.0),
        Err(e) => println!("Multiply error: {}", e),
    }

    // Send a command (fire and forget)
    let command_result: Result<(), SparkChannelError> = dispatcher
        .send_command::<_, Result<_, SparkChannelError>>(CalculatorMessage::Error(42))
        .await;

    println!("Command result: {:?}", command_result);

    // Wait a bit to see the output
    tokio::time::sleep(Duration::from_millis(100)).await;

    // Send a shutdown message
    let cancellation_token = CalculatorCancellationToken(CancellationToken::new());

    let _ = dispatcher
        .sender
        .send(SparkGenericModuleMessage::Shutdown(cancellation_token))
        .await;

    // Wait for server to shutdown
    let _ = server_handle.await;

    Ok(())
}

Trait Implementations

impl<Message: Clone, Response: Clone, CancellationMessage: Clone + SparkChannelCancellationTrait, Error: Clone> Clone for SparkGenericModuleDispatcher<Message, Response, CancellationMessage, Error>

fn clone( &self, ) -> SparkGenericModuleDispatcher<Message, Response, CancellationMessage, Error>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.