Struct gstd::msg::CreateProgramFuture

pub struct CreateProgramFuture {
    pub waiting_reply_to: MessageId,
    pub program_id: ActorId,
}

Async functions that relate to creating programs wait for a reply from the program’s init function. These functions have the suffix _for_reply, such as crate::prog::create_program_bytes_for_reply.

To get the reply payload (in bytes), one should use .await syntax. After calling a corresponding async function, the program interrupts its execution until a reply arrives.

This future keeps the sent message identifier (MessageId) to wake the program after a reply arrives. Also, it keeps an identifier of a newly created program (ActorId).

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::CreateProgramFuture, prog, ActorId};

#[gstd::async_main]
async fn main() {
    let future: CreateProgramFuture =
        prog::create_program_bytes_for_reply(code_id, b"salt", b"PING", 0, 0)
            .expect("Unable to create a program");
    let (prog_id, reply): (ActorId, Vec<u8>) = future.await.expect("Unable to get a reply");
}

Fields

waiting_reply_to: MessageId

A message identifier for an expected reply.

program_id: ActorId

An identifier of a newly created program.

Implementations

impl CreateProgramFuture

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.

Trait Implementations

impl FusedFuture for CreateProgramFuture

fn is_terminated(&self) -> bool

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

impl Future for CreateProgramFuture

type Output = Result<(ActorId, Vec<u8>), Error>

The type of value produced on completion.

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

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