Struct Fr

pub struct Fr<M: Message> { /* private fields */ }

Future Response

Response type from a handler containing a future that is to be spawned into a another task where the response will then be sent to the sender. This should be used when the response is computed in a future that can run independently from the service.

use interlink::prelude::*;
use std::time::Duration;
use tokio::time::sleep;

#[derive(Service)]
struct Test { value: String };

#[derive(Message)]
#[msg(rtype = "String")]
struct TestMessage {
    value: String,
}

impl Handler<TestMessage> for Test {
    type Response = Fr<TestMessage>;

    fn handle(&mut self, msg: TestMessage, ctx: &mut ServiceContext<Self>) -> Self::Response {
        // Additional logic can be run here before the future
        // response is created

        Fr::new(Box::pin(async move {
            // Some future that must be polled in another task
            sleep(Duration::from_millis(1000)).await;

            // You can return the response type of the message here
            "Response".to_string()
       }))
    }
}

#[tokio::test]
async fn test() {
    let service = Test { value: "Default".to_string() };
    let link = service.start();
     
    let res: String = link
        .send(TestMessage {
            value: "Example".to_string()
        })
        .await
        .unwrap();
     
    assert_eq!(&res, "Response")    

}

Implementations

impl<M> Fr<M>

where M: Message,

pub fn new(future: BoxFuture<'static, M::Response>) -> Fr<M>

Creates a new future response from the provided boxed future.

pub fn new_box<F>(future: F) -> Fr<M>

where F: Future<Output = M::Response> + Send + 'static,

Creates a Fr wrapping the provided future creating a boxed future from the provided future. Don’t use this if you’ve already boxed the future

pub fn ready(value: M::Response) -> Fr<M>

Creates a new future response for a ready future containing a value that is already ready.

Trait Implementations

impl<S, M> ResponseHandler<S, M> for Fr<M>

where S: Service, M: Message,

fn respond( self, _service: &mut S, _ctx: &mut ServiceContext<S>, tx: Option<Sender<M::Response>>, )