Struct tarantool::net_box::promise::Promise

pub struct Promise<T> { /* private fields */ }

An asynchronous net_box::Conn response.

Implementations

impl<T> Promise<T>

pub fn state(&self) -> State

Check if the promise is kept. Returns an error if one was received or if connection is closed.

pub fn try_get(self) -> TryGet<T, Error>

Check if the promise is kept and return the value. Consumes self. If you only need to check the state of the promise, use the state method.

Does not yield.

Returns:

• Ok(value) if value is available.
• Err(error) if
  • received a response with error
  • connection was closed
• Pending(self) otherwise

pub fn wait(self) -> Result<T>

Waits indefinitely until the promise is kept or the connection is closed. Consumes self.

pub fn wait_timeout(self, timeout: Duration) -> TryGet<T, Error>

Waits for the promise to be kept. Consumes self.

Assume this yields.

Returns:

• Ok(value) if promise was successfully kept within time limit.
• Err(error)
  • received a response with error
  • connection was closed
• Pending on timeout

pub fn replace_cond(&mut self, cond: Rc<Cond>) -> Rc<Cond>

Replaces the contained Cond used for wait & wait_timeout methods with the provided one. Useful if several promises need to be waited on.

Example

use tarantool::{fiber::Cond, net_box::{Conn, promise::{Promise, State}}};
use std::rc::Rc;

let c1: Conn = get_conn("addr1");
let mut p1: Promise<()> = c1.call_async("foo", ()).unwrap();
let c2: Conn = get_conn("addr2");
let mut p2: Promise<()> = c2.call_async("foo", ()).unwrap();
let cond = Rc::new(Cond::new());
p1.replace_cond(cond.clone());
p2.replace_cond(cond.clone());
cond.wait();
assert!(
    matches!(p1.state(), State::Kept | State::ReceivedError) ||
    matches!(p2.state(), State::Kept | State::ReceivedError)
)

Trait Implementations

impl<T> Debug for Promise<T>

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

Formats the value using the given formatter.