]> git.saurik.com Git - wxWidgets.git/blob - src/unix/fswatcher_inotify.cpp
Remove all lines containing cvs/svn "$Id$" keyword.
[wxWidgets.git] / src / unix / fswatcher_inotify.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/fswatcher_inotify.cpp
3 // Purpose: inotify-based wxFileSystemWatcher implementation
4 // Author: Bartosz Bekier
5 // Created: 2009-05-26
6 // Copyright: (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __BORLANDC__
14 #pragma hdrstop
15 #endif
16
17 #if wxUSE_FSWATCHER
18
19 #include "wx/fswatcher.h"
20
21 #ifdef wxHAS_INOTIFY
22
23 #include <sys/inotify.h>
24 #include <unistd.h>
25 #include "wx/private/fswatcher.h"
26
27 // ============================================================================
28 // wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
29 // ============================================================================
30
31 // inotify watch descriptor => wxFSWatchEntry* map
32 WX_DECLARE_HASH_MAP(int, wxFSWatchEntry*, wxIntegerHash, wxIntegerEqual,
33 wxFSWatchEntryDescriptors);
34
35 // inotify event cookie => inotify_event* map
36 WX_DECLARE_HASH_MAP(int, inotify_event*, wxIntegerHash, wxIntegerEqual,
37 wxInotifyCookies);
38
39 /**
40 * Helper class encapsulating inotify mechanism
41 */
42 class wxFSWatcherImplUnix : public wxFSWatcherImpl
43 {
44 public:
45 wxFSWatcherImplUnix(wxFileSystemWatcherBase* watcher) :
46 wxFSWatcherImpl(watcher),
47 m_source(NULL),
48 m_ifd(-1)
49 {
50 m_handler = new wxFSWSourceHandler(this);
51 }
52
53 ~wxFSWatcherImplUnix()
54 {
55 // we close inotify only if initialized before
56 if (IsOk())
57 {
58 Close();
59 }
60
61 delete m_handler;
62 }
63
64 bool Init()
65 {
66 wxCHECK_MSG( !IsOk(), false, "Inotify already initialized" );
67
68 wxEventLoopBase *loop = wxEventLoopBase::GetActive();
69 wxCHECK_MSG( loop, false, "File system watcher needs an event loop" );
70
71 m_ifd = inotify_init();
72 if ( m_ifd == -1 )
73 {
74 wxLogSysError( _("Unable to create inotify instance") );
75 return false;
76 }
77
78 m_source = loop->AddSourceForFD
79 (
80 m_ifd,
81 m_handler,
82 wxEVENT_SOURCE_INPUT | wxEVENT_SOURCE_EXCEPTION
83 );
84
85 return m_source != NULL;
86 }
87
88 void Close()
89 {
90 wxCHECK_RET( IsOk(),
91 "Inotify not initialized or invalid inotify descriptor" );
92
93 wxDELETE(m_source);
94
95 if ( close(m_ifd) != 0 )
96 {
97 wxLogSysError( _("Unable to close inotify instance") );
98 }
99 }
100
101 virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryUnix> watch)
102 {
103 wxCHECK_MSG( IsOk(), false,
104 "Inotify not initialized or invalid inotify descriptor" );
105
106 int wd = DoAddInotify(watch.get());
107 if (wd == -1)
108 {
109 wxLogSysError( _("Unable to add inotify watch") );
110 return false;
111 }
112
113 wxFSWatchEntryDescriptors::value_type val(wd, watch.get());
114 if (!m_watchMap.insert(val).second)
115 {
116 wxFAIL_MSG( wxString::Format( "Path %s is already watched",
117 watch->GetPath()) );
118 return false;
119 }
120
121 return true;
122 }
123
124 virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryUnix> watch)
125 {
126 wxCHECK_MSG( IsOk(), false,
127 "Inotify not initialized or invalid inotify descriptor" );
128
129 int ret = DoRemoveInotify(watch.get());
130 if (ret == -1)
131 {
132 wxLogSysError( _("Unable to remove inotify watch") );
133 return false;
134 }
135
136 if (m_watchMap.erase(watch->GetWatchDescriptor()) != 1)
137 {
138 wxFAIL_MSG( wxString::Format("Path %s is not watched",
139 watch->GetPath()) );
140 }
141 // Cache the wd in case any events arrive late
142 m_staleDescriptors.Add(watch->GetWatchDescriptor());
143
144 watch->SetWatchDescriptor(-1);
145 return true;
146 }
147
148 virtual bool RemoveAll()
149 {
150 wxFSWatchEntries::iterator it = m_watches.begin();
151 for ( ; it != m_watches.end(); ++it )
152 {
153 (void) DoRemove(it->second);
154 }
155 m_watches.clear();
156 return true;
157 }
158
159 int ReadEvents()
160 {
161 wxCHECK_MSG( IsOk(), -1,
162 "Inotify not initialized or invalid inotify descriptor" );
163
164 // read events
165 // TODO differentiate depending on params
166 char buf[128 * sizeof(inotify_event)];
167 int left = ReadEventsToBuf(buf, sizeof(buf));
168 if (left == -1)
169 return -1;
170
171 // left > 0, we have events
172 char* memory = buf;
173 int event_count = 0;
174 while (left > 0) // OPT checking 'memory' would suffice
175 {
176 event_count++;
177 inotify_event* e = (inotify_event*)memory;
178
179 // process one inotify_event
180 ProcessNativeEvent(*e);
181
182 int offset = sizeof(inotify_event) + e->len;
183 left -= offset;
184 memory += offset;
185 }
186
187 // take care of unmatched renames
188 ProcessRenames();
189
190 wxLogTrace(wxTRACE_FSWATCHER, "We had %d native events", event_count);
191 return event_count;
192 }
193
194 bool IsOk() const
195 {
196 return m_source != NULL;
197 }
198
199 protected:
200 int DoAddInotify(wxFSWatchEntry* watch)
201 {
202 int flags = Watcher2NativeFlags(watch->GetFlags());
203 int wd = inotify_add_watch(m_ifd, watch->GetPath().fn_str(), flags);
204 // finally we can set watch descriptor
205 watch->SetWatchDescriptor(wd);
206 return wd;
207 }
208
209 int DoRemoveInotify(wxFSWatchEntry* watch)
210 {
211 return inotify_rm_watch(m_ifd, watch->GetWatchDescriptor());
212 }
213
214 void ProcessNativeEvent(const inotify_event& inevt)
215 {
216 wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));
217
218 // after removing inotify watch we get IN_IGNORED for it, but the watch
219 // will be already removed from our list at that time
220 if (inevt.mask & IN_IGNORED)
221 {
222 // It is now safe to remove it from the stale descriptors too, we
223 // won't get any more events for it.
224 // However if we're here because a dir that we're still watching
225 // has just been deleted, its wd won't be on this list
226 const int pos = m_staleDescriptors.Index(inevt.wd);
227 if ( pos != wxNOT_FOUND )
228 {
229 m_staleDescriptors.RemoveAt(static_cast<size_t>(pos));
230 wxLogTrace(wxTRACE_FSWATCHER,
231 "Removed wd %i from the stale-wd cache", inevt.wd);
232 }
233 return;
234 }
235
236 // get watch entry for this event
237 wxFSWatchEntryDescriptors::iterator it = m_watchMap.find(inevt.wd);
238
239 // wd will be -1 for IN_Q_OVERFLOW, which would trigger the wxFAIL_MSG
240 if (inevt.wd != -1)
241 {
242 if (it == m_watchMap.end())
243 {
244 // It's not in the map; check if was recently removed from it.
245 if (m_staleDescriptors.Index(inevt.wd) != wxNOT_FOUND)
246 {
247 wxLogTrace(wxTRACE_FSWATCHER,
248 "Got an event for stale wd %i", inevt.wd);
249 }
250 else
251 {
252 // In theory we shouldn't reach here. In practice, some
253 // events, e.g. IN_MODIFY, arrive just after the IN_IGNORED
254 // so their wd has already been discarded. Warn about them.
255 wxFileSystemWatcherEvent
256 event
257 (
258 wxFSW_EVENT_WARNING,
259 wxString::Format
260 (
261 _("Unexpected event for \"%s\": no "
262 "matching watch descriptor."),
263 inevt.len ? inevt.name : ""
264 )
265 );
266 SendEvent(event);
267
268 }
269
270 // In any case, don't process this event: it's either for an
271 // already removed entry, or for an unknown one.
272 return;
273 }
274 }
275
276 int nativeFlags = inevt.mask;
277 int flags = Native2WatcherFlags(nativeFlags);
278
279 // check out for error/warning condition
280 if (flags & wxFSW_EVENT_WARNING || flags & wxFSW_EVENT_ERROR)
281 {
282 wxString errMsg = GetErrorDescription(nativeFlags);
283 wxFileSystemWatcherEvent event(flags, errMsg);
284 SendEvent(event);
285 return;
286 }
287
288 if (inevt.wd == -1)
289 {
290 // Although this is not supposed to happen, we seem to be getting
291 // occasional IN_ACCESS/IN_MODIFY events without valid watch value.
292 wxFileSystemWatcherEvent
293 event
294 (
295 wxFSW_EVENT_WARNING,
296 wxString::Format
297 (
298 _("Invalid inotify event for \"%s\""),
299 inevt.len ? inevt.name : ""
300 )
301 );
302 SendEvent(event);
303 return;
304 }
305
306 wxFSWatchEntry& watch = *(it->second);
307
308 // Now IN_UNMOUNT. We must do so here, as it's not in the watch flags
309 if (nativeFlags & IN_UNMOUNT)
310 {
311 wxFileName path = GetEventPath(watch, inevt);
312 wxFileSystemWatcherEvent event(wxFSW_EVENT_UNMOUNT, path, path);
313 SendEvent(event);
314 }
315 // filter out ignored events and those not asked for.
316 // we never filter out warnings or exceptions
317 else if ((flags == 0) || !(flags & watch.GetFlags()))
318 {
319 return;
320 }
321
322 // Creation
323 // We need do something here only if the original watch was recursive;
324 // we don't watch a child dir itself inside a non-tree watch.
325 // We watch only dirs explicitly, so we don't want file IN_CREATEs.
326 // Distinguish by whether nativeFlags contain IN_ISDIR
327 else if ((nativeFlags & IN_CREATE) &&
328 (watch.GetType() == wxFSWPath_Tree) && (inevt.mask & IN_ISDIR))
329 {
330 wxFileName fn = GetEventPath(watch, inevt);
331 // Though it's a dir, fn treats it as a file. So:
332 fn.AssignDir(fn.GetFullPath());
333
334 if (m_watcher->AddAny(fn, wxFSW_EVENT_ALL,
335 wxFSWPath_Tree, watch.GetFilespec()))
336 {
337 // Tell the owner, in case it's interested
338 // If there's a filespec, assume he's not
339 if (watch.GetFilespec().empty())
340 {
341 wxFileSystemWatcherEvent event(flags, fn, fn);
342 SendEvent(event);
343 }
344 }
345 }
346
347 // Deletion
348 // We watch only dirs explicitly, so we don't want file IN_DELETEs.
349 // We obviously can't check using DirExists() as the object has been
350 // deleted; and nativeFlags here doesn't contain IN_ISDIR, even for
351 // a dir. Fortunately IN_DELETE_SELF doesn't happen for files. We need
352 // to do something here only inside a tree watch, or if it's the parent
353 // dir that's deleted. Otherwise let the parent dir cope
354 else if ((nativeFlags & IN_DELETE_SELF) &&
355 ((watch.GetType() == wxFSWPath_Dir) ||
356 (watch.GetType() == wxFSWPath_Tree)))
357 {
358 // We must remove the deleted directory from the map, so that
359 // DoRemoveInotify() isn't called on it in the future. Don't assert
360 // if the wd isn't found: repeated IN_DELETE_SELFs can occur
361 wxFileName fn = GetEventPath(watch, inevt);
362 wxString path(fn.GetPathWithSep());
363
364 if (m_watchMap.erase(inevt.wd) == 1)
365 {
366 // Delete from wxFileSystemWatcher
367 wxDynamicCast(m_watcher, wxInotifyFileSystemWatcher)->
368 OnDirDeleted(path);
369
370 // Now remove from our local list of watched items
371 wxFSWatchEntries::iterator wit =
372 m_watches.find(path);
373 if (wit != m_watches.end())
374 {
375 m_watches.erase(wit);
376 }
377
378 // Cache the wd in case any events arrive late
379 m_staleDescriptors.Add(inevt.wd);
380 }
381
382 // Tell the owner, in case it's interested
383 // If there's a filespec, assume he's not
384 if (watch.GetFilespec().empty())
385 {
386 wxFileSystemWatcherEvent event(flags, fn, fn);
387 SendEvent(event);
388 }
389 }
390
391 // renames
392 else if (nativeFlags & IN_MOVE)
393 {
394 // IN_MOVE events are produced in the following circumstances:
395 // * A move within a dir (what the user sees as a rename) gives an
396 // IN_MOVED_FROM and IN_MOVED_TO pair, each with the same path.
397 // * A move within watched dir foo/ e.g. from foo/bar1/ to foo/bar2/
398 // will also produce such a pair, but with different paths.
399 // * A move to baz/ will give only an IN_MOVED_FROM for foo/bar1;
400 // if baz/ is inside a different watch, that gets the IN_MOVED_TO.
401
402 // The first event to arrive, usually the IN_MOVED_FROM, is
403 // cached to await a matching IN_MOVED_TO; should none arrive, the
404 // unpaired event will be processed later in ProcessRenames().
405 wxInotifyCookies::iterator it2 = m_cookies.find(inevt.cookie);
406 if ( it2 == m_cookies.end() )
407 {
408 int size = sizeof(inevt) + inevt.len;
409 inotify_event* e = (inotify_event*) operator new (size);
410 memcpy(e, &inevt, size);
411
412 wxInotifyCookies::value_type val(e->cookie, e);
413 m_cookies.insert(val);
414 }
415 else
416 {
417 inotify_event& oldinevt = *(it2->second);
418
419 // Tell the owner, in case it's interested
420 // If there's a filespec, assume he's not
421 if ( watch.GetFilespec().empty() )
422 {
423 // The the only way to know the path for the first event,
424 // normally the IN_MOVED_FROM, is to retrieve the watch
425 // corresponding to oldinevt. This is needed for a move
426 // within a watch.
427 wxFSWatchEntry* oldwatch;
428 wxFSWatchEntryDescriptors::iterator oldwatch_it =
429 m_watchMap.find(oldinevt.wd);
430 if (oldwatch_it != m_watchMap.end())
431 {
432 oldwatch = oldwatch_it->second;
433 }
434 else
435 {
436 wxLogTrace(wxTRACE_FSWATCHER,
437 "oldinevt's watch descriptor not in the watch map");
438 // For want of a better alternative, use 'watch'. That
439 // will work fine for renames, though not for moves
440 oldwatch = &watch;
441 }
442
443 wxFileSystemWatcherEvent event(flags);
444 if ( inevt.mask & IN_MOVED_FROM )
445 {
446 event.SetPath(GetEventPath(watch, inevt));
447 event.SetNewPath(GetEventPath(*oldwatch, oldinevt));
448 }
449 else
450 {
451 event.SetPath(GetEventPath(*oldwatch, oldinevt));
452 event.SetNewPath(GetEventPath(watch, inevt));
453 }
454 SendEvent(event);
455 }
456
457 m_cookies.erase(it2);
458 delete &oldinevt;
459 }
460 }
461 // every other kind of event
462 else
463 {
464 wxFileName path = GetEventPath(watch, inevt);
465 // For files, check that it matches any filespec
466 if ( MatchesFilespec(path, watch.GetFilespec()) )
467 {
468 wxFileSystemWatcherEvent event(flags, path, path);
469 SendEvent(event);
470 }
471 }
472 }
473
474 void ProcessRenames()
475 {
476 // After all of a batch of events has been processed, this deals with
477 // any still-unpaired IN_MOVED_FROM or IN_MOVED_TO events.
478 wxInotifyCookies::iterator it = m_cookies.begin();
479 while ( it != m_cookies.end() )
480 {
481 inotify_event& inevt = *(it->second);
482
483 wxLogTrace(wxTRACE_FSWATCHER, "Processing pending rename events");
484 wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));
485
486 // get watch entry for this event
487 wxFSWatchEntryDescriptors::iterator wit = m_watchMap.find(inevt.wd);
488 if (wit == m_watchMap.end())
489 {
490 wxLogTrace(wxTRACE_FSWATCHER,
491 "Watch descriptor not present in the watch map!");
492 }
493 else
494 {
495 // Tell the owner, in case it's interested
496 // If there's a filespec, assume he's not
497 wxFSWatchEntry& watch = *(wit->second);
498 if ( watch.GetFilespec().empty() )
499 {
500 int flags = Native2WatcherFlags(inevt.mask);
501 wxFileName path = GetEventPath(watch, inevt);
502 {
503 wxFileSystemWatcherEvent event(flags, path, path);
504 SendEvent(event);
505 }
506 }
507 }
508
509 m_cookies.erase(it);
510 delete &inevt;
511 it = m_cookies.begin();
512 }
513 }
514
515 void SendEvent(wxFileSystemWatcherEvent& evt)
516 {
517 wxLogTrace(wxTRACE_FSWATCHER, evt.ToString());
518 m_watcher->GetOwner()->ProcessEvent(evt);
519 }
520
521 int ReadEventsToBuf(char* buf, int size)
522 {
523 wxCHECK_MSG( IsOk(), false,
524 "Inotify not initialized or invalid inotify descriptor" );
525
526 memset(buf, 0, size);
527 ssize_t left = read(m_ifd, buf, size);
528 if (left == -1)
529 {
530 wxLogSysError(_("Unable to read from inotify descriptor"));
531 return -1;
532 }
533 else if (left == 0)
534 {
535 wxLogWarning(_("EOF while reading from inotify descriptor"));
536 return -1;
537 }
538
539 return left;
540 }
541
542 static wxString InotifyEventToString(const inotify_event& inevt)
543 {
544 wxString mask = (inevt.mask & IN_ISDIR) ?
545 wxString::Format("IS_DIR | %u", inevt.mask & ~IN_ISDIR) :
546 wxString::Format("%u", inevt.mask);
547 const char* name = "";
548 if (inevt.len)
549 name = inevt.name;
550 return wxString::Format("Event: wd=%d, mask=%s, cookie=%u, len=%u, "
551 "name=%s", inevt.wd, mask, inevt.cookie,
552 inevt.len, name);
553 }
554
555 static wxFileName GetEventPath(const wxFSWatchEntry& watch,
556 const inotify_event& inevt)
557 {
558 // only when dir is watched, we have non-empty e.name
559 wxFileName path = watch.GetPath();
560 if (path.IsDir() && inevt.len)
561 {
562 path = wxFileName(path.GetPath(), inevt.name);
563 }
564 return path;
565 }
566
567 static int Watcher2NativeFlags(int flags)
568 {
569 // Start with the standard case of wanting all events
570 if (flags == wxFSW_EVENT_ALL)
571 {
572 return IN_ALL_EVENTS;
573 }
574
575 static const int flag_mapping[][2] = {
576 { wxFSW_EVENT_ACCESS, IN_ACCESS },
577 { wxFSW_EVENT_MODIFY, IN_MODIFY },
578 { wxFSW_EVENT_ATTRIB, IN_ATTRIB },
579 { wxFSW_EVENT_RENAME, IN_MOVE },
580 { wxFSW_EVENT_CREATE, IN_CREATE },
581 { wxFSW_EVENT_DELETE, IN_DELETE|IN_DELETE_SELF|IN_MOVE_SELF },
582 { wxFSW_EVENT_UNMOUNT, IN_UNMOUNT }
583 // wxFSW_EVENT_ERROR/WARNING make no sense here
584 };
585
586 int native_flags = 0;
587 for ( unsigned int i=0; i < WXSIZEOF(flag_mapping); ++i)
588 {
589 if (flags & flag_mapping[i][0])
590 native_flags |= flag_mapping[i][1];
591 }
592
593 return native_flags;
594 }
595
596 static int Native2WatcherFlags(int flags)
597 {
598 static const int flag_mapping[][2] = {
599 { IN_ACCESS, wxFSW_EVENT_ACCESS }, // generated during read!
600 { IN_MODIFY, wxFSW_EVENT_MODIFY },
601 { IN_ATTRIB, wxFSW_EVENT_ATTRIB },
602 { IN_CLOSE_WRITE, 0 },
603 { IN_CLOSE_NOWRITE, 0 },
604 { IN_OPEN, 0 },
605 { IN_MOVED_FROM, wxFSW_EVENT_RENAME },
606 { IN_MOVED_TO, wxFSW_EVENT_RENAME },
607 { IN_CREATE, wxFSW_EVENT_CREATE },
608 { IN_DELETE, wxFSW_EVENT_DELETE },
609 { IN_DELETE_SELF, wxFSW_EVENT_DELETE },
610 { IN_MOVE_SELF, wxFSW_EVENT_DELETE },
611
612 { IN_UNMOUNT, wxFSW_EVENT_UNMOUNT},
613 { IN_Q_OVERFLOW, wxFSW_EVENT_WARNING},
614
615 // ignored, because this is generated mainly by watcher::Remove()
616 { IN_IGNORED, 0 }
617 };
618
619 unsigned int i=0;
620 for ( ; i < WXSIZEOF(flag_mapping); ++i) {
621 // in this mapping multiple flags at once don't happen
622 if (flags & flag_mapping[i][0])
623 return flag_mapping[i][1];
624 }
625
626 // never reached
627 wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flags));
628 return -1;
629 }
630
631 /**
632 * Returns error description for specified inotify mask
633 */
634 static const wxString GetErrorDescription(int flag)
635 {
636 switch ( flag )
637 {
638 case IN_Q_OVERFLOW:
639 return _("Event queue overflowed");
640 }
641
642 // never reached
643 wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flag));
644 return wxEmptyString;
645 }
646
647 wxFSWSourceHandler* m_handler; // handler for inotify event source
648 wxFSWatchEntryDescriptors m_watchMap; // inotify wd=>wxFSWatchEntry* map
649 wxArrayInt m_staleDescriptors; // stores recently-removed watches
650 wxInotifyCookies m_cookies; // map to track renames
651 wxEventLoopSource* m_source; // our event loop source
652
653 // file descriptor created by inotify_init()
654 int m_ifd;
655 };
656
657
658 // ============================================================================
659 // wxFSWSourceHandler implementation
660 // ============================================================================
661
662 // once we get signaled to read, actuall event reading occurs
663 void wxFSWSourceHandler::OnReadWaiting()
664 {
665 wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
666 m_service->ReadEvents();
667 }
668
669 void wxFSWSourceHandler::OnWriteWaiting()
670 {
671 wxFAIL_MSG("We never write to inotify descriptor.");
672 }
673
674 void wxFSWSourceHandler::OnExceptionWaiting()
675 {
676 wxFAIL_MSG("We never receive exceptions on inotify descriptor.");
677 }
678
679
680 // ============================================================================
681 // wxInotifyFileSystemWatcher implementation
682 // ============================================================================
683
684 wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher()
685 : wxFileSystemWatcherBase()
686 {
687 Init();
688 }
689
690 wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher(const wxFileName& path,
691 int events)
692 : wxFileSystemWatcherBase()
693 {
694 if (!Init())
695 {
696 if (m_service)
697 delete m_service;
698 return;
699 }
700
701 Add(path, events);
702 }
703
704 wxInotifyFileSystemWatcher::~wxInotifyFileSystemWatcher()
705 {
706 }
707
708 bool wxInotifyFileSystemWatcher::Init()
709 {
710 m_service = new wxFSWatcherImplUnix(this);
711 return m_service->Init();
712 }
713
714 void wxInotifyFileSystemWatcher::OnDirDeleted(const wxString& path)
715 {
716 if (!path.empty())
717 {
718 wxFSWatchInfoMap::iterator it = m_watches.find(path);
719 wxCHECK_RET(it != m_watches.end(),
720 wxString::Format("Path '%s' is not watched", path));
721
722 // path has been deleted, so we must forget it whatever its refcount
723 m_watches.erase(it);
724 }
725 }
726
727 #endif // wxHAS_INOTIFY
728
729 #endif // wxUSE_FSWATCHER