Struct PendingMsgs 

pub struct PendingMsgs<T, M>
where
    T: Msg<M>,
    M: Sized + Clone + Tvf,
{ /* private fields */ }

ProSA pending message to keep track of the message and trigger a timeout if a message is expire This object is not thread safe, you must use it within the same Tokio thread

use std::time::Duration;
use prosa::event::pending::PendingMsgs;
use tokio::sync::mpsc::Receiver;
use prosa::core::msg::{Msg, RequestMsg, InternalMsg};
use prosa_utils::msg::simple_string_tvf::SimpleStringTvf;

async fn processing(mut queue: Receiver<InternalMsg<SimpleStringTvf>>) {
    let mut pending_msg: PendingMsgs<RequestMsg<SimpleStringTvf>, SimpleStringTvf> = Default::default();
    tokio::select! {
        Some(msg) = queue.recv() => {
            match msg {
                InternalMsg::Request(msg) => {
                    // Push in the pending message, the message will wait a timeout of 200ms
                    pending_msg.push(msg, Duration::from_millis(200));
                },
                InternalMsg::Response(msg) => {
                    let original_request: Option<RequestMsg<SimpleStringTvf>> = pending_msg.pull_msg(msg.get_id());
                    println!("Receive a response: {:?}, from original request {:?}", msg, original_request);
                },
                _ => {},
            }
        },
        Some(msg) = pending_msg.pull(), if !pending_msg.is_empty() => {
            println!("Timeout message {:?}", msg);
            // Do your processing
        },
    }
}

Implementations

impl<T, M> PendingMsgs<T, M>

where T: Msg<M>, M: Sized + Clone + Tvf,

pub fn len(&self) -> usize

Returns the number of pending messages, also referred to as its ‘length’.

pub fn capacity(&self) -> usize

Returns the capacity of the internal message map.

pub fn is_empty(&self) -> bool

Returns true if there is no pending message

pub fn with_capacity(capacity: usize) -> Self

where T: Msg<M>, M: Sized + Clone + Tvf,

Method to create a new pending message list with a specific capacity

pub fn push(&mut self, msg: T, timeout: Duration)

Method to push a pending message

pub fn push_with_id(&mut self, id: u64, msg: T, timeout: Duration)

Method to push a pending message with a custom id

pub fn pull_msg(&mut self, msg_id: u64) -> Option<T>

Method to pull a pending message to process it

pub async fn pull(&mut self) -> Option<T>

Method to wait for expired message (timeout) If there is no pending message (is_empty == true) the method return immediatelly. It doesn’t block until a message is pending

use std::time::Duration;
use tokio::sync::mpsc::Sender;
use prosa::event::pending::PendingMsgs;
use prosa::core::msg::{Msg, RequestMsg, InternalMsg};
use prosa_utils::msg::simple_string_tvf::SimpleStringTvf;

async fn processing(tvf: SimpleStringTvf, queue: Sender<InternalMsg<SimpleStringTvf>>) {
    let mut pending_msg: PendingMsgs<RequestMsg<SimpleStringTvf>, SimpleStringTvf> = Default::default();
    let mut msg: Option<RequestMsg<SimpleStringTvf>> = pending_msg.pull().await;
    assert!(msg.is_none());
    pending_msg.push(RequestMsg::new(String::from("service"), tvf, queue), Duration::from_millis(200));
    tokio::select! {
        Some(msg) = pending_msg.pull(), if !pending_msg.is_empty() => {
            println!("Timeout message {:?}", msg);
        }
    }
}

Trait Implementations

impl<T, M> Debug for PendingMsgs<T, M>

where T: Msg<M> + Debug, M: Sized + Clone + Tvf + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, M> Default for PendingMsgs<T, M>

where T: Msg<M>, M: Sized + Clone + Tvf,

fn default() -> Self

Returns the “default value” for a type.