use std::collections::HashMap;
use std::ffi::c_void;
use std::sync::{Arc, LazyLock, Mutex};
use rustorb_core::{ValueRef, WeakValueRef};
use crate::value::ReleaseFn;
#[derive(Debug)]
pub(crate) struct Host {
pub(crate) key: u64,
pub(crate) ptr: *mut c_void,
release: ReleaseFn,
}
unsafe impl Send for Host {}
unsafe impl Sync for Host {}
impl Drop for Host {
fn drop(&mut self) {
{
let mut map = registry().lock().unwrap_or_else(|e| e.into_inner());
if map.get(&self.key).is_some_and(WeakValueRef::is_dead) {
map.remove(&self.key);
}
}
if let Some(release) = self.release {
unsafe { release(self.ptr) };
}
}
}
fn registry() -> &'static Mutex<HashMap<u64, WeakValueRef>> {
static REGISTRY: LazyLock<Mutex<HashMap<u64, WeakValueRef>>> = LazyLock::new(Default::default);
®ISTRY
}
pub(crate) fn host_of(v: &ValueRef) -> Option<Arc<Host>> {
v.native()?.downcast::<Host>().ok()
}
pub(crate) fn lookup(key: u64) -> Option<ValueRef> {
let weak = registry()
.lock()
.unwrap_or_else(|e| e.into_inner())
.get(&key)
.cloned()?;
let v = weak.upgrade()?;
host_of(&v).is_some_and(|h| h.key == key).then_some(v)
}
pub(crate) fn attach(v: &ValueRef, key: u64, ptr: *mut c_void, release: ReleaseFn) {
v.set_native(Some(Arc::new(Host { key, ptr, release })));
let old = registry()
.lock()
.unwrap_or_else(|e| e.into_inner())
.insert(key, v.downgrade());
drop(old);
}
#[derive(Debug)]
pub(crate) struct Owned {
ptr: *mut c_void,
release: ReleaseFn,
}
impl Owned {
pub(crate) fn new(ptr: *mut c_void, release: ReleaseFn) -> Owned {
Owned { ptr, release }
}
pub(crate) fn take(self) -> (*mut c_void, ReleaseFn) {
let me = std::mem::ManuallyDrop::new(self);
(me.ptr, me.release)
}
}
impl Drop for Owned {
fn drop(&mut self) {
if let Some(release) = self.release {
unsafe { release(self.ptr) };
}
}
}
#[derive(Debug)]
pub(crate) struct Written {
pub(crate) slot: usize,
pub(crate) key: u64,
pub(crate) host: Option<Owned>,
}