use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use crate::{MemoryPushOutcome, Result};
use super::state::{EndpointState, record};
use super::{CallbackError, PacketQueue};
use crate::memory::registry::{self, EventCode};
pub(crate) struct MemoryInputInner {
queue: PacketQueue,
state: Mutex<EndpointState>,
event_code: AtomicU32,
}
pub(crate) struct MemoryOutputInner {
queue: PacketQueue,
state: Mutex<EndpointState>,
event_code: AtomicU32,
}
impl MemoryInputInner {
#[cfg(test)]
pub(crate) fn wait_for_waiter(&self) -> bool {
self.queue.wait_for_waiter()
}
pub(super) fn new(queue: PacketQueue) -> Result<Arc<Self>> {
let inner = Arc::new(Self {
queue,
state: Mutex::new(EndpointState::new()),
event_code: AtomicU32::new(0),
});
let event_code = registry::register_input(&inner)?;
inner.event_code.store(event_code.raw(), Ordering::Relaxed);
Ok(inner)
}
pub(crate) fn event_code(&self) -> u32 {
self.event_code.load(Ordering::Relaxed)
}
pub(crate) fn take_for_callback(&self, capacity: usize) -> Result<Option<Vec<u8>>> {
self.queue.take_for_input(capacity, "MemoryInput")
}
pub(crate) fn record_callback_error(&self, error: CallbackError) {
record(&self.state, error);
self.queue.abort();
}
pub(super) fn queue(&self) -> &PacketQueue {
&self.queue
}
pub(super) fn state(&self) -> &Mutex<EndpointState> {
&self.state
}
}
impl MemoryOutputInner {
#[cfg(test)]
pub(crate) fn wait_for_waiter(&self) -> bool {
self.queue.wait_for_waiter()
}
pub(super) fn new(queue: PacketQueue) -> Result<Arc<Self>> {
let inner = Arc::new(Self {
queue,
state: Mutex::new(EndpointState::new()),
event_code: AtomicU32::new(0),
});
let event_code = registry::register_output(&inner)?;
inner.event_code.store(event_code.raw(), Ordering::Relaxed);
Ok(inner)
}
pub(crate) fn event_code(&self) -> u32 {
self.event_code.load(Ordering::Relaxed)
}
pub(crate) fn push_from_callback(&self, data: &[u8]) -> Result<MemoryPushOutcome> {
self.queue
.push_shared(Arc::<[u8]>::from(data), "MemoryOutput")
}
pub(crate) fn record_callback_error(&self, error: CallbackError) {
record(&self.state, error);
self.queue.abort();
}
pub(super) fn queue(&self) -> &PacketQueue {
&self.queue
}
pub(super) fn state(&self) -> &Mutex<EndpointState> {
&self.state
}
}
impl MemoryInputInner {
fn registered_event_code(&self) -> Option<EventCode> {
let raw = self.event_code.load(Ordering::Relaxed);
(raw != 0).then_some(EventCode::from_raw(raw))
}
}
impl MemoryOutputInner {
fn registered_event_code(&self) -> Option<EventCode> {
let raw = self.event_code.load(Ordering::Relaxed);
(raw != 0).then_some(EventCode::from_raw(raw))
}
}
impl Drop for MemoryInputInner {
fn drop(&mut self) {
if let Some(event_code) = self.registered_event_code() {
registry::unregister(event_code);
}
}
}
impl Drop for MemoryOutputInner {
fn drop(&mut self) {
if let Some(event_code) = self.registered_event_code() {
registry::unregister(event_code);
}
}
}