use core::sync::atomic::{AtomicPtr, Ordering};
pub type NoticeSink = fn(&str);
static SINK: AtomicPtr<()> = AtomicPtr::new(core::ptr::null_mut());
pub fn set_sink(sink: Option<NoticeSink>) {
let raw = match sink {
Some(f) => f as *mut (),
None => core::ptr::null_mut(),
};
SINK.store(raw, Ordering::Release);
}
pub(crate) fn emit(args: core::fmt::Arguments<'_>) {
let raw = SINK.load(Ordering::Acquire);
if raw.is_null() {
eprintln!("{args}");
return;
}
let sink = unsafe { core::mem::transmute::<*mut (), NoticeSink>(raw) };
match args.as_str() {
Some(literal) => sink(literal),
None => sink(&args.to_string()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
static SEEN: Mutex<Vec<String>> = Mutex::new(Vec::new());
fn record(note: &str) {
SEEN.lock().expect("the note log").push(note.to_string());
}
#[test]
fn an_installed_sink_takes_every_note_and_none_leaves_them_on_stderr() {
set_sink(Some(record));
notice!("a note with {} in it", 42);
notice!("a note that is one literal");
set_sink(None);
notice!("a note for stderr, which the sink never sees");
let seen = SEEN.lock().expect("the note log");
assert!(seen.iter().any(|n| n == "a note with 42 in it"));
assert!(seen.iter().any(|n| n == "a note that is one literal"));
assert!(!seen.iter().any(|n| n.starts_with("a note for stderr")));
}
}