Struct RPCResult 

pub struct RPCResult { /* private fields */ }

Represents a result of a RPC call. Can be awaited with or without timeout.

Example:

use maelstrom::protocol::Message;
use maelstrom::{RPCResult, Runtime, Result};
use serde::Serialize;
use tokio_context::context::Context;

async fn call<T>(ctx: Context, runtime: Runtime, node: String, msg: T) -> Result<Message>
where
    T: Serialize,
{
    let mut res: RPCResult = runtime.rpc(node, msg).await?;
    return res.done_with(ctx).await;
}

Implementations

impl RPCResult

pub fn new(msg_id: u64, rx: Receiver<Message>, runtime: Runtime) -> RPCResult

pub fn done(&mut self)

Releases RPC call resources. Drop calls Self::done().

Example:

use maelstrom::protocol::Message;
use maelstrom::{RPCResult, Runtime, Result};
use serde::Serialize;

async fn call<T>(runtime: Runtime, node: String, msg: T)
where
    T: Serialize,
{
    let _ = runtime.rpc(node, msg).await;
}

pub async fn done_with(&mut self, ctx: Context) -> Result<Message>

Acquires a RPC call response within specific timeout.

Example:

use maelstrom::protocol::Message;
use maelstrom::{RPCResult, Runtime, Result};
use serde::Serialize;
use tokio_context::context::Context;

async fn call<T>(ctx: Context, runtime: Runtime, node: String, msg: T) -> Result<Message>
where
    T: Serialize,
{
    let mut res: RPCResult = runtime.rpc(node, msg).await?;
    return res.done_with(ctx).await;
}

Trait Implementations

impl Drop for RPCResult

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Future for RPCResult

Makes RPCResult an awaitable future.

Example:

use maelstrom::protocol::Message;
use maelstrom::{RPCResult, Runtime, Result};
use serde::Serialize;

async fn call<T>(runtime: Runtime, node: String, msg: T) -> Result<Message>
where
    T: Serialize,
{
    let mut res: RPCResult = runtime.rpc(node, msg).await?;
    return res.await;
}

type Output = Result<Message, Box<dyn Error + Send + Sync>>

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.