use std::sync::{Arc, RwLock};
pub(crate) struct HookSlot<T: ?Sized> {
inner: RwLock<Option<Arc<T>>>,
}
impl<T: ?Sized> HookSlot<T> {
pub(crate) const fn new() -> Self {
Self {
inner: RwLock::new(None),
}
}
pub(crate) fn register(&self, hook: Arc<T>, warn_on_replace: &str) {
let mut slot = self.inner.write().unwrap_or_else(|poisoned| poisoned.into_inner());
if let Some(previous) = slot.as_ref()
&& !Arc::ptr_eq(previous, &hook)
{
tracing::warn!("{warn_on_replace}");
}
*slot = Some(hook);
}
pub(crate) fn get(&self) -> Option<Arc<T>> {
self.inner.read().unwrap_or_else(|poisoned| poisoned.into_inner()).clone()
}
pub(crate) fn clear(&self) {
*self.inner.write().unwrap_or_else(|poisoned| poisoned.into_inner()) = None;
}
}
#[cfg(test)]
mod tests {
use super::HookSlot;
use std::sync::Arc;
trait Marker: Send + Sync {
fn id(&self) -> u32;
}
struct Impl(u32);
impl Marker for Impl {
fn id(&self) -> u32 {
self.0
}
}
#[test]
fn empty_slot_reads_none() {
let slot: HookSlot<dyn Marker> = HookSlot::new();
assert!(slot.get().is_none());
}
#[test]
fn register_then_get_returns_the_hook() {
let slot: HookSlot<dyn Marker> = HookSlot::new();
slot.register(Arc::new(Impl(7)), "unused");
assert_eq!(slot.get().map(|h| h.id()), Some(7));
}
#[test]
fn re_registration_swaps_to_the_latest_instance() {
let slot: HookSlot<dyn Marker> = HookSlot::new();
slot.register(Arc::new(Impl(1)), "unused");
slot.register(Arc::new(Impl(2)), "unused");
assert_eq!(slot.get().map(|h| h.id()), Some(2));
}
#[test]
fn re_registering_the_same_arc_is_idempotent() {
let slot: HookSlot<dyn Marker> = HookSlot::new();
let hook: Arc<dyn Marker> = Arc::new(Impl(9));
slot.register(Arc::clone(&hook), "unused");
slot.register(hook, "unused");
assert_eq!(slot.get().map(|h| h.id()), Some(9));
}
#[test]
fn clear_empties_the_slot() {
let slot: HookSlot<dyn Marker> = HookSlot::new();
slot.register(Arc::new(Impl(3)), "unused");
slot.clear();
assert!(slot.get().is_none());
}
}