Struct gstd::msg::CodecMessageFuture

pub struct CodecMessageFuture<T> {
    pub waiting_reply_to: MessageId,
    /* private fields */
}

Same as MessageFuture, but allows decoding the reply’s payload instead of getting a byte vector.

Generic T type should implement the Decode trait.

Examples

The following example explicitly annotates variable types for demonstration purposes only. Usually, annotating them is unnecessary because they can be inferred automatically.

use gstd::{
    msg::{self, CodecMessageFuture},
    prelude::*,
};
# use gstd::ActorId;

#[derive(Decode)]
#[codec(crate = gstd::codec)]
struct Reply {
    field: String,
}

#[gstd::async_main]
async fn main() {
    # let dest = ActorId::zero();
    let future: CodecMessageFuture<Reply> =
        msg::send_bytes_for_reply_as(dest, b"PING", 0, 0).expect("Unable to send");
    let reply: Reply = future.await.expect("Unable to get a reply");
    let field: String = reply.field;
}
# fn main() {}

Fields

waiting_reply_to: MessageId

A message identifier for an expected reply.

Implementations

impl<D: Decode> CodecMessageFuture<D>

pub fn up_to(self, duration: Option<u32>) -> Result<Self>

Postpone handling for a maximum amount of blocks that could be paid, that doesn’t exceed a given duration.

pub fn exactly(self, duration: Option<u32>) -> Result<Self>

Postpone handling for a given specific amount of blocks.

pub fn handle_reply<F: FnOnce() + 'static>(self, f: F) -> Result<Self>

Execute a function when the reply is received.

This callback will be executed in reply context and consume reply gas, so adequate reply_deposit should be supplied in *_for_reply call that comes before this. Note that the hook will still be executed on reply even after original future resolves in timeout.

Examples

Send message to echo program and wait for reply.

use gstd::{ActorId, msg, debug};

#[gstd::async_main]
async fn main() {
    let dest = ActorId::from(1); // Replace with correct actor id

    msg::send_bytes_for_reply(dest, b"PING", 0, 1_000_000)
        .expect("Unable to send")
        .handle_reply(|| {
            debug!("reply code: {:?}", msg::reply_code());

            if msg::load_bytes().unwrap_or_default() == b"PONG" {
               debug!("successfully received pong");
            }
        })
        .expect("Error setting reply hook")
        .await
        .expect("Received error");
}

Panics

Panics if this is called second time.

Trait Implementations

impl<D: Decode> FusedFuture for CodecMessageFuture<D>

fn is_terminated(&self) -> bool

Returns true if the underlying future should no longer be polled.

impl<D: Decode> Future for CodecMessageFuture<D>

type Output = Result<D, Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.