use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use super::api::Announcement;
use crate::backend::api::Op;
use crate::key::LockerId;
#[derive(Debug, Default)]
pub(crate) struct Coherence {
closed: Arc<AtomicBool>,
}
impl Coherence {
pub(crate) fn disabled() -> Self {
Self::default()
}
pub(crate) fn open(_name: &str) -> Self {
Self::default()
}
#[cfg(test)]
pub(crate) fn close_witness(&self) -> Arc<AtomicBool> {
self.closed.clone()
}
#[allow(dead_code)] pub(crate) fn is_enabled(&self) -> bool {
false
}
pub(crate) fn prepare(&self, _locker_id: LockerId, _ops: &[Op]) -> Option<Announcement> {
None
}
pub(crate) fn post(&self, _announcement: Announcement) {}
pub(crate) fn close(&self) {
self.closed.store(true, Ordering::Release);
}
}
impl Drop for Coherence {
fn drop(&mut self) {
self.close();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dropping_unregisters_without_a_close_call() {
let witness = {
let coherence = Coherence::open("never-closed");
let witness = coherence.close_witness();
assert!(!witness.load(Ordering::Acquire), "not closed yet");
witness
};
assert!(
witness.load(Ordering::Acquire),
"Drop must do what close does; on wasm skipping it is a use-after-free"
);
}
#[test]
fn close_then_drop_is_idempotent() {
let coherence = Coherence::open("closed-twice");
let witness = coherence.close_witness();
coherence.close();
assert!(witness.load(Ordering::Acquire));
drop(coherence);
assert!(witness.load(Ordering::Acquire));
}
}