use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use serde::de::DeserializeOwned;
use tokio::sync::mpsc;
use crate::actor::Command;
use crate::protocol::socketio::Packet;
use crate::{Error, Payload, Result};
#[derive(Debug, Clone)]
pub struct Event {
name: String,
payload: Payload,
ack: Option<AckSender>,
}
impl Event {
pub(crate) fn new(name: String, payload: Payload, ack: Option<AckSender>) -> Self {
Event { name, payload, ack }
}
pub fn name(&self) -> &str {
&self.name
}
pub fn payload(&self) -> &Payload {
&self.payload
}
pub fn into_payload(self) -> Payload {
self.payload
}
pub fn arg<T: DeserializeOwned>(&self, index: usize) -> Result<T> {
Ok(self.payload.arg(index)?)
}
pub fn wants_ack(&self) -> bool {
self.ack.is_some()
}
pub fn ack(&self, data: impl Into<Payload>) -> Result<()> {
match &self.ack {
Some(ack) => ack.send(data),
None => Ok(()),
}
}
pub fn ack_sender(&self) -> Option<AckSender> {
self.ack.clone()
}
}
#[derive(Debug, Clone)]
pub struct AckSender {
id: u64,
nsp: Arc<str>,
cmd: mpsc::UnboundedSender<Command>,
sent: Arc<AtomicBool>,
}
impl AckSender {
pub(crate) fn new(id: u64, nsp: Arc<str>, cmd: mpsc::UnboundedSender<Command>) -> Self {
AckSender {
id,
nsp,
cmd,
sent: Arc::default(),
}
}
pub fn id(&self) -> u64 {
self.id
}
pub fn send(&self, data: impl Into<Payload>) -> Result<()> {
if self.sent.swap(true, Ordering::AcqRel) {
return Ok(());
}
let packet = Packet::new_ack(data.into(), &self.nsp, self.id)?;
self.cmd
.send(Command::Send { packet })
.map_err(|_| Error::Closed)
}
}