calandria 0.0.1-rc.2

Bounded reactor framework for explicit single-owner systems
Documentation
//! Mutex and condition-variable state for one completion pair.

use std::{
    mem,
    task::{Context, Poll, Waker},
};

use crate::{
    retained::RetainedBytes,
    sync::{Arc, Condvar, Mutex, MutexGuard, recover_poison},
};

use super::CompletionError;

pub(super) struct Shared<T> {
    inner: Arc<Inner<T>>,
}

struct Inner<T> {
    state: Mutex<State<T>>,
    ready: Condvar,
}

enum State<T> {
    Pending {
        observer_alive: bool,
        waker: Option<Waker>,
    },
    Ready(Result<T, CompletionError>),
    Consumed,
}

pub(super) fn retained_bytes<T>() -> RetainedBytes {
    RetainedBytes::try_from(mem::size_of::<Inner<T>>())
        .unwrap_or_else(|_| panic!("completion payload exceeds retained-byte accounting"))
}

impl<T> Shared<T> {
    pub(super) fn new() -> Self {
        Self {
            inner: Arc::new(Inner {
                state: Mutex::new(State::Pending {
                    observer_alive: true,
                    waker: None,
                }),
                ready: Condvar::new(),
            }),
        }
    }

    pub(super) fn complete(&self, value: T) -> Result<(), T> {
        let mut state = self.lock();
        let previous = mem::replace(&mut *state, State::Consumed);
        let (result, waker) = match previous {
            State::Pending {
                observer_alive: true,
                waker,
            } => {
                *state = State::Ready(Ok(value));
                (Ok(()), waker)
            }
            State::Pending {
                observer_alive: false,
                ..
            }
            | State::Consumed => (Err(value), None),
            ready @ State::Ready(_) => {
                *state = ready;
                (Err(value), None)
            }
        };
        drop(state);
        self.inner.ready.notify_all();
        wake(waker);
        result
    }

    pub(super) fn close_producer(&self) {
        let mut state = self.lock();
        let previous = mem::replace(&mut *state, State::Consumed);
        let waker = match previous {
            State::Pending {
                observer_alive: true,
                waker,
            } => {
                *state = State::Ready(Err(CompletionError::Closed));
                waker
            }
            State::Pending { .. } | State::Consumed => None,
            ready @ State::Ready(_) => {
                *state = ready;
                None
            }
        };
        drop(state);
        self.inner.ready.notify_all();
        wake(waker);
    }

    pub(super) fn wait(&self) -> Result<T, CompletionError> {
        let mut state = self.lock();
        loop {
            if matches!(&*state, State::Pending { .. }) {
                state = self.wait_until_ready(state);
                continue;
            }
            return match mem::replace(&mut *state, State::Consumed) {
                State::Ready(result) => result,
                State::Consumed => Err(CompletionError::Consumed),
                State::Pending { .. } => panic!("completion wait invariant violated"),
            };
        }
    }

    pub(super) fn try_take(&self) -> Option<Result<T, CompletionError>> {
        let mut state = self.lock();
        if matches!(&*state, State::Pending { .. }) {
            return None;
        }
        Some(match mem::replace(&mut *state, State::Consumed) {
            State::Ready(result) => result,
            State::Consumed => Err(CompletionError::Consumed),
            State::Pending { .. } => panic!("completion extraction invariant violated"),
        })
    }

    pub(super) fn poll(&self, context: &Context<'_>) -> Poll<Result<T, CompletionError>> {
        let mut state = self.lock();
        if let State::Pending { waker, .. } = &mut *state {
            if !waker
                .as_ref()
                .is_some_and(|stored| stored.will_wake(context.waker()))
            {
                *waker = Some(context.waker().clone());
            }
            return Poll::Pending;
        }
        match mem::replace(&mut *state, State::Consumed) {
            State::Ready(result) => Poll::Ready(result),
            State::Consumed => Poll::Ready(Err(CompletionError::Consumed)),
            State::Pending { .. } => panic!("completion poll invariant violated"),
        }
    }

    pub(super) fn abandon_observer(&self) {
        let mut state = self.lock();
        let previous = mem::replace(&mut *state, State::Consumed);
        let discarded = match previous {
            State::Pending { .. } => {
                *state = State::Pending {
                    observer_alive: false,
                    waker: None,
                };
                None
            }
            State::Ready(result) => Some(result),
            State::Consumed => None,
        };
        drop(state);
        drop(discarded);
    }

    fn lock(&self) -> MutexGuard<'_, State<T>> {
        self.inner.state.lock().unwrap_or_else(recover_poison)
    }

    fn wait_until_ready<'a>(&self, state: MutexGuard<'a, State<T>>) -> MutexGuard<'a, State<T>> {
        self.inner.ready.wait(state).unwrap_or_else(recover_poison)
    }
}

impl<T> Clone for Shared<T> {
    fn clone(&self) -> Self {
        Self {
            inner: Arc::clone(&self.inner),
        }
    }
}

fn wake(waker: Option<Waker>) {
    if let Some(waker) = waker {
        waker.wake();
    }
}