use core::hash::Hash;
use std::{
collections::HashSet,
sync::{Mutex, MutexGuard},
};
use left_right::{Absorb, ReadHandle, ReadHandleFactory, WriteHandle};
use crate::drive::registry::RootKey;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum Mark<Root> {
Mark(Root),
Unmark(Root),
}
#[derive(Debug, Clone, Default)]
struct Retirees<Root>(HashSet<Root>);
impl<Root> Absorb<Mark<Root>> for Retirees<Root>
where
Root: Clone + Eq + Hash,
{
fn absorb_first(&mut self, operation: &mut Mark<Root>, _other: &Self) {
match operation {
Mark::Mark(key) => {
self.0.insert(key.clone());
}
Mark::Unmark(key) => {
self.0.remove(key);
}
}
}
fn absorb_second(&mut self, operation: Mark<Root>, _other: &Self) {
match operation {
Mark::Mark(key) => {
self.0.insert(key);
}
Mark::Unmark(key) => {
self.0.remove(&key);
}
}
}
fn sync_with(&mut self, first: &Self) {
self.0.clone_from(&first.0);
}
}
pub struct RetiredReader<Root> {
handle: ReadHandle<Retirees<Root>>,
}
impl<Root> core::fmt::Debug for RetiredReader<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("RetiredReader").finish_non_exhaustive()
}
}
impl<Root> RetiredReader<Root>
where
Root: RootKey,
{
#[must_use]
pub fn retired(&self, key: &Root) -> bool {
self.handle.enter().is_some_and(|held| held.0.contains(key))
}
#[must_use]
pub fn held(&self) -> usize {
self.handle.enter().map_or(0, |held| held.0.len())
}
}
pub struct RetiredReaders<Root> {
factory: ReadHandleFactory<Retirees<Root>>,
}
impl<Root> Clone for RetiredReaders<Root> {
fn clone(&self) -> Self {
Self {
factory: self.factory.clone(),
}
}
}
impl<Root> core::fmt::Debug for RetiredReaders<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("RetiredReaders").finish_non_exhaustive()
}
}
impl<Root> RetiredReaders<Root> {
#[must_use]
pub fn reader(&self) -> RetiredReader<Root> {
RetiredReader {
handle: self.factory.handle(),
}
}
}
pub struct RetiredMirror<Root: RootKey> {
writer: Mutex<WriteHandle<Retirees<Root>, Mark<Root>>>,
readers: RetiredReaders<Root>,
}
impl<Root: RootKey> core::fmt::Debug for RetiredMirror<Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("RetiredMirror")
.field("held", &self.held())
.finish_non_exhaustive()
}
}
impl<Root: RootKey> Default for RetiredMirror<Root> {
fn default() -> Self {
Self::new()
}
}
impl<Root: RootKey> RetiredMirror<Root> {
#[must_use]
pub fn new() -> Self {
let (writer, reader) =
left_right::new_from_empty::<Retirees<Root>, Mark<Root>>(Retirees(HashSet::new()));
Self {
readers: RetiredReaders {
factory: reader.factory(),
},
writer: Mutex::new(writer),
}
}
#[must_use]
pub fn rebuilt(keys: impl IntoIterator<Item = Root>) -> Self {
let mirror = Self::new();
{
let mut writer = mirror.writer();
for key in keys {
writer.append(Mark::Mark(key));
}
writer.publish();
}
mirror
}
#[inline]
#[must_use]
pub fn readers(&self) -> RetiredReaders<Root> {
self.readers.clone()
}
#[inline]
#[must_use]
pub fn reader(&self) -> RetiredReader<Root> {
self.readers.reader()
}
pub fn mark(&self, key: Root) {
self.writer().append(Mark::Mark(key)).publish();
}
pub fn unmark(&self, key: Root) {
self.writer().append(Mark::Unmark(key)).publish();
}
#[must_use]
pub fn held(&self) -> usize {
self.published(|held| held.0.len())
}
#[must_use]
pub fn retired(&self, key: &Root) -> bool {
self.published(|held| held.0.contains(key))
}
fn published<T>(&self, read: impl FnOnce(&Retirees<Root>) -> T) -> T {
let writer = self.writer();
let held = writer
.enter()
.expect("a mirror whose own writer is held has a copy to read");
read(&held)
}
fn writer(&self) -> MutexGuard<'_, WriteHandle<Retirees<Root>, Mark<Root>>> {
self.writer.lock().unwrap_or_else(|held| held.into_inner())
}
}