use mlua::{FromLua, IntoLua, Lua, Value};
use std::cell::{Cell, RefCell};
use std::collections::VecDeque;
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
use std::sync::{Arc, Mutex, PoisonError};
use std::task::{Context, Poll, Wake, Waker};
use tokio::sync::mpsc;
pub(crate) type Chan = Rc<RefCell<ChanCore>>;
pub(crate) struct ChanCore {
buf: VecDeque<Value>,
cap: usize,
closed: bool,
recv_wakers: Vec<Waker>,
send_wakers: Vec<Waker>,
source: Option<Rc<dyn HostSource>>,
offers: VecDeque<Rc<Offer>>,
waiters: VecDeque<Rc<Waiter>>,
ticker: bool,
sink: Option<Rc<dyn HostSink>>,
sink_waiters: Vec<Rc<RefCell<Waker>>>,
}
pub(crate) struct SelectMark {
claimed: Cell<bool>,
}
pub(crate) type Mark = Rc<SelectMark>;
impl SelectMark {
pub(crate) fn new() -> Mark {
Rc::new(SelectMark {
claimed: Cell::new(false),
})
}
pub(crate) fn claim(&self) {
self.claimed.set(true);
}
}
fn claimed(mark: &Option<Mark>) -> bool {
mark.as_ref().is_some_and(|m| m.claimed.get())
}
fn same_select(a: &Option<Mark>, b: &Option<Mark>) -> bool {
matches!((a, b), (Some(a), Some(b)) if Rc::ptr_eq(a, b))
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum OfferState {
Open,
Taken,
Withdrawn,
}
struct Offer {
value: RefCell<Option<Value>>,
state: Cell<OfferState>,
waker: RefCell<Waker>,
select: Option<Mark>,
}
struct Waiter {
slot: RefCell<Option<Value>>,
waker: RefCell<Waker>,
select: Option<Mark>,
}
impl ChanCore {
fn with_cap(cap: usize, source: Option<Rc<dyn HostSource>>) -> ChanCore {
ChanCore {
buf: VecDeque::new(),
cap,
closed: false,
recv_wakers: Vec::new(),
send_wakers: Vec::new(),
source,
offers: VecDeque::new(),
waiters: VecDeque::new(),
ticker: false,
sink: None,
sink_waiters: Vec::new(),
}
}
fn receiver_wakers(&mut self) -> Vec<Waker> {
let mut wakers = std::mem::take(&mut self.recv_wakers);
wakers.extend(self.waiters.iter().map(|w| w.waker.borrow().clone()));
wakers
}
fn fill_waiter(&mut self, v: Value, me: &Option<Mark>) -> Result<Waker, Value> {
let waiter = self.waiters.iter().find(|w| {
w.slot.borrow().is_none() && !claimed(&w.select) && !same_select(&w.select, me)
});
match waiter {
Some(w) => {
*w.slot.borrow_mut() = Some(v);
let waker = w.waker.borrow().clone();
Ok(waker)
}
None => Err(v),
}
}
fn take_offer(&mut self, me: &Option<Mark>) -> Option<(Value, Waker)> {
let pos = self.offers.iter().position(|o| {
o.state.get() == OfferState::Open && !claimed(&o.select) && !same_select(&o.select, me)
})?;
let offer = self.offers.remove(pos)?;
offer.state.set(OfferState::Taken);
if let Some(m) = &offer.select {
m.claim();
}
let v = offer.value.borrow_mut().take().unwrap_or(Value::Nil);
let waker = offer.waker.borrow().clone();
Some((v, waker))
}
}
pub(crate) trait HostSource {
fn poll_take(&self, cx: &mut Context<'_>, lua: &Lua) -> Poll<mlua::Result<Option<Value>>>;
fn try_take(&self, lua: &Lua) -> mlua::Result<TryRecv>;
fn close(&self);
fn is_closed(&self) -> bool;
fn len(&self) -> usize;
fn cap(&self) -> usize;
}
#[derive(Default)]
struct FanOut {
wakers: Mutex<Vec<Waker>>,
}
impl FanOut {
fn register(&self, waker: &Waker) {
let mut list = self.wakers.lock().unwrap_or_else(PoisonError::into_inner);
register(&mut list, waker);
}
}
impl Wake for FanOut {
fn wake(self: Arc<Self>) {
self.wake_by_ref();
}
fn wake_by_ref(self: &Arc<Self>) {
let wakers =
std::mem::take(&mut *self.wakers.lock().unwrap_or_else(PoisonError::into_inner));
wake_all(wakers);
}
}
struct HostRx<T> {
rx: RefCell<mpsc::Receiver<T>>,
fan: Arc<FanOut>,
waker: Waker,
}
impl<T: IntoLua + 'static> HostSource for HostRx<T> {
fn poll_take(&self, cx: &mut Context<'_>, lua: &Lua) -> Poll<mlua::Result<Option<Value>>> {
self.fan.register(cx.waker());
let got = self
.rx
.borrow_mut()
.poll_recv(&mut Context::from_waker(&self.waker));
match got {
Poll::Ready(Some(v)) => Poll::Ready(v.into_lua(lua).map(Some)),
Poll::Ready(None) => Poll::Ready(Ok(None)),
Poll::Pending => Poll::Pending,
}
}
fn try_take(&self, lua: &Lua) -> mlua::Result<TryRecv> {
let got = self.rx.borrow_mut().try_recv();
match got {
Ok(v) => Ok(TryRecv::Value(v.into_lua(lua)?)),
Err(mpsc::error::TryRecvError::Empty) => Ok(TryRecv::Empty),
Err(mpsc::error::TryRecvError::Disconnected) => Ok(TryRecv::Closed),
}
}
fn close(&self) {
self.rx.borrow_mut().close();
}
fn is_closed(&self) -> bool {
self.rx.borrow().is_closed()
}
fn len(&self) -> usize {
self.rx.borrow().len()
}
fn cap(&self) -> usize {
self.rx.borrow().max_capacity()
}
}
pub(crate) type Reserve = Pin<Box<dyn Future<Output = Result<Box<dyn SinkPermit>, Closed>>>>;
pub(crate) trait HostSink {
fn reserve(&self) -> Result<Reserve, Closed>;
fn try_reserve(&self) -> Result<Option<Box<dyn SinkPermit>>, Closed>;
fn close(&self);
fn is_closed(&self) -> bool;
fn len(&self) -> usize;
fn cap(&self) -> usize;
}
pub(crate) trait SinkPermit {
fn send(self: Box<Self>, lua: &Lua, v: Value) -> mlua::Result<()>;
}
impl<T: FromLua + Send + 'static> SinkPermit for mpsc::OwnedPermit<T> {
fn send(self: Box<Self>, lua: &Lua, v: Value) -> mlua::Result<()> {
let value = T::from_lua(v, lua)?;
drop((*self).send(value));
Ok(())
}
}
struct HostTx<T> {
tx: RefCell<Option<mpsc::Sender<T>>>,
cap: usize,
}
impl<T: FromLua + Send + 'static> HostSink for HostTx<T> {
fn reserve(&self) -> Result<Reserve, Closed> {
let tx = self.tx.borrow().clone().ok_or(Closed)?;
Ok(Box::pin(async move {
match tx.reserve_owned().await {
Ok(permit) => Ok(Box::new(permit) as Box<dyn SinkPermit>),
Err(_) => Err(Closed),
}
}))
}
fn try_reserve(&self) -> Result<Option<Box<dyn SinkPermit>>, Closed> {
let tx = self.tx.borrow().clone().ok_or(Closed)?;
match tx.try_reserve_owned() {
Ok(permit) => Ok(Some(Box::new(permit))),
Err(mpsc::error::TrySendError::Full(_)) => Ok(None),
Err(mpsc::error::TrySendError::Closed(_)) => Err(Closed),
}
}
fn close(&self) {
let tx = self.tx.borrow_mut().take();
drop(tx);
}
fn is_closed(&self) -> bool {
self.tx.borrow().as_ref().is_none_or(|tx| tx.is_closed())
}
fn len(&self) -> usize {
self.tx
.borrow()
.as_ref()
.map_or(0, |tx| tx.max_capacity() - tx.capacity())
}
fn cap(&self) -> usize {
self.cap
}
}
#[derive(Debug)]
pub(crate) struct Closed;
pub(crate) enum TryRecv {
Value(Value),
Closed,
Empty,
}
fn register(list: &mut Vec<Waker>, waker: &Waker) {
if !list.iter().any(|w| w.will_wake(waker)) {
list.push(waker.clone());
}
}
fn wake_all(wakers: Vec<Waker>) {
for w in wakers {
w.wake();
}
}
pub(crate) fn new(cap: usize) -> Chan {
Rc::new(RefCell::new(ChanCore::with_cap(cap, None)))
}
pub(crate) fn new_ticker() -> Chan {
let mut core = ChanCore::with_cap(1, None);
core.ticker = true;
Rc::new(RefCell::new(core))
}
pub(crate) fn new_host<T: IntoLua + 'static>(rx: mpsc::Receiver<T>) -> Chan {
let fan = Arc::new(FanOut::default());
let cap = rx.max_capacity();
let source = HostRx {
rx: RefCell::new(rx),
waker: Waker::from(fan.clone()),
fan,
};
Rc::new(RefCell::new(ChanCore::with_cap(cap, Some(Rc::new(source)))))
}
pub(crate) fn new_to_host<T: FromLua + Send + 'static>(tx: mpsc::Sender<T>) -> Chan {
let cap = tx.max_capacity();
let mut core = ChanCore::with_cap(cap, None);
core.sink = Some(Rc::new(HostTx {
tx: RefCell::new(Some(tx)),
cap,
}));
Rc::new(RefCell::new(core))
}
pub(crate) fn send_only(chan: &Chan) -> Option<&'static str> {
chan.borrow()
.sink
.is_some()
.then_some("a channel to the host; the host receives")
}
pub(crate) fn receive_only(chan: &Chan) -> Option<&'static str> {
let c = chan.borrow();
if c.source.is_some() {
Some("a host channel; the host sends")
} else if c.ticker {
Some("a ticker")
} else {
None
}
}
fn poll_recv(chan: &Chan, cx: &mut Context<'_>, lua: &Lua) -> Poll<mlua::Result<Option<Value>>> {
let mut c = chan.borrow_mut();
if let Some(v) = c.buf.pop_front() {
let wakers = std::mem::take(&mut c.send_wakers);
drop(c);
wake_all(wakers);
return Poll::Ready(Ok(Some(v)));
}
let Some(source) = c.source.clone() else {
if c.closed {
return Poll::Ready(Ok(None));
}
register(&mut c.recv_wakers, cx.waker());
return Poll::Pending;
};
register(&mut c.recv_wakers, cx.waker());
drop(c);
source.poll_take(cx, lua)
}
pub(crate) fn try_recv(chan: &Chan, lua: &Lua) -> mlua::Result<TryRecv> {
let mut c = chan.borrow_mut();
if let Some(v) = c.buf.pop_front() {
let wakers = std::mem::take(&mut c.send_wakers);
drop(c);
wake_all(wakers);
return Ok(TryRecv::Value(v));
}
if c.cap == 0 {
if let Some((v, waker)) = c.take_offer(&None) {
drop(c);
waker.wake();
return Ok(TryRecv::Value(v));
}
}
if let Some(source) = c.source.clone() {
drop(c);
return source.try_take(lua);
}
Ok(if c.closed {
TryRecv::Closed
} else {
TryRecv::Empty
})
}
pub(crate) fn unrecv(chan: &Chan, v: Value) {
let mut c = chan.borrow_mut();
c.buf.push_front(v);
let wakers = c.receiver_wakers();
drop(c);
wake_all(wakers);
}
fn poll_send(
chan: &Chan,
cx: &mut Context<'_>,
slot: &mut Option<Value>,
) -> Poll<Result<(), Closed>> {
let mut c = chan.borrow_mut();
if c.closed {
return Poll::Ready(Err(Closed));
}
if c.buf.len() < c.cap {
if let Some(v) = slot.take() {
c.buf.push_back(v);
}
let wakers = std::mem::take(&mut c.recv_wakers);
drop(c);
wake_all(wakers);
return Poll::Ready(Ok(()));
}
register(&mut c.send_wakers, cx.waker());
Poll::Pending
}
pub(crate) fn try_send(chan: &Chan, lua: &Lua, v: Value) -> mlua::Result<Result<bool, Closed>> {
let mut c = chan.borrow_mut();
if c.closed {
return Ok(Err(Closed));
}
if let Some(sink) = c.sink.clone() {
drop(c);
return match sink.try_reserve() {
Ok(Some(permit)) => permit.send(lua, v).map(|()| Ok(true)),
Ok(None) => Ok(Ok(false)),
Err(closed) => Ok(Err(closed)),
};
}
if c.cap == 0 {
let filled = c.fill_waiter(v, &None);
drop(c);
return Ok(Ok(match filled {
Ok(waker) => {
waker.wake();
true
}
Err(_) => false,
}));
}
if c.buf.len() >= c.cap {
return Ok(Ok(false));
}
c.buf.push_back(v);
let wakers = std::mem::take(&mut c.recv_wakers);
drop(c);
wake_all(wakers);
Ok(Ok(true))
}
pub(crate) fn close(chan: &Chan) {
let mut c = chan.borrow_mut();
if c.closed {
return;
}
c.closed = true;
if let Some(source) = &c.source {
source.close();
}
let sink = c.sink.clone();
let mut wakers = c.receiver_wakers();
wakers.append(&mut c.send_wakers);
wakers.extend(c.sink_waiters.iter().map(|w| w.borrow().clone()));
for offer in std::mem::take(&mut c.offers) {
offer.state.set(OfferState::Withdrawn);
wakers.push(offer.waker.borrow().clone());
}
drop(c);
if let Some(sink) = sink {
sink.close();
}
wake_all(wakers);
}
pub(crate) fn is_closed(chan: &Chan) -> bool {
let c = chan.borrow();
c.closed
|| c.source.as_ref().is_some_and(|s| s.is_closed())
|| c.sink.as_ref().is_some_and(|s| s.is_closed())
}
pub(crate) fn len(chan: &Chan) -> usize {
let c = chan.borrow();
c.buf.len() + c.source.as_ref().map_or(0, |s| s.len()) + c.sink.as_ref().map_or(0, |s| s.len())
}
pub(crate) fn cap(chan: &Chan) -> usize {
let c = chan.borrow();
match (&c.source, &c.sink) {
(Some(s), _) => s.cap(),
(_, Some(s)) => s.cap(),
_ => c.cap,
}
}
pub(crate) fn push_newest(chan: &Chan, v: Value) -> bool {
let mut c = chan.borrow_mut();
if c.closed {
return false;
}
if c.buf.len() >= c.cap {
c.buf.pop_back();
}
c.buf.push_back(v);
let wakers = c.receiver_wakers();
drop(c);
wake_all(wakers);
true
}
pub(crate) struct Receiving {
chan: Chan,
select: Option<Mark>,
waiter: Option<Rc<Waiter>>,
}
impl Receiving {
pub(crate) fn new(chan: Chan, select: Option<Mark>) -> Receiving {
Receiving {
chan,
select,
waiter: None,
}
}
pub(crate) fn chan(&self) -> &Chan {
&self.chan
}
pub(crate) fn poll(
&mut self,
cx: &mut Context<'_>,
lua: &Lua,
) -> Poll<mlua::Result<Option<Value>>> {
let mut c = self.chan.borrow_mut();
if c.cap != 0 || c.source.is_some() {
drop(c);
return poll_recv(&self.chan, cx, lua);
}
if let Some(w) = &self.waiter {
let filled = w.slot.borrow_mut().take();
if let Some(v) = filled {
Self::forget(&mut c, &mut self.waiter);
return Poll::Ready(Ok(Some(v)));
}
}
if let Some(v) = c.buf.pop_front() {
Self::forget(&mut c, &mut self.waiter);
return Poll::Ready(Ok(Some(v)));
}
if let Some((v, waker)) = c.take_offer(&self.select) {
Self::forget(&mut c, &mut self.waiter);
drop(c);
waker.wake();
return Poll::Ready(Ok(Some(v)));
}
if c.closed {
Self::forget(&mut c, &mut self.waiter);
return Poll::Ready(Ok(None));
}
match &self.waiter {
Some(w) => {
let mut waker = w.waker.borrow_mut();
if !waker.will_wake(cx.waker()) {
*waker = cx.waker().clone();
}
}
None => {
let w = Rc::new(Waiter {
slot: RefCell::new(None),
waker: RefCell::new(cx.waker().clone()),
select: self.select.clone(),
});
c.waiters.push_back(w.clone());
self.waiter = Some(w);
}
}
Poll::Pending
}
fn forget(c: &mut ChanCore, waiter: &mut Option<Rc<Waiter>>) {
if let Some(w) = waiter.take() {
c.waiters.retain(|x| !Rc::ptr_eq(x, &w));
}
}
pub(crate) fn withdraw(&mut self) {
let Some(w) = self.waiter.take() else {
return;
};
let mut c = self.chan.borrow_mut();
c.waiters.retain(|x| !Rc::ptr_eq(x, &w));
let filled = w.slot.borrow_mut().take();
if let Some(v) = filled {
c.buf.push_front(v);
let wakers = c.receiver_wakers();
drop(c);
wake_all(wakers);
}
}
}
impl Drop for Receiving {
fn drop(&mut self) {
self.withdraw();
}
}
pub(crate) struct Sending {
chan: Chan,
value: Option<Value>,
select: Option<Mark>,
offer: Option<Rc<Offer>>,
eager: bool,
reserve: Option<Reserve>,
sink_wait: Option<Rc<RefCell<Waker>>>,
}
impl Sending {
pub(crate) fn new(chan: Chan, v: Value, select: Option<Mark>) -> Sending {
Sending {
chan,
value: Some(v),
select,
offer: None,
eager: false,
reserve: None,
sink_wait: None,
}
}
pub(crate) fn set_eager(&mut self) {
self.eager = true;
}
pub(crate) fn poll(
&mut self,
cx: &mut Context<'_>,
lua: &Lua,
) -> Poll<mlua::Result<Result<(), Closed>>> {
let sink = self.chan.borrow().sink.clone();
if let Some(sink) = sink {
return self.poll_sink(cx, lua, &*sink);
}
self.poll_local(cx).map(Ok)
}
fn poll_sink(
&mut self,
cx: &mut Context<'_>,
lua: &Lua,
sink: &dyn HostSink,
) -> Poll<mlua::Result<Result<(), Closed>>> {
if self.chan.borrow().closed {
self.withdraw();
return Poll::Ready(Ok(Err(Closed)));
}
let permit = if self.eager {
match sink.try_reserve() {
Ok(Some(permit)) => permit,
Ok(None) => return Poll::Pending,
Err(closed) => return Poll::Ready(Ok(Err(closed))),
}
} else {
let reserve = match &mut self.reserve {
Some(r) => r,
None => match sink.reserve() {
Ok(r) => self.reserve.insert(r),
Err(closed) => return Poll::Ready(Ok(Err(closed))),
},
};
match reserve.as_mut().poll(cx) {
Poll::Pending => {
self.wait_sink(cx);
return Poll::Pending;
}
Poll::Ready(got) => {
self.withdraw();
match got {
Ok(permit) => permit,
Err(closed) => return Poll::Ready(Ok(Err(closed))),
}
}
}
};
let v = self.value.take().unwrap_or(Value::Nil);
Poll::Ready(permit.send(lua, v).map(Ok))
}
fn wait_sink(&mut self, cx: &mut Context<'_>) {
match &self.sink_wait {
Some(w) => {
let mut waker = w.borrow_mut();
if !waker.will_wake(cx.waker()) {
*waker = cx.waker().clone();
}
}
None => {
let w = Rc::new(RefCell::new(cx.waker().clone()));
self.chan.borrow_mut().sink_waiters.push(w.clone());
self.sink_wait = Some(w);
}
}
}
fn poll_local(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Closed>> {
if self.chan.borrow().cap != 0 {
return poll_send(&self.chan, cx, &mut self.value);
}
if let Some(offer) = &self.offer {
return match offer.state.get() {
OfferState::Taken => Poll::Ready(Ok(())),
OfferState::Withdrawn => Poll::Ready(Err(Closed)),
OfferState::Open => {
let mut waker = offer.waker.borrow_mut();
if !waker.will_wake(cx.waker()) {
*waker = cx.waker().clone();
}
Poll::Pending
}
};
}
let mut c = self.chan.borrow_mut();
if c.closed {
return Poll::Ready(Err(Closed));
}
if self.eager {
let Some(v) = self.value.take() else {
return Poll::Pending;
};
return match c.fill_waiter(v, &self.select) {
Ok(waker) => {
drop(c);
waker.wake();
Poll::Ready(Ok(()))
}
Err(v) => {
self.value = Some(v);
Poll::Pending
}
};
}
let offer = Rc::new(Offer {
value: RefCell::new(self.value.take()),
state: Cell::new(OfferState::Open),
waker: RefCell::new(cx.waker().clone()),
select: self.select.clone(),
});
c.offers.push_back(offer.clone());
self.offer = Some(offer);
let wakers = c.receiver_wakers();
drop(c);
wake_all(wakers);
Poll::Pending
}
pub(crate) fn delivered(&self) -> bool {
self.offer
.as_ref()
.is_some_and(|o| o.state.get() == OfferState::Taken)
}
pub(crate) fn withdraw(&mut self) {
self.reserve = None;
if let Some(w) = self.sink_wait.take() {
self.chan
.borrow_mut()
.sink_waiters
.retain(|x| !Rc::ptr_eq(x, &w));
}
let Some(offer) = &self.offer else {
return;
};
if offer.state.get() != OfferState::Open {
return;
}
offer.state.set(OfferState::Withdrawn);
self.chan
.borrow_mut()
.offers
.retain(|o| !Rc::ptr_eq(o, offer));
self.offer = None;
}
}
impl Drop for Sending {
fn drop(&mut self) {
self.withdraw();
}
}
pub(crate) struct ChanUd(pub(crate) Chan);
impl mlua::UserData for ChanUd {}