rustduck-core 1.1.0

Safe typed TSDuck core bindings for rustduck
Documentation
//! Rust-owned callback state and registry lifetime for memory endpoints.

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);
        }
    }
}