Struct EventWatcher 

pub struct EventWatcher { /* private fields */ }

Event-driven watcher built on top of notify.

Owns the recommended backend (FSEvents/inotify/RDCW), a debounce thread, and the receiver end of the batched-event channel. Dropping the watcher tears down the backend and the debounce thread.

Implementations

impl EventWatcher

pub fn new(dir: &Path) -> Result<Self, SsgError>

Builds a watcher rooted at dir, watching recursively, with a 100 ms debounce window.

Errors

Returns SsgError::Io wrapping the underlying notify::Error when the backend cannot subscribe (missing directory, permission denied, kernel resource exhaustion).

Examples

use ssg::event_watch::{EventWatcher, DEFAULT_DEBOUNCE};
let tmp = tempfile::tempdir().unwrap();
let w = EventWatcher::new(tmp.path()).unwrap();
assert_eq!(w.debounce(), DEFAULT_DEBOUNCE);

pub fn with_debounce(dir: &Path, debounce: Duration) -> Result<Self, SsgError>

Same as Self::new but with a caller-supplied debounce window (used by tests to keep latency low).

Errors

See Self::new.

Examples

use std::time::Duration;
use ssg::event_watch::EventWatcher;
let tmp = tempfile::tempdir().unwrap();
let w = EventWatcher::with_debounce(tmp.path(), Duration::from_millis(50)).unwrap();
assert_eq!(w.debounce(), Duration::from_millis(50));

pub fn recv(&self) -> Option<ChangeBatch>

Blocks until the next debounced batch is available.

Returns None if the watcher is being torn down.

Examples

use ssg::event_watch::EventWatcher;
let tmp = tempfile::tempdir().unwrap();
let w = EventWatcher::new(tmp.path()).unwrap();
// Blocks until a change arrives — would hang in a doctest sandbox.
if let Some(batch) = w.recv() {
    assert!(!batch.paths.is_empty());
}

pub fn recv_timeout(&self, timeout: Duration) -> RecvOutcome

Like Self::recv but with a timeout.

Returns:

• RecvOutcome::Batch — a debounced batch arrived.
• RecvOutcome::Timeout — no batch within timeout.
• RecvOutcome::Closed — the watcher was dropped or the debounce thread exited.

Examples

use std::time::Duration;
use ssg::event_watch::{EventWatcher, RecvOutcome};
let tmp = tempfile::tempdir().unwrap();
let w = EventWatcher::with_debounce(tmp.path(), Duration::from_millis(20)).unwrap();
let out = w.recv_timeout(Duration::from_millis(30));
assert!(!out.is_closed());

pub const fn debounce(&self) -> Duration

Debounce window in effect for this watcher.

Examples

use std::time::Duration;
use ssg::event_watch::EventWatcher;
let tmp = tempfile::tempdir().unwrap();
let w = EventWatcher::with_debounce(tmp.path(), Duration::from_millis(75)).unwrap();
assert_eq!(w.debounce(), Duration::from_millis(75));

Trait Implementations

impl Debug for EventWatcher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for EventWatcher

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.