win-events 0.0.2

use std::error::Error;
use std::sync::{Arc, MutexGuard};
use std::time::Duration;

use crate::events::event::{EventHandle, EventState};
use crate::waiters::waiter::{Signaler, WaitList};
use crate::{wait_one, Event};

struct PulseEventInfo {
    waiters: WaitList,
}

impl PulseEventInfo {
    fn new() -> PulseEventInfo {
        PulseEventInfo {
            waiters: WaitList::new(),
        }
    }
}

impl EventState for PulseEventInfo {
    fn is_set(&self) -> bool {
        false
    }

    fn set(&self) {
        self.waiters.fire()
    }

    fn clear(&self) {
        self.waiters.clear()
    }

    fn register_signaler(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        if self.is_set() {
            signaler.fire(pos)?;
        }
        self.waiters.register_signaler(pos, signaler)
    }

    fn remove_signaler(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
        self.waiters.remove_signaler(signaler)
    }

    fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>> {
        Ok(None)
    }

    fn can_consume(&self) -> bool {
        true
    }

    fn consume(&self) {}
}

/// A PulseEvent
///
/// An event represents a boolean condition that can be waited on until signaled. This allows a
/// thread to block and wait for another thread to set the event. Until the event is manually reset
/// waiting will return immediately.
///
/// # Examples
///
/// ```
/// use std::thread;
/// use std::time::Duration;
/// use win_events::{Event, PulseEvent};
///
/// let evt_started = PulseEvent::new();
/// let evt_started2 = evt_started.clone();
///
/// // spawn a thread and set the cloned event
/// thread::spawn(move|| {
///     thread::sleep(Duration::from_millis(1));
///     evt_started2.set();
/// });
///
/// // Wait for the started event
/// let wait_result = evt_started.wait(Duration::from_millis(100)).unwrap();
/// assert!(wait_result);
/// ```
#[derive(Clone)]
pub struct PulseEvent {
    info: Arc<EventHandle>,
}

impl PulseEvent {
    /// Creates a new PulseEvent
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::PulseEvent;
    ///
    /// let evt = PulseEvent::new();
    /// ```
    pub fn new() -> PulseEvent {
        let state: Box<dyn EventState> = Box::new(PulseEventInfo::new());
        PulseEvent {
            info: Arc::new(EventHandle::new(state)),
        }
    }

    /// Gets the current state of the event, this always returns false for a pulse
    /// event.
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::PulseEvent;
    ///
    /// let evt = PulseEvent::new();
    /// assert!(!evt.is_set())
    ///  ```
    pub fn is_set(&self) -> bool {
        self.info.is_set()
    }

    /// Sets the event and fires a signal to any threads waiting on the event.
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::PulseEvent;
    ///
    /// let evt = PulseEvent::new();
    /// evt.set();
    /// assert!(!evt.is_set())
    /// ```
    pub fn set(&self) {
        self.info.set()
    }

    /// Clears the event
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::PulseEvent;
    ///
    /// let evt = PulseEvent::new();
    /// evt.clear();
    /// assert!(!evt.is_set())
    /// ```
    pub fn clear(&self) {
        self.info.clear()
    }
    /// Waits on the event to be set
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread::{sleep, spawn};
    /// use std::time::Duration;
    /// use win_events::PulseEvent;
    ///
    /// let evt = PulseEvent::new();
    /// let evt_inner = evt.clone();
    ///
    /// let worker = spawn(move || {
    ///    sleep(Duration::from_millis(3));
    ///    evt_inner.set()
    /// });
    ///
    /// let wait_result = evt.wait(Duration::from_millis(100)).unwrap();
    /// assert!(wait_result)
    /// ```
    pub fn wait(&self, dur: Duration) -> Result<bool, Box<dyn Error>> {
        wait_one(self, dur)
    }
}

impl Event for PulseEvent {
    fn handle(&self) -> &Arc<EventHandle> {
        &self.info
    }
}