use std::num::NonZeroUsize;
use std::sync::Arc;
use crate::{MemoryQueuePolicy, Result};
use super::binding::MemoryOutputBinding;
use super::inner::MemoryOutputInner;
use super::state::{acquire, take};
use super::validation::capacity;
use super::{CallbackError, PacketQueue};
pub struct MemoryOutput {
pub(crate) inner: Arc<MemoryOutputInner>,
}
impl MemoryOutput {
pub fn new(capacity_bytes: NonZeroUsize, policy: MemoryQueuePolicy) -> Result<Arc<Self>> {
let inner = MemoryOutputInner::new(PacketQueue::new(capacity(capacity_bytes)?, policy))?;
Ok(Arc::new(Self { inner }))
}
pub fn recv_shared(&self) -> Result<Option<Arc<[u8]>>> {
self.inner.queue().recv_shared("MemoryOutput")
}
pub fn try_recv_shared(&self) -> Result<Option<Arc<[u8]>>> {
self.inner.queue().try_recv_shared("MemoryOutput")
}
pub fn recv(&self) -> Result<Option<Vec<u8>>> {
self.recv_shared()
.map(|data| data.map(|data| data.to_vec()))
}
pub fn try_recv(&self) -> Result<Option<Vec<u8>>> {
self.try_recv_shared()
.map(|data| data.map(|data| data.to_vec()))
}
pub fn close(&self) {
self.inner.queue().close();
}
pub fn abort(&self) {
self.inner.queue().abort();
}
pub fn queued_bytes(&self) -> usize {
self.inner.queue().queued_bytes()
}
pub fn dropped_bytes(&self) -> usize {
self.inner.queue().dropped_bytes()
}
pub fn take_callback_error(&self) -> Option<CallbackError> {
take(self.inner.state())
}
pub(crate) fn bind(&self) -> Result<MemoryOutputBinding> {
acquire(self.inner.state(), "MemoryOutput")?;
Ok(MemoryOutputBinding::new(Arc::clone(&self.inner)))
}
}