use std::fmt;
use std::pin::Pin;
use std::task::{Context, Poll};
use bytes::Bytes;
use futures_util::{Stream, StreamExt};
use url::Url;
use crate::engineio::error::Result;
use crate::engineio::transports::{PollingTransport, WebsocketTransport};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum TransportKind {
Polling,
Websocket,
}
impl TransportKind {
pub fn as_str(self) -> &'static str {
match self {
TransportKind::Polling => "polling",
TransportKind::Websocket => "websocket",
}
}
pub(crate) fn is_polling(self) -> bool {
self == TransportKind::Polling
}
}
impl fmt::Display for TransportKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Frame {
Text(Bytes),
Binary(Bytes),
}
impl From<Bytes> for Frame {
fn from(bytes: Bytes) -> Self {
Frame::Text(bytes)
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Transport {
Polling(PollingTransport),
Websocket(WebsocketTransport),
}
impl From<PollingTransport> for Transport {
fn from(transport: PollingTransport) -> Self {
Transport::Polling(transport)
}
}
impl From<WebsocketTransport> for Transport {
fn from(transport: WebsocketTransport) -> Self {
Transport::Websocket(transport)
}
}
impl Transport {
pub async fn emit(&self, data: Bytes, is_binary_att: bool) -> Result<()> {
match self {
Transport::Polling(t) => t.emit(data, is_binary_att).await,
Transport::Websocket(t) => t.emit(data, is_binary_att).await,
}
}
pub async fn base_url(&self) -> Result<Url> {
match self {
Transport::Polling(t) => t.base_url().await,
Transport::Websocket(t) => t.base_url().await,
}
}
pub(crate) async fn ws_ping(&self) -> Result<()> {
match self {
Transport::Polling(_) => Ok(()),
Transport::Websocket(t) => t.ping().await,
}
}
pub fn kind(&self) -> TransportKind {
match self {
Transport::Polling(_) => TransportKind::Polling,
Transport::Websocket(_) => TransportKind::Websocket,
}
}
}
impl Stream for Transport {
type Item = Result<Frame>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
match self.get_mut() {
Transport::Polling(t) => t
.poll_next_unpin(cx)
.map(|item| item.map(|r| r.map(Frame::Text))),
Transport::Websocket(t) => t.poll_next_unpin(cx),
}
}
}