Struct lunatic_message_request::MessageRequest

pub struct MessageRequest<Req, Res, S = Bincode>where
    S: Serializer<Res>,{ /* private fields */ }

Message containing a request, allowing for a response to be sent back.

Message requests can be created using MessageRequest::new.

A message request should always have reply called, otherwise a process could be left waiting forever for a response (unless receive_timeout is used).

Implementations

impl<Req, Res, S> MessageRequest<Req, Res, S>where S: Serializer<Res>,

pub fn new(req: Req) -> (Self, TaggedMailbox<Res, S>)

Creates a new MessageRequest and TaggedMailbox.

The tagged mailbox can be used to wait for a response using TaggedMailbox::receive.

Internally, this method creates a tag which is shared between the message request and tagged mailbox.

pub fn into_parts(self) -> (PendingProcess<Res, S>, Req)

Splits the message request into a PendingProcess and the inner request.

This is useful if you need ownership of the inner request directly.

pub fn reply(self, res: Res)where Res: Serialize + DeserializeOwned,

Replies to the process with a response.

Examples found in repository

examples/counter.rs (line 21)

fn main() {
    let counter = spawn_link!(|mailbox: Mailbox<Message>| {
        let mut count = 0;

        loop {
            let msg = mailbox.receive();
            match msg {
                Message::Inc => count += 1,
                Message::Dec => count -= 1,
                Message::Count(req) => req.reply(count),
            }
        }
    });

    // Initial count should be 0
    let count = counter.request(Message::Count, ());
    assert_eq!(count, 0);

    // Increment count
    counter.send(Message::Inc);

    // Count should now be 1
    let count = counter.request(Message::Count, ());
    assert_eq!(count, 1);
}

Trait Implementations

impl<Req: Clone, Res: Clone, S> Clone for MessageRequest<Req, Res, S>where S: Serializer<Res> + Clone,

fn clone(&self) -> MessageRequest<Req, Res, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Req: Debug, Res: Debug, S> Debug for MessageRequest<Req, Res, S>where S: Serializer<Res> + Debug,

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

Formats the value using the given formatter.

impl<Req, Res, S> Deref for MessageRequest<Req, Res, S>where S: Serializer<Res>,

type Target = Req

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Req, Res, S> DerefMut for MessageRequest<Req, Res, S>where S: Serializer<Res>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, Req, Res, S> Deserialize<'de> for MessageRequest<Req, Res, S>where S: Serializer<Res>, Req: Serialize + for<'dee> Deserialize<'dee>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Req: PartialEq, Res: PartialEq, S> PartialEq<MessageRequest<Req, Res, S>> for MessageRequest<Req, Res, S>where S: Serializer<Res> + PartialEq,

fn eq(&self, other: &MessageRequest<Req, Res, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Req, Res, S> Serialize for MessageRequest<Req, Res, S>where S: Serializer<Res>, Req: Serialize + for<'dee> Deserialize<'dee>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Req: Copy, Res: Copy, S> Copy for MessageRequest<Req, Res, S>where S: Serializer<Res> + Copy,

impl<Req: Eq, Res: Eq, S> Eq for MessageRequest<Req, Res, S>where S: Serializer<Res> + Eq,

impl<Req, Res, S> StructuralEq for MessageRequest<Req, Res, S>where S: Serializer<Res>,

impl<Req, Res, S> StructuralPartialEq for MessageRequest<Req, Res, S>where S: Serializer<Res>,