use std::collections::VecDeque;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::sync::mpsc;
use crate::client::Client;
use crate::config::Config;
use crate::delivery;
use crate::error::Error;
use crate::handler::{Event, Handler};
use crate::message::{Message, OwnedMessage};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum Incoming {
Message(OwnedMessage),
Event(Event),
Binary(bytes::Bytes),
}
pub struct Events {
rx: Receiver,
gate: delivery::Shared,
wake: mpsc::UnboundedReceiver<()>,
}
impl std::fmt::Debug for Events {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Events").finish_non_exhaustive()
}
}
#[cfg(not(target_arch = "wasm32"))]
type Sender = mpsc::Sender<Incoming>;
#[cfg(not(target_arch = "wasm32"))]
type Receiver = mpsc::Receiver<Incoming>;
#[cfg(target_arch = "wasm32")]
type Sender = mpsc::UnboundedSender<Incoming>;
#[cfg(target_arch = "wasm32")]
type Receiver = mpsc::UnboundedReceiver<Incoming>;
impl Events {
pub async fn next(&mut self) -> Option<Incoming> {
futures_util::future::poll_fn(|cx| self.poll(cx)).await
}
pub fn try_next(&mut self) -> Option<Incoming> {
while self.wake.try_recv().is_ok() {}
loop {
if let Some(item) = delivery::lock(&self.gate).take_out() {
return Some(item);
}
let incoming = self.rx.try_recv().ok()?;
if let Some(item) = self.pass(incoming) {
return Some(item);
}
}
}
fn pass(&mut self, incoming: Incoming) -> Option<Incoming> {
let mut gate = delivery::lock(&self.gate);
match incoming {
Incoming::Message(message) => gate.owned(message).map(Incoming::Message),
Incoming::Event(event) => {
gate.event(&event);
Some(Incoming::Event(event))
}
binary => Some(binary),
}
}
fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Option<Incoming>> {
loop {
if let Some(item) = delivery::lock(&self.gate).take_out() {
return Poll::Ready(Some(item));
}
while let Poll::Ready(Some(())) = self.wake.poll_recv(cx) {}
match self.rx.poll_recv(cx) {
Poll::Ready(Some(incoming)) => {
if let Some(item) = self.pass(incoming) {
return Poll::Ready(Some(item));
}
}
Poll::Ready(None) => return Poll::Ready(delivery::lock(&self.gate).take_out()),
Poll::Pending => {
return match delivery::lock(&self.gate).take_out() {
Some(item) => Poll::Ready(Some(item)),
None => Poll::Pending,
};
}
}
}
}
}
impl futures_util::Stream for Events {
type Item = Incoming;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Incoming>> {
self.poll(cx)
}
}
#[cfg(not(target_arch = "wasm32"))]
const QUEUE: usize = 1024;
pub async fn connect(config: Config) -> Result<(Client, Events), Error> {
with_events(config, true).await
}
pub async fn start(config: Config) -> Result<(Client, Events), Error> {
with_events(config, false).await
}
async fn with_events(config: Config, wait: bool) -> Result<(Client, Events), Error> {
#[cfg(not(target_arch = "wasm32"))]
let (tx, rx) = mpsc::channel(QUEUE);
#[cfg(target_arch = "wasm32")]
let (tx, rx) = mpsc::unbounded_channel();
let queue = Queue {
tx,
waiting: VecDeque::new(),
};
let (wake_tx, wake) = mpsc::unbounded_channel();
let (client, gate) = Client::launch(config, |_| queue, Some(wake_tx), wait).await?;
Ok((client, Events { rx, gate, wake }))
}
struct Queue {
tx: Sender,
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
waiting: VecDeque<Incoming>,
}
impl Queue {
#[cfg(not(target_arch = "wasm32"))]
fn push(&mut self, item: Incoming) {
if !self.waiting.is_empty() {
self.waiting.push_back(item);
return;
}
match self.tx.try_send(item) {
Ok(()) => {}
Err(mpsc::error::TrySendError::Full(item)) => self.waiting.push_back(item),
Err(mpsc::error::TrySendError::Closed(_)) => {}
}
}
#[cfg(target_arch = "wasm32")]
fn push(&mut self, item: Incoming) {
let _ = self.tx.send(item);
}
}
impl Handler for Queue {
fn message(&mut self, message: &Message<'_>) {
self.push(Incoming::Message(message.to_owned()));
}
fn event(&mut self, event: Event) {
self.push(Incoming::Event(event));
}
fn binary(&mut self, data: &[u8]) {
self.push(Incoming::Binary(bytes::Bytes::copy_from_slice(data)));
}
#[cfg(not(target_arch = "wasm32"))]
async fn ready(&mut self) {
while !self.waiting.is_empty() {
let Ok(permit) = self.tx.reserve().await else {
self.waiting.clear();
return;
};
if let Some(item) = self.waiting.pop_front() {
permit.send(item);
}
}
}
}