Trying to implement a custom future. Could someone please tell me if anything is obviously wrong? I see the poll() called twice, once when the .await is called and I see the poll() being called after the wake(). But poll() never seems to return Ready.
use std::{
future::Future,
pin::Pin,
task::{Context, Poll, Waker}
};
use std::sync::RwLock;
use crate::io::Buffer;
struct InnerRpcFuture
{
buffer_ : Option<Buffer>,
waker_ : Option<Waker>
}
impl InnerRpcFuture
{
fn wake_me(&self) -> ()
{
self.waker_.as_ref().unwrap().wake_by_ref();
}
fn is_ready(&self) -> bool
{
return self.buffer_.is_some();
}
}
pub struct RpcFuture
{
id_ : String,
inner_ : RwLock<InnerRpcFuture>
}
impl RpcFuture
{
pub fn new() -> Self
{
return RpcFuture {
id_ : uuid::Uuid::new_v4().to_string(),
inner_ : RwLock::new(InnerRpcFuture{
buffer_ : None,
waker_ : None
})
}
}
fn is_ready(&self) -> bool
{
let inner = self.inner_.read().unwrap();
return inner.is_ready();
}
fn get_state(&self) -> Buffer
{
let mut inner = self.inner_.write().unwrap();
return inner.buffer_.take().unwrap();
}
fn set_waker(&self, waker : Waker) -> ()
{
let mut inner = self.inner_.write().unwrap();
inner.waker_ = Some(waker);
}
pub fn set(&self, buffer : Buffer) -> ()
{
let mut inner = self.inner_.write().unwrap();
inner.buffer_ = Some(buffer);
println!("waking now {} {}", inner.is_ready(), self.id_);
inner.wake_me();
}
}
impl Future for &RpcFuture
{
type Output = Buffer;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>
{
println!("poll called {} {}", self.is_ready(), self.id_);
let fut = Pin::into_inner(self);
if fut.is_ready()
{
return Poll::Ready(fut.get_state());
}
else
{
let waker = cx.waker().clone();
fut.set_waker(waker);
return Poll::Pending;
}
}
}