rustduck-core 1.1.0

Safe typed TSDuck core bindings for rustduck
Documentation
//! Shared endpoint lease and callback-error state.

use std::sync::Mutex;

use crate::{Error, Result};

use super::CallbackError;

pub(super) struct EndpointState {
    bound: bool,
    callback_error: Option<CallbackError>,
}

impl EndpointState {
    pub(super) const fn new() -> Self {
        Self {
            bound: false,
            callback_error: None,
        }
    }
}

pub(super) fn acquire(state: &Mutex<EndpointState>, endpoint: &'static str) -> Result<()> {
    let mut state = state
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner());
    if state.bound {
        return Err(Error::InvalidState {
            object: endpoint,
            operation: "bind",
            state: "bound",
        });
    }
    state.bound = true;
    Ok(())
}

pub(super) fn release(state: &Mutex<EndpointState>) {
    state
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner())
        .bound = false;
}

pub(super) fn record(state: &Mutex<EndpointState>, error: CallbackError) {
    state
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner())
        .callback_error = Some(error);
}

pub(super) fn take(state: &Mutex<EndpointState>) -> Option<CallbackError> {
    state
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner())
        .callback_error
        .take()
}