Struct NotifySource

pub struct NotifySource { /* private fields */ }

Calloop event source for watching files.

This struct implements EventSource, which allows passing it to LoopHandle::insert_source for registering it with calloop.

Since this implements Deref and DerefMut into RecommendedWatcher, you can call any function from Watcher on it. Use this to watch new files.

Example

use std::path::Path;

use calloop::EventLoop;
use calloop_notify::NotifySource;
use calloop_notify::notify::{RecursiveMode, Watcher};

// Create calloop event loop.
let mut event_loop = EventLoop::try_new().unwrap();
let loop_handle = event_loop.handle();

// Watch current directory recursively.
let mut notify_source = NotifySource::new().unwrap();
notify_source.watch(Path::new("."), RecursiveMode::Recursive).unwrap();

// Insert notify source into calloop.
loop_handle
    .insert_source(notify_source, |event, _, _: &mut ()| {
        println!("Notify Event: {event:?}");
    })
    .unwrap();

// Dispatch event loop.
loop {
    event_loop.dispatch(None, &mut ()).unwrap();
}

Implementations

impl NotifySource

pub fn new() -> Result<Self, Error>

Create the event source.

Errors

If the notify watcher creation failed.

Example

use calloop_notify::NotifySource;

let notify_source = NotifySource::new().unwrap();

Examples found in repository

examples/watch.rs (line 13)

fn main() {
    // Create calloop event loop.
    let mut event_loop = EventLoop::try_new().unwrap();
    let loop_handle = event_loop.handle();

    // Watch current directory recursively.
    let mut notify_source = NotifySource::new().unwrap();
    notify_source.watch(Path::new("."), RecursiveMode::Recursive).unwrap();

    // Insert notify source into calloop.
    loop_handle
        .insert_source(notify_source, |event, _, _| {
            println!("Notify Event: {event:?}");
        })
        .unwrap();

    // Dispatch event loop.
    loop {
        event_loop.dispatch(None, &mut ()).unwrap();
    }
}

Trait Implementations

impl Deref for NotifySource

type Target = INotifyWatcher

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for NotifySource

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl EventSource for NotifySource

type Error = ChannelError

The error type returned from process_events() (not the user callback!).

type Event = Event

The type of events generated by your source.

type Metadata = ()

Some metadata of your event source

type Ret = ()

The return type of the user callback

fn process_events<F>( &mut self, readiness: Readiness, token: Token, callback: F, ) -> Result<PostAction, Self::Error>

where F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,

Process any relevant events

fn register( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory, ) -> Result<()>

Register yourself to this poll instance

fn reregister( &mut self, poll: &mut Poll, token_factory: &mut TokenFactory, ) -> Result<()>

Re-register your file descriptors

fn unregister(&mut self, poll: &mut Poll) -> Result<()>

Unregister your file descriptors

const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = false

Whether this source needs to be sent the EventSource::before_sleep and EventSource::before_handle_events notifications. These are opt-in because they require more expensive checks, and almost all sources will not need these notifications

fn before_sleep(&mut self) -> Result<Option<(Readiness, Token)>, Error>

Notification that a single poll is about to begin

fn before_handle_events(&mut self, events: EventIterator<'_>)

Notification that polling is complete, and EventSource::process_events will be called with the given events for this source. The iterator may be empty, which indicates that no events were generated for this source