From d7e22791faffb7bd9bd10f031c260ae019d7f474 Mon Sep 17 00:00:00 2001 From: Alphyr <47725341+a1phyr@users.noreply.github.com> Date: Thu, 12 Aug 2021 21:27:14 +0200 Subject: [PATCH] Add `EventHandler` trait to replace `EventFn` (#346) * Add `EventHandler` trait to replace `EventFn` --- examples/async_monitor.rs | 7 ++-- examples/hot_reload_tide/src/main.rs | 4 +-- examples/monitor_raw.rs | 2 +- src/fsevent.rs | 31 +++++++---------- src/inotify.rs | 39 +++++++++++---------- src/kqueue.rs | 21 ++++++------ src/lib.rs | 51 ++++++++++++++++++++++++---- src/null.rs | 2 +- src/poll.rs | 45 ++++++++++++------------ src/windows.rs | 49 +++++++++++++------------- 10 files changed, 146 insertions(+), 105 deletions(-) diff --git a/examples/async_monitor.rs b/examples/async_monitor.rs index a0a9ab87..a940982f 100644 --- a/examples/async_monitor.rs +++ b/examples/async_monitor.rs @@ -1,6 +1,9 @@ -use notify::{RecommendedWatcher, RecursiveMode, Event, Watcher}; +use futures::{ + channel::mpsc::{channel, Receiver}, + SinkExt, StreamExt, +}; +use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher}; use std::path::Path; -use futures::{SinkExt, StreamExt, channel::mpsc::{channel, Receiver}}; fn async_watcher() -> notify::Result<(RecommendedWatcher, Receiver>)> { let (mut tx, rx) = channel(1); diff --git a/examples/hot_reload_tide/src/main.rs b/examples/hot_reload_tide/src/main.rs index 71f9acfd..362ffec9 100644 --- a/examples/hot_reload_tide/src/main.rs +++ b/examples/hot_reload_tide/src/main.rs @@ -1,12 +1,10 @@ - // Imagine this is a web app that remembers information about audio messages. // It has a config.json file that acts as a database, // you can edit the configuration and the app will pick up changes without the need to restart it. // This concept is known as hot-reloading. use hot_reload_tide::messages::{load_config, Config}; use notify::{ - event::ModifyKind, - Error, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher, + event::ModifyKind, Error, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher, }; use std::path::Path; use std::sync::{Arc, Mutex}; diff --git a/examples/monitor_raw.rs b/examples/monitor_raw.rs index 39b35845..b5b80395 100644 --- a/examples/monitor_raw.rs +++ b/examples/monitor_raw.rs @@ -6,7 +6,7 @@ fn watch>(path: P) -> notify::Result<()> { // Automatically select the best implementation for your platform. // You can also access each implementation directly e.g. INotifyWatcher. - let mut watcher = RecommendedWatcher::new(move |res| tx.send(res).unwrap())?; + let mut watcher = RecommendedWatcher::new(tx)?; // Add a path to be watched. All files and directories at that path and // below will be monitored for changes. diff --git a/src/fsevent.rs b/src/fsevent.rs index a0f81b40..48ef9e52 100644 --- a/src/fsevent.rs +++ b/src/fsevent.rs @@ -15,7 +15,7 @@ #![allow(non_upper_case_globals, dead_code)] use crate::event::*; -use crate::{Config, Error, EventFn, RecursiveMode, Result, Watcher}; +use crate::{Config, Error, EventHandler, RecursiveMode, Result, Watcher}; use crossbeam_channel::{unbounded, Sender}; use fsevent_sys as fs; use fsevent_sys::core_foundation as cf; @@ -63,7 +63,7 @@ pub struct FsEventWatcher { since_when: fs::FSEventStreamEventId, latency: cf::CFTimeInterval, flags: fs::FSEventStreamCreateFlags, - event_fn: Arc>, + event_handler: Arc>, runloop: Option<(cf::CFRunLoopRef, thread::JoinHandle<()>)>, recursive_info: HashMap, } @@ -224,7 +224,7 @@ fn translate_flags(flags: StreamFlags, precise: bool) -> Vec { } struct StreamContextInfo { - event_fn: Arc>, + event_handler: Arc>, recursive_info: HashMap, } @@ -249,7 +249,7 @@ extern "C" { } impl FsEventWatcher { - fn from_event_fn(event_fn: Arc>) -> Result { + fn from_event_handler(event_handler: Arc>) -> Result { Ok(FsEventWatcher { paths: unsafe { cf::CFArrayCreateMutable(cf::kCFAllocatorDefault, 0, &cf::kCFTypeArrayCallBacks) @@ -257,7 +257,7 @@ impl FsEventWatcher { since_when: fs::kFSEventStreamEventIdSinceNow, latency: 0.0, flags: fs::kFSEventStreamCreateFlagFileEvents | fs::kFSEventStreamCreateFlagNoDefer, - event_fn, + event_handler, runloop: None, recursive_info: HashMap::new(), }) @@ -343,11 +343,7 @@ impl FsEventWatcher { } // https://github.com/thibaudgg/rb-fsevent/blob/master/ext/fsevent_watch/main.c - fn append_path( - &mut self, - path: &Path, - recursive_mode: RecursiveMode, - ) -> Result<()> { + fn append_path(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> { if !path.exists() { return Err(Error::path_not_found().add_path(path.into())); } @@ -382,7 +378,7 @@ impl FsEventWatcher { // stream is closed. This means we will leak the context if we panic before reacing // `FSEventStreamRelease`. let context = Box::into_raw(Box::new(StreamContextInfo { - event_fn: self.event_fn.clone(), + event_handler: self.event_handler.clone(), recursive_info: self.recursive_info.clone(), })); @@ -486,7 +482,7 @@ unsafe fn callback_impl( ) { let event_paths = event_paths as *const *const libc::c_char; let info = info as *const StreamContextInfo; - let event_fn = &(*info).event_fn; + let event_handler = &(*info).event_handler; for p in 0..num_events { let path = CStr::from_ptr(*event_paths.add(p)) @@ -521,16 +517,16 @@ unsafe fn callback_impl( for ev in translate_flags(flag, true).into_iter() { // TODO: precise let ev = ev.add_path(path.clone()); - let mut event_fn = event_fn.lock().expect("lock not to be poisoned"); - (event_fn)(Ok(ev)); + let mut event_handler = event_handler.lock().expect("lock not to be poisoned"); + event_handler.handle_event(Ok(ev)); } } } impl Watcher for FsEventWatcher { /// Create a new watcher. - fn new(event_fn: F) -> Result { - Self::from_event_fn(Arc::new(Mutex::new(event_fn))) + fn new(event_handler: F) -> Result { + Self::from_event_handler(Arc::new(Mutex::new(event_handler))) } fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> { @@ -565,10 +561,9 @@ fn test_fsevent_watcher_drop() { let dir = tempfile::tempdir().unwrap(); let (tx, rx) = std::sync::mpsc::channel(); - let event_fn = move |res| tx.send(res).unwrap(); { - let mut watcher = FsEventWatcher::new(event_fn).unwrap(); + let mut watcher = FsEventWatcher::new(tx).unwrap(); watcher.watch(dir.path(), RecursiveMode::Recursive).unwrap(); thread::sleep(Duration::from_millis(2000)); println!("is running -> {}", watcher.is_running()); diff --git a/src/inotify.rs b/src/inotify.rs index 9d32bfed..c17c2333 100644 --- a/src/inotify.rs +++ b/src/inotify.rs @@ -5,7 +5,7 @@ //! will return events for the directory itself, and for files inside the directory. use super::event::*; -use super::{Config, Error, ErrorKind, EventFn, RecursiveMode, Result, Watcher}; +use super::{Config, Error, ErrorKind, EventHandler, RecursiveMode, Result, Watcher}; use crossbeam_channel::{bounded, unbounded, Sender}; use inotify as inotify_sys; use inotify_sys::{EventMask, Inotify, WatchDescriptor, WatchMask}; @@ -35,7 +35,7 @@ struct EventLoop { event_loop_tx: crossbeam_channel::Sender, event_loop_rx: crossbeam_channel::Receiver, inotify: Option, - event_fn: Box, + event_handler: Box, watches: HashMap, paths: HashMap, rename_event: Option, @@ -56,9 +56,9 @@ enum EventLoopMsg { } #[inline] -fn send_pending_rename_event(rename_event: &mut Option, event_fn: &mut dyn EventFn) { +fn send_pending_rename_event(rename_event: &mut Option, event_handler: &mut dyn EventHandler) { if let Some(e) = rename_event.take() { - event_fn(Ok(e)); + event_handler.handle_event(Ok(e)); } } @@ -96,7 +96,7 @@ fn remove_watch_by_event( } impl EventLoop { - pub fn new(inotify: Inotify, event_fn: Box) -> Result { + pub fn new(inotify: Inotify, event_handler: Box) -> Result { let (event_loop_tx, event_loop_rx) = crossbeam_channel::unbounded::(); let poll = mio::Poll::new()?; @@ -114,7 +114,7 @@ impl EventLoop { event_loop_tx, event_loop_rx, inotify: Some(inotify), - event_fn, + event_handler, watches: HashMap::new(), paths: HashMap::new(), rename_event: None, @@ -142,7 +142,7 @@ impl EventLoop { // Process whatever happened. for event in &events { - self.handle_event(&event); + self.handle_event(event); } // Stop, if we're done. @@ -188,7 +188,7 @@ impl EventLoop { let current_cookie = self.rename_event.as_ref().and_then(|e| e.tracker()); // send pending rename event only if the rename event for which the timer has been created hasn't been handled already; otherwise ignore this timeout if current_cookie == Some(cookie) { - send_pending_rename_event(&mut self.rename_event, &mut *self.event_fn); + send_pending_rename_event(&mut self.rename_event, &mut *self.event_handler); } } EventLoopMsg::Configure(config, tx) => { @@ -218,7 +218,7 @@ impl EventLoop { num_events += 1; if event.mask.contains(EventMask::Q_OVERFLOW) { let ev = Ok(Event::new(EventKind::Other).set_flag(Flag::Rescan)); - (self.event_fn)(ev); + self.event_handler.handle_event(ev); } let path = match event.name { @@ -229,7 +229,10 @@ impl EventLoop { }; if event.mask.contains(EventMask::MOVED_FROM) { - send_pending_rename_event(&mut self.rename_event, &mut *self.event_fn); + send_pending_rename_event( + &mut self.rename_event, + &mut *self.event_handler, + ); remove_watch_by_event(&path, &self.watches, &mut remove_watches); self.rename_event = Some( Event::new(EventKind::Modify(ModifyKind::Name( @@ -243,7 +246,7 @@ impl EventLoop { if event.mask.contains(EventMask::MOVED_TO) { if let Some(e) = self.rename_event.take() { if e.tracker() == Some(event.cookie as usize) { - (self.event_fn)(Ok(e.clone())); + self.event_handler.handle_event(Ok(e.clone())); evs.push( Event::new(EventKind::Modify(ModifyKind::Name( RenameMode::To, @@ -384,12 +387,12 @@ impl EventLoop { if !evs.is_empty() { send_pending_rename_event( &mut self.rename_event, - &mut *self.event_fn, + &mut *self.event_handler, ); } for ev in evs { - (self.event_fn)(Ok(ev)); + self.event_handler.handle_event(Ok(ev)); } } } @@ -421,7 +424,7 @@ impl EventLoop { } } Err(e) => { - (self.event_fn)(Err(Error::io(e))); + self.event_handler.handle_event(Err(Error::io(e))); } } } @@ -554,9 +557,9 @@ fn filter_dir(e: walkdir::Result) -> Option) -> Result { + fn from_event_handler(event_handler: Box) -> Result { let inotify = Inotify::init()?; - let event_loop = EventLoop::new(inotify, event_fn)?; + let event_loop = EventLoop::new(inotify, event_handler)?; let channel = event_loop.event_loop_tx.clone(); let waker = event_loop.event_loop_waker.clone(); event_loop.run(); @@ -598,8 +601,8 @@ impl INotifyWatcher { impl Watcher for INotifyWatcher { /// Create a new watcher. - fn new(event_fn: F) -> Result { - Self::from_event_fn(Box::new(event_fn)) + fn new(event_handler: F) -> Result { + Self::from_event_handler(Box::new(event_handler)) } fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> { diff --git a/src/kqueue.rs b/src/kqueue.rs index 57c2afca..619df009 100644 --- a/src/kqueue.rs +++ b/src/kqueue.rs @@ -5,7 +5,7 @@ //! pieces of kernel code termed filters. use super::event::*; -use super::{Error, EventFn, RecursiveMode, Result, Watcher}; +use super::{Error, EventHandler, RecursiveMode, Result, Watcher}; use crossbeam_channel::{unbounded, Sender}; use kqueue::{EventData, EventFilter, FilterFlag, Ident}; use std::collections::HashMap; @@ -32,7 +32,7 @@ struct EventLoop { event_loop_tx: crossbeam_channel::Sender, event_loop_rx: crossbeam_channel::Receiver, kqueue: kqueue::Watcher, - event_fn: Box, + event_handler: Box, watches: HashMap, } @@ -49,7 +49,7 @@ enum EventLoopMsg { } impl EventLoop { - pub fn new(kqueue: kqueue::Watcher, event_fn: Box) -> Result { + pub fn new(kqueue: kqueue::Watcher, event_handler: Box) -> Result { let (event_loop_tx, event_loop_rx) = crossbeam_channel::unbounded::(); let poll = mio::Poll::new()?; @@ -67,7 +67,7 @@ impl EventLoop { event_loop_tx, event_loop_rx, kqueue, - event_fn, + event_handler, watches: HashMap::new(), }; Ok(event_loop) @@ -93,7 +93,7 @@ impl EventLoop { // Process whatever happened. for event in &events { - self.handle_event(&event); + self.handle_event(event); } // Stop, if we're done. @@ -225,7 +225,7 @@ impl EventLoop { } } .add_path(path); - (self.event_fn)(Ok(event)); + self.event_handler.handle_event(Ok(event)); } // as we don't add any other EVFILTER to kqueue we should never get here kqueue::Event { ident: _, data: _ } => unreachable!(), @@ -320,9 +320,9 @@ fn filter_dir(e: walkdir::Result) -> Option) -> Result { + fn from_event_handler(event_handler: Box) -> Result { let kqueue = kqueue::Watcher::new()?; - let event_loop = EventLoop::new(kqueue, event_fn)?; + let event_loop = EventLoop::new(kqueue, event_handler)?; let channel = event_loop.event_loop_tx.clone(); let waker = event_loop.event_loop_waker.clone(); event_loop.run(); @@ -374,10 +374,11 @@ impl KqueueWatcher { impl Watcher for KqueueWatcher { /// Create a new watcher. - fn new(event_fn: F) -> Result { - Self::from_event_fn(Box::new(event_fn)) + fn new(event_handler: F) -> Result { + Self::from_event_handler(Box::new(event_handler)) } + fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> { self.watch_inner(path, recursive_mode) } diff --git a/src/lib.rs b/src/lib.rs index 0cb4c83b..1c777af5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -139,9 +139,48 @@ mod config; mod error; /// The set of requirements for watcher event handling functions. -pub trait EventFn: 'static + FnMut(Result) + Send {} +/// +/// # Example implementation +/// +/// ```no_run +/// use notify::{Event, Result, EventHandler}; +/// +/// /// Prints received events +/// struct EventPrinter; +/// +/// impl EventHandler for EventPrinter { +/// fn handle_event(&mut self, event: Result) { +/// if let Ok(event) = event { +/// println!("Event: {:?}", event); +/// } +/// } +/// } +/// ``` +pub trait EventHandler: Send + 'static { + /// Handles an event. + fn handle_event(&mut self, event: Result); +} -impl EventFn for F where F: 'static + FnMut(Result) + Send {} +impl EventHandler for F +where + F: FnMut(Result) + Send + 'static, +{ + fn handle_event(&mut self, event: Result) { + (self)(event); + } +} + +impl EventHandler for crossbeam_channel::Sender> { + fn handle_event(&mut self, event: Result) { + let _ = self.send(event); + } +} + +impl EventHandler for std::sync::mpsc::Sender> { + fn handle_event(&mut self, event: Result) { + let _ = self.send(event); + } +} /// Type that can deliver file activity notifications /// @@ -150,7 +189,7 @@ impl EventFn for F where F: 'static + FnMut(Result) + Send {} /// that should work on any platform. pub trait Watcher { /// Create a new watcher. - fn new(event_fn: F) -> Result where Self: Sized; + fn new(event_handler: F) -> Result where Self: Sized; /// Begin watching a new path. /// /// If the `path` is a directory, `recursive_mode` will be evaluated. If `recursive_mode` is @@ -215,12 +254,12 @@ pub type RecommendedWatcher = PollWatcher; /// _immediate_ mode. /// /// See [`Watcher::new_immediate`](trait.Watcher.html#tymethod.new_immediate). -pub fn recommended_watcher(event_fn: F) -> Result +pub fn recommended_watcher(event_handler: F) -> Result where - F: EventFn, + F: EventHandler, { // All recommended watchers currently implement `new`, so just call that. - RecommendedWatcher::new(event_fn) + RecommendedWatcher::new(event_handler) } #[cfg(test)] diff --git a/src/null.rs b/src/null.rs index 01fef9ae..f8763e3e 100644 --- a/src/null.rs +++ b/src/null.rs @@ -19,7 +19,7 @@ impl Watcher for NullWatcher { Ok(()) } - fn new(event_fn: F) -> Result where Self: Sized { + fn new(event_handler: F) -> Result where Self: Sized { Ok(NullWatcher) } } diff --git a/src/poll.rs b/src/poll.rs index f280e599..e7a050ad 100644 --- a/src/poll.rs +++ b/src/poll.rs @@ -4,7 +4,7 @@ //! Rust stdlib APIs and should work on all of the platforms it supports. use super::event::*; -use super::{Error, EventFn, RecursiveMode, Result, Watcher}; +use super::{Error, EventHandler, RecursiveMode, Result, Watcher}; use filetime::FileTime; use std::collections::HashMap; use std::fs; @@ -29,24 +29,27 @@ struct WatchData { /// Polling based `Watcher` implementation pub struct PollWatcher { - event_fn: Arc>, + event_handler: Arc>, watches: Arc>>, open: Arc, delay: Duration, } -fn emit_event(event_fn: &Mutex, res: Result) { - if let Ok(mut guard) = event_fn.lock() { - let f: &mut dyn EventFn = &mut *guard; - f(res); +fn emit_event(event_handler: &Mutex, res: Result) { + if let Ok(mut guard) = event_handler.lock() { + let f: &mut dyn EventHandler = &mut *guard; + f.handle_event(res); } } impl PollWatcher { /// Create a [PollWatcher] which polls every `delay` milliseconds - pub fn with_delay(event_fn: Arc>, delay: Duration) -> Result { + pub fn with_delay( + event_handler: Arc>, + delay: Duration, + ) -> Result { let mut p = PollWatcher { - event_fn, + event_handler, watches: Arc::new(Mutex::new(HashMap::new())), open: Arc::new(AtomicBool::new(true)), delay, @@ -59,8 +62,8 @@ impl PollWatcher { let watches = self.watches.clone(); let open = self.open.clone(); let delay = self.delay; - let event_fn = self.event_fn.clone(); - let event_fn = move |res| emit_event(&event_fn, res); + let event_handler = self.event_handler.clone(); + let event_handler = move |res| emit_event(&event_handler, res); thread::spawn(move || { // In order of priority: @@ -87,7 +90,7 @@ impl PollWatcher { match fs::metadata(watch) { Err(e) => { let err = Err(Error::io(e).add_path(watch.clone())); - event_fn(err); + event_handler(err); continue; } Ok(metadata) => { @@ -112,7 +115,7 @@ impl PollWatcher { let meta = ModifyKind::Metadata(kind); let kind = EventKind::Modify(meta); let ev = Event::new(kind).add_path(watch.clone()); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } } } @@ -130,7 +133,7 @@ impl PollWatcher { Err(e) => { let err = Error::io(e.into()) .add_path(path.to_path_buf()); - event_fn(Err(err)); + event_handler(Err(err)); } Ok(m) => { let mtime = @@ -148,7 +151,7 @@ impl PollWatcher { EventKind::Create(CreateKind::Any); let ev = Event::new(kind) .add_path(path.to_path_buf()); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } Some(PathData { mtime: old_mtime, .. @@ -160,7 +163,7 @@ impl PollWatcher { // TODO add new mtime as attr let ev = Event::new(kind) .add_path(path.to_path_buf()); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } } } @@ -178,7 +181,7 @@ impl PollWatcher { if last_check < current_time { let ev = Event::new(EventKind::Remove(RemoveKind::Any)) .add_path(path.clone()); - event_fn(Ok(ev)); + event_handler(Ok(ev)); removed.push(path.clone()); } } @@ -202,7 +205,7 @@ impl PollWatcher { match fs::metadata(path) { Err(e) => { let err = Error::io(e).add_path(watch); - emit_event(&self.event_fn, Err(err)); + emit_event(&self.event_handler, Err(err)); } Ok(metadata) => { let mut paths = HashMap::new(); @@ -233,7 +236,7 @@ impl PollWatcher { match entry.metadata() { Err(e) => { let err = Error::io(e.into()).add_path(path.to_path_buf()); - emit_event(&self.event_fn, Err(err)); + emit_event(&self.event_handler, Err(err)); } Ok(m) => { let mtime = FileTime::from_last_modification_time(&m).seconds(); @@ -273,10 +276,10 @@ impl PollWatcher { impl Watcher for PollWatcher { /// Create a new [PollWatcher]. - fn new(event_fn: F) -> Result { - let event_fn = Arc::new(Mutex::new(event_fn)); + fn new(event_handler: F) -> Result { + let event_handler = Arc::new(Mutex::new(event_handler)); let delay = Duration::from_secs(30); - Self::with_delay(event_fn, delay) + Self::with_delay(event_handler, delay) } fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> { diff --git a/src/windows.rs b/src/windows.rs index f24ae628..d38cb026 100644 --- a/src/windows.rs +++ b/src/windows.rs @@ -16,7 +16,7 @@ use winapi::um::winbase::{self, INFINITE, WAIT_OBJECT_0}; use winapi::um::winnt::{self, FILE_NOTIFY_INFORMATION, HANDLE}; use crate::event::*; -use crate::{Config, Error, EventFn, RecursiveMode, Result, Watcher}; +use crate::{Config, Error, EventHandler, RecursiveMode, Result, Watcher}; use crossbeam_channel::{bounded, unbounded, Receiver, Sender}; use std::collections::HashMap; use std::env; @@ -41,7 +41,7 @@ struct ReadData { } struct ReadDirectoryRequest { - event_fn: Arc>, + event_handler: Arc>, buffer: [u8; BUF_SIZE as usize], handle: HANDLE, data: ReadData, @@ -66,7 +66,7 @@ struct WatchState { struct ReadDirectoryChangesServer { rx: Receiver, - event_fn: Arc>, + event_handler: Arc>, meta_tx: Sender, cmd_tx: Sender>, watches: HashMap, @@ -75,7 +75,7 @@ struct ReadDirectoryChangesServer { impl ReadDirectoryChangesServer { fn start( - event_fn: Arc>, + event_handler: Arc>, meta_tx: Sender, cmd_tx: Sender>, wakeup_sem: HANDLE, @@ -87,7 +87,7 @@ impl ReadDirectoryChangesServer { let wakeup_sem = sem_temp as HANDLE; let server = ReadDirectoryChangesServer { rx: action_rx, - event_fn, + event_handler, meta_tx, cmd_tx, watches: HashMap::new(), @@ -213,7 +213,7 @@ impl ReadDirectoryChangesServer { complete_sem: semaphore, }; self.watches.insert(path.clone(), ws); - start_read(&rd, self.event_fn.clone(), handle); + start_read(&rd, self.event_handler.clone(), handle); Ok(path) } @@ -245,9 +245,9 @@ fn stop_watch(ws: &WatchState, meta_tx: &Sender) { let _ = meta_tx.send(MetaEvent::SingleWatchComplete); } -fn start_read(rd: &ReadData, event_fn: Arc>, handle: HANDLE) { +fn start_read(rd: &ReadData, event_handler: Arc>, handle: HANDLE) { let mut request = Box::new(ReadDirectoryRequest { - event_fn, + event_handler, handle, buffer: [0u8; BUF_SIZE as usize], data: rd.clone(), @@ -318,7 +318,7 @@ unsafe extern "system" fn handle_event( } // Get the next request queued up as soon as possible - start_read(&request.data, request.event_fn.clone(), request.handle); + start_read(&request.data, request.event_handler.clone(), request.handle); // The FILE_NOTIFY_INFORMATION struct has a variable length due to the variable length // string as its last member. Each struct contains an offset for getting the next entry in @@ -345,42 +345,42 @@ unsafe extern "system" fn handle_event( if !skip { let newe = Event::new(EventKind::Any).add_path(path); - fn emit_event(event_fn: &Mutex, res: Result) { - if let Ok(mut guard) = event_fn.lock() { - let f: &mut dyn EventFn = &mut *guard; - f(res); + fn emit_event(event_handler: &Mutex, res: Result) { + if let Ok(mut guard) = event_handler.lock() { + let f: &mut dyn EventHandler = &mut *guard; + f.handle_event(res); } } - let event_fn = |res| emit_event(&request.event_fn, res); + let event_handler = |res| emit_event(&request.event_handler, res); if (*cur_entry).Action == winnt::FILE_ACTION_RENAMED_OLD_NAME { let mode = RenameMode::From; let kind = ModifyKind::Name(mode); let kind = EventKind::Modify(kind); let ev = newe.set_kind(kind); - event_fn(Ok(ev)) + event_handler(Ok(ev)) } else { match (*cur_entry).Action { winnt::FILE_ACTION_RENAMED_NEW_NAME => { let kind = EventKind::Modify(ModifyKind::Name(RenameMode::To)); let ev = newe.set_kind(kind); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } winnt::FILE_ACTION_ADDED => { let kind = EventKind::Create(CreateKind::Any); let ev = newe.set_kind(kind); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } winnt::FILE_ACTION_REMOVED => { let kind = EventKind::Remove(RemoveKind::Any); let ev = newe.set_kind(kind); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } winnt::FILE_ACTION_MODIFIED => { let kind = EventKind::Modify(ModifyKind::Any); let ev = newe.set_kind(kind); - event_fn(Ok(ev)); + event_handler(Ok(ev)); } _ => (), }; @@ -403,9 +403,8 @@ pub struct ReadDirectoryChangesWatcher { } impl ReadDirectoryChangesWatcher { - pub fn create( - event_fn: Arc>, + event_handler: Arc>, meta_tx: Sender, ) -> Result { let (cmd_tx, cmd_rx) = unbounded(); @@ -416,7 +415,7 @@ impl ReadDirectoryChangesWatcher { return Err(Error::generic("Failed to create wakeup semaphore.")); } - let action_tx = ReadDirectoryChangesServer::start(event_fn, meta_tx, cmd_tx, wakeup_sem); + let action_tx = ReadDirectoryChangesServer::start(event_handler, meta_tx, cmd_tx, wakeup_sem); Ok(ReadDirectoryChangesWatcher { tx: action_tx, @@ -492,12 +491,12 @@ impl ReadDirectoryChangesWatcher { } impl Watcher for ReadDirectoryChangesWatcher { - fn new(event_fn: F) -> Result { + fn new(event_handler: F) -> Result { // create dummy channel for meta event // TODO: determine the original purpose of this - can we remove it? let (meta_tx, _) = unbounded(); - let event_fn = Arc::new(Mutex::new(event_fn)); - Self::create(event_fn, meta_tx) + let event_handler = Arc::new(Mutex::new(event_handler)); + Self::create(event_handler, meta_tx) } fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {