3.14

2 files changed, 1233 insertions, 1162 deletions

diff --git a/shared/inotify/inotify-cxx.cpp b/shared/inotify/inotify-cxx.cpp
index 689612ac..5a460ec7 100644
--- a/shared/inotify/inotify-cxx.cpp
+++ b/shared/inotify/inotify-cxx.cpp
@@ -2,11 +2,11 @@
 /// inotify C++ interface implementation
 /**
  * \file inotify-cxx.cpp
- * 
+ *
  * inotify C++ interface
- * 
+ *
  * Copyright (C) 2006, 2007, 2009 Lukas Jelinek <lukas@aiken.cz>
- * 
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of one of the following licenses:
  *
@@ -19,9 +19,9 @@
  *
  * Credits:
  *     Mike Frysinger (cleanup of includes)
- * 
+ *
  */
- 
+
 
 #include <errno.h>
 #include <unistd.h>
@@ -52,590 +52,658 @@
 
 int32_t InotifyEvent::GetDescriptor() const
 {
-  return  m_pWatch != NULL            // if watch exists
-      ?   m_pWatch->GetDescriptor()   // return its descriptor
-      :   -1;                         // else return -1
+    return  m_pWatch != NULL            // if watch exists
+            ?   m_pWatch->GetDescriptor()   // return its descriptor
+            :   -1;                         // else return -1
 }
 
 uint32_t InotifyEvent::GetMaskByName(const std::string& rName)
 {
-  if (rName == "IN_ACCESS")
-    return IN_ACCESS;
-  else if (rName == "IN_MODIFY")
-    return IN_MODIFY;
-  else if (rName == "IN_ATTRIB")
-    return IN_ATTRIB;
-  else if (rName == "IN_CLOSE_WRITE")
-    return IN_CLOSE_WRITE;
-  else if (rName == "IN_CLOSE_NOWRITE")
-    return IN_CLOSE_NOWRITE;
-  else if (rName == "IN_OPEN")
-    return IN_OPEN;
-  else if (rName == "IN_MOVED_FROM")
-    return IN_MOVED_FROM;
-  else if (rName == "IN_MOVED_TO")
-    return IN_MOVED_TO;
-  else if (rName == "IN_CREATE")
-    return IN_CREATE;
-  else if (rName == "IN_DELETE")
-    return IN_DELETE;
-  else if (rName == "IN_DELETE_SELF")
-    return IN_DELETE_SELF;
-  else if (rName == "IN_UNMOUNT")
-    return IN_UNMOUNT;
-  else if (rName == "IN_Q_OVERFLOW")
-    return IN_Q_OVERFLOW;
-  else if (rName == "IN_IGNORED")
-    return IN_IGNORED;
-  else if (rName == "IN_CLOSE")
-    return IN_CLOSE;
-  else if (rName == "IN_MOVE")
-    return IN_MOVE;
-  else if (rName == "IN_ISDIR")
-    return IN_ISDIR;
-  else if (rName == "IN_ONESHOT")
-    return IN_ONESHOT;
-  else if (rName == "IN_ALL_EVENTS")
-    return IN_ALL_EVENTS;
-    
+    if (rName == "IN_ACCESS")
+        return IN_ACCESS;
+    else if (rName == "IN_MODIFY")
+        return IN_MODIFY;
+    else if (rName == "IN_ATTRIB")
+        return IN_ATTRIB;
+    else if (rName == "IN_CLOSE_WRITE")
+        return IN_CLOSE_WRITE;
+    else if (rName == "IN_CLOSE_NOWRITE")
+        return IN_CLOSE_NOWRITE;
+    else if (rName == "IN_OPEN")
+        return IN_OPEN;
+    else if (rName == "IN_MOVED_FROM")
+        return IN_MOVED_FROM;
+    else if (rName == "IN_MOVED_TO")
+        return IN_MOVED_TO;
+    else if (rName == "IN_CREATE")
+        return IN_CREATE;
+    else if (rName == "IN_DELETE")
+        return IN_DELETE;
+    else if (rName == "IN_DELETE_SELF")
+        return IN_DELETE_SELF;
+    else if (rName == "IN_UNMOUNT")
+        return IN_UNMOUNT;
+    else if (rName == "IN_Q_OVERFLOW")
+        return IN_Q_OVERFLOW;
+    else if (rName == "IN_IGNORED")
+        return IN_IGNORED;
+    else if (rName == "IN_CLOSE")
+        return IN_CLOSE;
+    else if (rName == "IN_MOVE")
+        return IN_MOVE;
+    else if (rName == "IN_ISDIR")
+        return IN_ISDIR;
+    else if (rName == "IN_ONESHOT")
+        return IN_ONESHOT;
+    else if (rName == "IN_ALL_EVENTS")
+        return IN_ALL_EVENTS;
+
 #ifdef IN_DONT_FOLLOW
-  else if (rName == "IN_DONT_FOLLOW")
-    return IN_DONT_FOLLOW;
+    else if (rName == "IN_DONT_FOLLOW")
+        return IN_DONT_FOLLOW;
 #endif // IN_DONT_FOLLOW
 
 #ifdef IN_ONLYDIR
-  else if (rName == "IN_ONLYDIR")
-    return IN_ONLYDIR;
+    else if (rName == "IN_ONLYDIR")
+        return IN_ONLYDIR;
 #endif // IN_ONLYDIR
 
 #ifdef IN_MOVE_SELF
-  else if (rName == "IN_MOVE_SELF")
-    return IN_MOVE_SELF;
+    else if (rName == "IN_MOVE_SELF")
+        return IN_MOVE_SELF;
 #endif // IN_MOVE_SELF
-    
-  return (uint32_t) 0;
+
+    return (uint32_t) 0;
 }
 
 void InotifyEvent::DumpTypes(uint32_t uValue, std::string& rStr)
 {
-  rStr = "";
-  
-  if (IsType(uValue, IN_ALL_EVENTS)) {
-    rStr.append("IN_ALL_EVENTS");
-  }
-  else {
-    if (IsType(uValue, IN_ACCESS)) {
-      DUMP_SEP;
-      rStr.append("IN_ACCESS");    
-    }
-    if (IsType(uValue, IN_MODIFY)) {
-      DUMP_SEP;
-      rStr.append("IN_MODIFY");
-    }
-    if (IsType(uValue, IN_ATTRIB)) {
-      DUMP_SEP;
-      rStr.append("IN_ATTRIB");
-    }
-    if (IsType(uValue, IN_CREATE)) {
-      DUMP_SEP;
-      rStr.append("IN_CREATE");
-    }
-    if (IsType(uValue, IN_DELETE)) {
-      DUMP_SEP;
-      rStr.append("IN_DELETE");
-    }
-    if (IsType(uValue, IN_DELETE_SELF)) {
-      DUMP_SEP;
-      rStr.append("IN_DELETE_SELF");
-    }
-    if (IsType(uValue, IN_OPEN)) {
-      DUMP_SEP;
-      rStr.append("IN_OPEN");
-    }
-    if (IsType(uValue, IN_CLOSE)) {
-      DUMP_SEP;
-      rStr.append("IN_CLOSE");
+    rStr = "";
+
+    if (IsType(uValue, IN_ALL_EVENTS))
+    {
+        rStr.append("IN_ALL_EVENTS");
     }
+    else
+    {
+        if (IsType(uValue, IN_ACCESS))
+        {
+            DUMP_SEP;
+            rStr.append("IN_ACCESS");
+        }
+        if (IsType(uValue, IN_MODIFY))
+        {
+            DUMP_SEP;
+            rStr.append("IN_MODIFY");
+        }
+        if (IsType(uValue, IN_ATTRIB))
+        {
+            DUMP_SEP;
+            rStr.append("IN_ATTRIB");
+        }
+        if (IsType(uValue, IN_CREATE))
+        {
+            DUMP_SEP;
+            rStr.append("IN_CREATE");
+        }
+        if (IsType(uValue, IN_DELETE))
+        {
+            DUMP_SEP;
+            rStr.append("IN_DELETE");
+        }
+        if (IsType(uValue, IN_DELETE_SELF))
+        {
+            DUMP_SEP;
+            rStr.append("IN_DELETE_SELF");
+        }
+        if (IsType(uValue, IN_OPEN))
+        {
+            DUMP_SEP;
+            rStr.append("IN_OPEN");
+        }
+        if (IsType(uValue, IN_CLOSE))
+        {
+            DUMP_SEP;
+            rStr.append("IN_CLOSE");
+        }
 
 #ifdef IN_MOVE_SELF
-    if (IsType(uValue, IN_MOVE_SELF)) {
-      DUMP_SEP;
-      rStr.append("IN_MOVE_SELF");    
-    }
+        if (IsType(uValue, IN_MOVE_SELF))
+        {
+            DUMP_SEP;
+            rStr.append("IN_MOVE_SELF");
+        }
 #endif // IN_MOVE_SELF
-    
-    else {
-      if (IsType(uValue, IN_CLOSE_WRITE)) {
+
+        else
+        {
+            if (IsType(uValue, IN_CLOSE_WRITE))
+            {
+                DUMP_SEP;
+                rStr.append("IN_CLOSE_WRITE");
+            }
+            if (IsType(uValue, IN_CLOSE_NOWRITE))
+            {
+                DUMP_SEP;
+                rStr.append("IN_CLOSE_NOWRITE");
+            }
+        }
+        if (IsType(uValue, IN_MOVE))
+        {
+            DUMP_SEP;
+            rStr.append("IN_MOVE");
+        }
+        else
+        {
+            if (IsType(uValue, IN_MOVED_FROM))
+            {
+                DUMP_SEP;
+                rStr.append("IN_MOVED_FROM");
+            }
+            if (IsType(uValue, IN_MOVED_TO))
+            {
+                DUMP_SEP;
+                rStr.append("IN_MOVED_TO");
+            }
+        }
+    }
+    if (IsType(uValue, IN_UNMOUNT))
+    {
         DUMP_SEP;
-        rStr.append("IN_CLOSE_WRITE");
-      }
-      if (IsType(uValue, IN_CLOSE_NOWRITE)) {
+        rStr.append("IN_UNMOUNT");
+    }
+    if (IsType(uValue, IN_Q_OVERFLOW))
+    {
         DUMP_SEP;
-        rStr.append("IN_CLOSE_NOWRITE");
-      }
+        rStr.append("IN_Q_OVERFLOW");
     }
-    if (IsType(uValue, IN_MOVE)) {
-      DUMP_SEP;
-      rStr.append("IN_MOVE");
+    if (IsType(uValue, IN_IGNORED))
+    {
+        DUMP_SEP;
+        rStr.append("IN_IGNORED");
     }
-    else {
-      if (IsType(uValue, IN_MOVED_FROM)) {
+    if (IsType(uValue, IN_ISDIR))
+    {
         DUMP_SEP;
-        rStr.append("IN_MOVED_FROM");
-      }
-      if (IsType(uValue, IN_MOVED_TO)) {
+        rStr.append("IN_ISDIR");
+    }
+    if (IsType(uValue, IN_ONESHOT))
+    {
         DUMP_SEP;
-        rStr.append("IN_MOVED_TO");
-      }
-    }
-  }
-  if (IsType(uValue, IN_UNMOUNT)) {
-    DUMP_SEP;
-    rStr.append("IN_UNMOUNT");
-  }
-  if (IsType(uValue, IN_Q_OVERFLOW)) {
-    DUMP_SEP;
-    rStr.append("IN_Q_OVERFLOW");
-  }
-  if (IsType(uValue, IN_IGNORED)) {
-    DUMP_SEP;
-    rStr.append("IN_IGNORED");
-  }
-  if (IsType(uValue, IN_ISDIR)) {
-    DUMP_SEP;
-    rStr.append("IN_ISDIR");
-  }
-  if (IsType(uValue, IN_ONESHOT)) {
-    DUMP_SEP;
-    rStr.append("IN_ONESHOT");
-  }
-  
+        rStr.append("IN_ONESHOT");
+    }
+
 #ifdef IN_DONT_FOLLOW
-  if (IsType(uValue, IN_DONT_FOLLOW)) {
-    DUMP_SEP;
-    rStr.append("IN_DONT_FOLLOW");
-  }
+    if (IsType(uValue, IN_DONT_FOLLOW))
+    {
+        DUMP_SEP;
+        rStr.append("IN_DONT_FOLLOW");
+    }
 #endif // IN_DONT_FOLLOW
-  
+
 #ifdef IN_ONLYDIR
-  if (IsType(uValue, IN_ONLYDIR)) {
-    DUMP_SEP;
-    rStr.append("IN_ONLYDIR");
-  }
+    if (IsType(uValue, IN_ONLYDIR))
+    {
+        DUMP_SEP;
+        rStr.append("IN_ONLYDIR");
+    }
 #endif // IN_ONLYDIR
 }
 
 void InotifyEvent::DumpTypes(std::string& rStr) const
 {
-  DumpTypes(m_uMask, rStr);
+    DumpTypes(m_uMask, rStr);
 }
 
 
 void InotifyWatch::SetMask(uint32_t uMask) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  if (m_wd != -1) {
-    int wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), uMask);
-    if (wd != m_wd) {
-      IN_WRITE_END_NOTHROW
-      throw InotifyException(IN_EXC_MSG("changing mask failed"), wd == -1 ? errno : EINVAL, this); 
-    }
-  }
-  
-  m_uMask = uMask;
-  
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    if (m_wd != -1)
+    {
+        int wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), uMask);
+        if (wd != m_wd)
+        {
+            IN_WRITE_END_NOTHROW
+            throw InotifyException(IN_EXC_MSG("changing mask failed"), wd == -1 ? errno : EINVAL, this);
+        }
+    }
+
+    m_uMask = uMask;
+
+    IN_WRITE_END
 }
 
 void InotifyWatch::SetEnabled(bool fEnabled) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  if (fEnabled == m_fEnabled) {
-    IN_WRITE_END_NOTHROW
-    return;
-  }
-  
-  if (m_pInotify != NULL) {
-    if (fEnabled) {
-      m_wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), m_uMask);
-      if (m_wd == -1) {
+    IN_WRITE_BEGIN
+
+    if (fEnabled == m_fEnabled)
+    {
         IN_WRITE_END_NOTHROW
-        throw InotifyException(IN_EXC_MSG("enabling watch failed"), errno, this);
-      }
-      m_pInotify->m_watches.insert(IN_WATCH_MAP::value_type(m_wd, this));
+        return;
     }
-    else {
-      if (inotify_rm_watch(m_pInotify->GetDescriptor(), m_wd) != 0) {
-        IN_WRITE_END_NOTHROW
-        throw InotifyException(IN_EXC_MSG("disabling watch failed"), errno, this);
-      }
-      m_pInotify->m_watches.erase(m_wd);
-      m_wd = -1;
-    }
-  }
-  
-  m_fEnabled = fEnabled;
-  
-  IN_WRITE_END
+
+    if (m_pInotify != NULL)
+    {
+        if (fEnabled)
+        {
+            m_wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), m_uMask);
+            if (m_wd == -1)
+            {
+                IN_WRITE_END_NOTHROW
+                throw InotifyException(IN_EXC_MSG("enabling watch failed"), errno, this);
+            }
+            m_pInotify->m_watches.insert(IN_WATCH_MAP::value_type(m_wd, this));
+        }
+        else
+        {
+            if (inotify_rm_watch(m_pInotify->GetDescriptor(), m_wd) != 0)
+            {
+                IN_WRITE_END_NOTHROW
+                throw InotifyException(IN_EXC_MSG("disabling watch failed"), errno, this);
+            }
+            m_pInotify->m_watches.erase(m_wd);
+            m_wd = -1;
+        }
+    }
+
+    m_fEnabled = fEnabled;
+
+    IN_WRITE_END
 }
 
 void InotifyWatch::__Disable()
 {
-  IN_WRITE_BEGIN
-  
-  if (!m_fEnabled) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("event cannot occur on disabled watch"), EINVAL, this);
-  }
-  
-  if (m_pInotify != NULL) {
-    m_pInotify->m_watches.erase(m_wd);
-    m_wd = -1;
-  }
-  
-  m_fEnabled = false;
-  
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    if (!m_fEnabled)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("event cannot occur on disabled watch"), EINVAL, this);
+    }
+
+    if (m_pInotify != NULL)
+    {
+        m_pInotify->m_watches.erase(m_wd);
+        m_wd = -1;
+    }
+
+    m_fEnabled = false;
+
+    IN_WRITE_END
 }
 
 
 Inotify::Inotify() throw (InotifyException)
 {
-  IN_LOCK_INIT
-  
-  m_fd = inotify_init();
-  if (m_fd == -1) {
-    IN_LOCK_DONE
-    throw InotifyException(IN_EXC_MSG("inotify init failed"), errno, NULL);
-  }
+    IN_LOCK_INIT
+
+    m_fd = inotify_init();
+    if (m_fd == -1)
+    {
+        IN_LOCK_DONE
+        throw InotifyException(IN_EXC_MSG("inotify init failed"), errno, NULL);
+    }
 }
-  
+
 Inotify::~Inotify()
 {
-  Close();
-  
-  IN_LOCK_DONE
+    Close();
+
+    IN_LOCK_DONE
 }
 
 void Inotify::Close()
 {
-  IN_WRITE_BEGIN
-  
-  if (m_fd != -1) {
-    RemoveAll();
-    close(m_fd);
-    m_fd = -1;
-  }
-  
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    if (m_fd != -1)
+    {
+        RemoveAll();
+        close(m_fd);
+        m_fd = -1;
+    }
+
+    IN_WRITE_END
 }
 
 void Inotify::Add(InotifyWatch* pWatch) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  // invalid descriptor - this case shouldn't occur - go away
-  if (m_fd == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
-  }
-
-  // this path already watched - go away  
-  if (FindWatch(pWatch->GetPath()) != NULL) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("path already watched"), EBUSY, this);
-  }
-  
-  // for enabled watch
-  if (pWatch->IsEnabled()) {
-    
-    // try to add watch to kernel
-    int wd = inotify_add_watch(m_fd, pWatch->GetPath().c_str(), pWatch->GetMask());
-    
-    // adding failed - go away
-    if (wd == -1) {
-      IN_WRITE_END_NOTHROW
-      throw InotifyException(IN_EXC_MSG("adding watch failed"), errno, this);
-    }
-    
-    // this path already watched (but defined another way)
-    InotifyWatch* pW = FindWatch(wd);
-    if (pW != NULL) {
-      
-      // try to recover old watch because it may be modified - then go away
-      if (inotify_add_watch(m_fd, pW->GetPath().c_str(), pW->GetMask()) < 0) {
+    IN_WRITE_BEGIN
+
+    // invalid descriptor - this case shouldn't occur - go away
+    if (m_fd == -1)
+    {
         IN_WRITE_END_NOTHROW
-        throw InotifyException(IN_EXC_MSG("watch collision detected and recovery failed"), errno, this);
-      }
-      else {
-        // recovery failed - go away
+        throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
+    }
+
+    // this path already watched - go away
+    if (FindWatch(pWatch->GetPath()) != NULL)
+    {
         IN_WRITE_END_NOTHROW
-        throw InotifyException(IN_EXC_MSG("path already watched (but defined another way)"), EBUSY, this);
-      }
-    }
-    
-    pWatch->m_wd = wd;
-    m_watches.insert(IN_WATCH_MAP::value_type(pWatch->m_wd, pWatch));
-  }
-  
-  m_paths.insert(IN_WP_MAP::value_type(pWatch->m_path, pWatch));
-  pWatch->m_pInotify = this;
-  
-  IN_WRITE_END
+        throw InotifyException(IN_EXC_MSG("path already watched"), EBUSY, this);
+    }
+
+    // for enabled watch
+    if (pWatch->IsEnabled())
+    {
+
+        // try to add watch to kernel
+        int wd = inotify_add_watch(m_fd, pWatch->GetPath().c_str(), pWatch->GetMask());
+
+        // adding failed - go away
+        if (wd == -1)
+        {
+            IN_WRITE_END_NOTHROW
+            throw InotifyException(IN_EXC_MSG("adding watch failed"), errno, this);
+        }
+
+        // this path already watched (but defined another way)
+        InotifyWatch* pW = FindWatch(wd);
+        if (pW != NULL)
+        {
+
+            // try to recover old watch because it may be modified - then go away
+            if (inotify_add_watch(m_fd, pW->GetPath().c_str(), pW->GetMask()) < 0)
+            {
+                IN_WRITE_END_NOTHROW
+                throw InotifyException(IN_EXC_MSG("watch collision detected and recovery failed"), errno, this);
+            }
+            else
+            {
+                // recovery failed - go away
+                IN_WRITE_END_NOTHROW
+                throw InotifyException(IN_EXC_MSG("path already watched (but defined another way)"), EBUSY, this);
+            }
+        }
+
+        pWatch->m_wd = wd;
+        m_watches.insert(IN_WATCH_MAP::value_type(pWatch->m_wd, pWatch));
+    }
+
+    m_paths.insert(IN_WP_MAP::value_type(pWatch->m_path, pWatch));
+    pWatch->m_pInotify = this;
+
+    IN_WRITE_END
 }
 
 void Inotify::Remove(InotifyWatch* pWatch) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  // invalid descriptor - this case shouldn't occur - go away
-  if (m_fd == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
-  }
-  
-  // for enabled watch
-  if (pWatch->m_wd != -1) {  
-    
-    // removing watch failed - go away
-    if (inotify_rm_watch(m_fd, pWatch->m_wd) == -1) {
-      IN_WRITE_END_NOTHROW
-      throw InotifyException(IN_EXC_MSG("removing watch failed"), errno, this);
-    }
-    m_watches.erase(pWatch->m_wd);
-    pWatch->m_wd = -1;
-  }
-
-  m_paths.erase(pWatch->m_path);
-  pWatch->m_pInotify = NULL;
-  
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    // invalid descriptor - this case shouldn't occur - go away
+    if (m_fd == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
+    }
+
+    // for enabled watch
+    if (pWatch->m_wd != -1)
+    {
+
+        // removing watch failed - go away
+        if (inotify_rm_watch(m_fd, pWatch->m_wd) == -1)
+        {
+            IN_WRITE_END_NOTHROW
+            throw InotifyException(IN_EXC_MSG("removing watch failed"), errno, this);
+        }
+        m_watches.erase(pWatch->m_wd);
+        pWatch->m_wd = -1;
+    }
+
+    m_paths.erase(pWatch->m_path);
+    pWatch->m_pInotify = NULL;
+
+    IN_WRITE_END
 }
 
 void Inotify::RemoveAll()
 {
-  IN_WRITE_BEGIN
-  
-  IN_WP_MAP::iterator it = m_paths.begin();
-  while (it != m_paths.end()) {
-    InotifyWatch* pW = (*it).second;
-    if (pW->m_wd != -1) {
-      inotify_rm_watch(m_fd, pW->m_wd);
-      pW->m_wd = -1;
-    }
-    pW->m_pInotify = NULL;
-    it++;
-  }
-  
-  m_watches.clear();
-  m_paths.clear();
-  
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    IN_WP_MAP::iterator it = m_paths.begin();
+    while (it != m_paths.end())
+    {
+        InotifyWatch* pW = (*it).second;
+        if (pW->m_wd != -1)
+        {
+            inotify_rm_watch(m_fd, pW->m_wd);
+            pW->m_wd = -1;
+        }
+        pW->m_pInotify = NULL;
+        it++;
+    }
+
+    m_watches.clear();
+    m_paths.clear();
+
+    IN_WRITE_END
 }
 
 void Inotify::WaitForEvents(bool fNoIntr) throw (InotifyException)
 {
-  ssize_t len = 0;
-  
-  do {
-    len = read(m_fd, m_buf, INOTIFY_BUFLEN);
-  } while (fNoIntr && len == -1 && errno == EINTR);
-  
-  if (len == -1 && !(errno == EWOULDBLOCK || errno == EINTR))
-    throw InotifyException(IN_EXC_MSG("reading events failed"), errno, this);
-  
-  if (len == -1)
-    return;
-  
-  IN_WRITE_BEGIN
-  
-  ssize_t i = 0;
-  while (i < len) {
-    struct inotify_event* pEvt = (struct inotify_event*) &m_buf[i];
-    InotifyWatch* pW = FindWatch(pEvt->wd);
-    if (pW != NULL) {
-      InotifyEvent evt(pEvt, pW);
-      if (    InotifyEvent::IsType(pW->GetMask(), IN_ONESHOT)
-          ||  InotifyEvent::IsType(evt.GetMask(), IN_IGNORED))
-        pW->__Disable();
-      m_events.push_back(evt);
-    }
-    i += INOTIFY_EVENT_SIZE + (ssize_t) pEvt->len;
-  }
-  
-  IN_WRITE_END
+    ssize_t len = 0;
+
+    do
+    {
+        len = read(m_fd, m_buf, INOTIFY_BUFLEN);
+    }
+    while (fNoIntr && len == -1 && errno == EINTR);
+
+    if (len == -1 && !(errno == EWOULDBLOCK || errno == EINTR))
+        throw InotifyException(IN_EXC_MSG("reading events failed"), errno, this);
+
+    if (len == -1)
+        return;
+
+    IN_WRITE_BEGIN
+
+    ssize_t i = 0;
+    while (i < len)
+    {
+        struct inotify_event* pEvt = (struct inotify_event*) &m_buf[i];
+        InotifyWatch* pW = FindWatch(pEvt->wd);
+        if (pW != NULL)
+        {
+            InotifyEvent evt(pEvt, pW);
+            if (    InotifyEvent::IsType(pW->GetMask(), IN_ONESHOT)
+                    ||  InotifyEvent::IsType(evt.GetMask(), IN_IGNORED))
+                pW->__Disable();
+            m_events.push_back(evt);
+        }
+        i += INOTIFY_EVENT_SIZE + (ssize_t) pEvt->len;
+    }
+
+    IN_WRITE_END
 }
-  
+
 bool Inotify::GetEvent(InotifyEvent* pEvt) throw (InotifyException)
 {
-  if (pEvt == NULL)
-    throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);
-  
-  IN_WRITE_BEGIN
-  
-  bool b = !m_events.empty();
-  if (b) {
-    *pEvt = m_events.front();
-    m_events.pop_front();
-  }
-  
-  IN_WRITE_END
-    
-  return b;
+    if (pEvt == NULL)
+        throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);
+
+    IN_WRITE_BEGIN
+
+    bool b = !m_events.empty();
+    if (b)
+    {
+        *pEvt = m_events.front();
+        m_events.pop_front();
+    }
+
+    IN_WRITE_END
+
+    return b;
 }
-  
+
 bool Inotify::PeekEvent(InotifyEvent* pEvt) throw (InotifyException)
 {
-  if (pEvt == NULL)
-    throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);
-  
-  IN_READ_BEGIN
-  
-  bool b = !m_events.empty();
-  if (b) {
-    *pEvt = m_events.front();
-  }
-  
-  IN_READ_END
-  
-  return b;
+    if (pEvt == NULL)
+        throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);
+
+    IN_READ_BEGIN
+
+    bool b = !m_events.empty();
+    if (b)
+    {
+        *pEvt = m_events.front();
+    }
+
+    IN_READ_END
+
+    return b;
 }
 
 InotifyWatch* Inotify::FindWatch(int iDescriptor)
 {
-  IN_READ_BEGIN
-  
-  IN_WATCH_MAP::iterator it = m_watches.find(iDescriptor);
-  InotifyWatch* pW = it == m_watches.end() ? NULL : (*it).second;
-  
-  IN_READ_END
-  
-  return pW;
+    IN_READ_BEGIN
+
+    IN_WATCH_MAP::iterator it = m_watches.find(iDescriptor);
+    InotifyWatch* pW = it == m_watches.end() ? NULL : (*it).second;
+
+    IN_READ_END
+
+    return pW;
 }
 
 InotifyWatch* Inotify::FindWatch(const std::string& rPath)
 {
-  IN_READ_BEGIN
-  
-  IN_WP_MAP::iterator it = m_paths.find(rPath);
-  InotifyWatch* pW = it == m_paths.end() ? NULL : (*it).second;
-  
-  IN_READ_END
-    
-  return pW;
+    IN_READ_BEGIN
+
+    IN_WP_MAP::iterator it = m_paths.find(rPath);
+    InotifyWatch* pW = it == m_paths.end() ? NULL : (*it).second;
+
+    IN_READ_END
+
+    return pW;
 }
-  
+
 void Inotify::SetNonBlock(bool fNonBlock) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  if (m_fd == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
-  }
-    
-  int res = fcntl(m_fd, F_GETFL);
-  if (res == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);
-  }
-  
-  if (fNonBlock) {
-    res |= O_NONBLOCK;
-  }
-  else {
-    res &= ~O_NONBLOCK;
-  }
-      
-  if (fcntl(m_fd, F_SETFL, res) == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);
-  }
-    
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    if (m_fd == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
+    }
+
+    int res = fcntl(m_fd, F_GETFL);
+    if (res == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);
+    }
+
+    if (fNonBlock)
+    {
+        res |= O_NONBLOCK;
+    }
+    else
+    {
+        res &= ~O_NONBLOCK;
+    }
+
+    if (fcntl(m_fd, F_SETFL, res) == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);
+    }
+
+    IN_WRITE_END
 }
 
 void Inotify::SetCloseOnExec(bool fClOnEx) throw (InotifyException)
 {
-  IN_WRITE_BEGIN
-  
-  if (m_fd == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
-  }
-    
-  int res = fcntl(m_fd, F_GETFD);
-  if (res == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);
-  }
-  
-  if (fClOnEx) {
-    res |= FD_CLOEXEC;
-  }
-  else {
-    res &= ~FD_CLOEXEC;
-  }
-      
-  if (fcntl(m_fd, F_SETFD, res) == -1) {
-    IN_WRITE_END_NOTHROW
-    throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);
-  }
-    
-  IN_WRITE_END
+    IN_WRITE_BEGIN
+
+    if (m_fd == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);
+    }
+
+    int res = fcntl(m_fd, F_GETFD);
+    if (res == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);
+    }
+
+    if (fClOnEx)
+    {
+        res |= FD_CLOEXEC;
+    }
+    else
+    {
+        res &= ~FD_CLOEXEC;
+    }
+
+    if (fcntl(m_fd, F_SETFD, res) == -1)
+    {
+        IN_WRITE_END_NOTHROW
+        throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);
+    }
+
+    IN_WRITE_END
 }
 
 uint32_t Inotify::GetCapability(InotifyCapability_t cap) throw (InotifyException)
 {
-  FILE* f = fopen(GetCapabilityPath(cap).c_str(), "r");
-  if (f == NULL)
-    throw InotifyException(IN_EXC_MSG("cannot get capability"), errno, NULL);
-    
-  unsigned int val = 0;
-  if (fscanf(f, "%u", &val) != 1) {
+    FILE* f = fopen(GetCapabilityPath(cap).c_str(), "r");
+    if (f == NULL)
+        throw InotifyException(IN_EXC_MSG("cannot get capability"), errno, NULL);
+
+    unsigned int val = 0;
+    if (fscanf(f, "%u", &val) != 1)
+    {
+        fclose(f);
+        throw InotifyException(IN_EXC_MSG("cannot get capability"), EIO, NULL);
+    }
+
     fclose(f);
-    throw InotifyException(IN_EXC_MSG("cannot get capability"), EIO, NULL);
-  }
-  
-  fclose(f);
-  
-  return (uint32_t) val;
+
+    return (uint32_t) val;
 }
 
 void Inotify::SetCapability(InotifyCapability_t cap, uint32_t val) throw (InotifyException)
 {
-  FILE* f = fopen(GetCapabilityPath(cap).c_str(), "w");
-  if (f == NULL)
-    throw InotifyException(IN_EXC_MSG("cannot set capability"), errno, NULL);
-    
-  if (fprintf(f, "%u", (unsigned int) val) <= 0) {
+    FILE* f = fopen(GetCapabilityPath(cap).c_str(), "w");
+    if (f == NULL)
+        throw InotifyException(IN_EXC_MSG("cannot set capability"), errno, NULL);
+
+    if (fprintf(f, "%u", (unsigned int) val) <= 0)
+    {
+        fclose(f);
+        throw InotifyException(IN_EXC_MSG("cannot set capability"), EIO, NULL);
+    }
+
     fclose(f);
-    throw InotifyException(IN_EXC_MSG("cannot set capability"), EIO, NULL);
-  }
-  
-  fclose(f);
 }
 
 std::string Inotify::GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException)
 {
-  std::string path(PROCFS_INOTIFY_BASE);
-  
-  switch (cap) {
-    case IN_MAX_EVENTS:
-      path.append("max_queued_events");
-      break;
-    case IN_MAX_INSTANCES:
-      path.append("max_user_instances");
-      break;
-    case IN_MAX_WATCHES:
-      path.append("max_user_watches");
-      break;
-    default:
-      throw InotifyException(IN_EXC_MSG("unknown capability type"), EINVAL, NULL);
-  }
-  
-  return path;
+    std::string path(PROCFS_INOTIFY_BASE);
+
+    switch (cap)
+    {
+        case IN_MAX_EVENTS:
+            path.append("max_queued_events");
+            break;
+        case IN_MAX_INSTANCES:
+            path.append("max_user_instances");
+            break;
+        case IN_MAX_WATCHES:
+            path.append("max_user_watches");
+            break;
+        default:
+            throw InotifyException(IN_EXC_MSG("unknown capability type"), EINVAL, NULL);
+    }
+
+    return path;
 }
 
diff --git a/shared/inotify/inotify-cxx.h b/shared/inotify/inotify-cxx.h
index 34ae2212..2fb00fc8 100644
--- a/shared/inotify/inotify-cxx.h
+++ b/shared/inotify/inotify-cxx.h
@@ -2,11 +2,11 @@
 /// inotify C++ interface header
 /**
  * \file inotify-cxx.h
- * 
+ *
  * inotify C++ interface
- * 
+ *
  * Copyright (C) 2006, 2007, 2009 Lukas Jelinek, <lukas@aiken.cz>
- * 
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of one of the following licenses:
  *
@@ -50,12 +50,12 @@
  */
 #define IN_EXC_MSG(msg) (std::string(__PRETTY_FUNCTION__) + ": " + msg)
 
-/// inotify capability/limit identifiers 
+/// inotify capability/limit identifiers
 typedef enum
 {
-  IN_MAX_EVENTS     = 0,  ///< max. events in the kernel queue
-  IN_MAX_INSTANCES  = 1,  ///< max. inotify file descriptors per process
-  IN_MAX_WATCHES    = 2   ///< max. watches per file descriptor
+    IN_MAX_EVENTS     = 0,  ///< max. events in the kernel queue
+    IN_MAX_INSTANCES  = 1,  ///< max. inotify file descriptors per process
+    IN_MAX_WATCHES    = 2   ///< max. watches per file descriptor
 } InotifyCapability_t;
 
 /// inotify-cxx thread safety
@@ -63,16 +63,16 @@ typedef enum
  * If this symbol is defined you can use this interface safely
  * threaded applications. Remember that it slightly degrades
  * performance.
- * 
+ *
  * Even if INOTIFY_THREAD_SAFE is defined some classes stay
  * unsafe. If you must use them (must you?) in more than one
  * thread concurrently you need to implement explicite locking.
- * 
+ *
  * You need not to define INOTIFY_THREAD_SAFE in that cases
  * where the application is multithreaded but all the inotify
  * infrastructure will be managed only in one thread. This is
  * the recommended way.
- * 
+ *
  * Locking may fail (it is very rare but not impossible). In this
  * case an exception is thrown. But if unlocking fails in case
  * of an error it does nothing (this failure is ignored).
@@ -95,7 +95,7 @@ typedef enum
       throw InotifyException(IN_EXC_MSG("cannot initialize lock"), res, this); \
     pthread_rwlockattr_destroy(&attr); \
   }
- 
+
 #define IN_LOCK_DONE pthread_rwlock_destroy(&__m_lock);
 
 #define IN_READ_BEGIN \
@@ -104,23 +104,23 @@ typedef enum
     if (res != 0) \
       throw InotifyException(IN_EXC_MSG("locking for reading failed"), res, (void*) this); \
   }
-  
+
 #define IN_READ_END \
   { \
     int res = pthread_rwlock_unlock(&__m_lock); \
     if (res != 0) \
       throw InotifyException(IN_EXC_MSG("unlocking failed"), res, (void*) this); \
   }
-  
+
 #define IN_READ_END_NOTHROW pthread_rwlock_unlock(&__m_lock);
-  
+
 #define IN_WRITE_BEGIN \
   { \
     int res = pthread_rwlock_wrlock(&__m_lock); \
     if (res != 0) \
       throw InotifyException(IN_EXC_MSG("locking for writing failed"), res, (void*) this); \
   }
-  
+
 #define IN_WRITE_END IN_READ_END
 #define IN_WRITE_END_NOTHROW IN_READ_END_NOTHROW
 
@@ -151,59 +151,59 @@ class Inotify;
  * This class allows to acquire information about exceptional
  * events. It makes easier to log or display error messages
  * and to identify problematic code locations.
- * 
+ *
  * Although this class is basically thread-safe it is not intended
  * to be shared between threads.
  */
 class InotifyException
 {
 public:
-  /// Constructor
-  /**
-   * \param[in] rMsg message
-   * \param[in] iErr error number (see errno.h)
-   * \param[in] pSrc source
-   */
-  InotifyException(const std::string& rMsg = "", int iErr = 0, void* pSrc = NULL)
-  : m_msg(rMsg),
-    m_err(iErr)
-  {
-    m_pSrc = pSrc;
-  }
-  
-  /// Returns the exception message.
-  /**
-   * \return message
-   */
-  inline const std::string& GetMessage() const
-  {
-    return m_msg;
-  }
-  
-  /// Returns the exception error number.
-  /**
-   * If not applicable this value is 0 (zero).
-   * 
-   * \return error number (standardized; see errno.h)
-   */
-  inline int GetErrorNumber() const
-  {
-    return m_err;
-  } 
-  
-  /// Returns the exception source.
-  /**
-   * \return source
-   */
-  inline void* GetSource() const
-  {
-    return m_pSrc;
-  }
+    /// Constructor
+    /**
+     * \param[in] rMsg message
+     * \param[in] iErr error number (see errno.h)
+     * \param[in] pSrc source
+     */
+    InotifyException(const std::string& rMsg = "", int iErr = 0, void* pSrc = NULL)
+        : m_msg(rMsg),
+          m_err(iErr)
+    {
+        m_pSrc = pSrc;
+    }
+
+    /// Returns the exception message.
+    /**
+     * \return message
+     */
+    inline const std::string& GetMessage() const
+    {
+        return m_msg;
+    }
+
+    /// Returns the exception error number.
+    /**
+     * If not applicable this value is 0 (zero).
+     *
+     * \return error number (standardized; see errno.h)
+     */
+    inline int GetErrorNumber() const
+    {
+        return m_err;
+    }
+
+    /// Returns the exception source.
+    /**
+     * \return source
+     */
+    inline void* GetSource() const
+    {
+        return m_pSrc;
+    }
 
 protected:
-  std::string m_msg;      ///< message
-  int m_err;              ///< error number
-  mutable void* m_pSrc;   ///< source
+    std::string m_msg;      ///< message
+    int m_err;              ///< error number
+    mutable void* m_pSrc;   ///< source
 };
 
 
@@ -211,7 +211,7 @@ protected:
 /**
  * It holds all information about inotify event and provides
  * access to its particular values.
- * 
+ *
  * This class is not (and is not intended to be) thread-safe
  * and therefore it must not be used concurrently in multiple
  * threads.
@@ -219,157 +219,160 @@ protected:
 class InotifyEvent
 {
 public:
-  /// Constructor.
-  /**
-   * Creates a plain event.
-   */
-  InotifyEvent()
-  : m_uMask(0),
-    m_uCookie(0)
-  {
-    m_pWatch = NULL;
-  }
-  
-  /// Constructor.
-  /**
-   * Creates an event based on inotify event data.
-   * For NULL pointers it works the same way as InotifyEvent().
-   * 
-   * \param[in] pEvt event data
-   * \param[in] pWatch inotify watch
-   */
-  InotifyEvent(const struct inotify_event* pEvt, InotifyWatch* pWatch)
-  : m_uMask(0),
-    m_uCookie(0)
-  {
-    if (pEvt != NULL) {
-      m_uMask = (uint32_t) pEvt->mask;
-      m_uCookie = (uint32_t) pEvt->cookie;
-      if (pEvt->name != NULL) {
-        m_name = pEvt->len > 0
-            ? pEvt->name
-            : "";
-      }
-      m_pWatch = pWatch;
-    }
-    else {
-      m_pWatch = NULL;
+    /// Constructor.
+    /**
+     * Creates a plain event.
+     */
+    InotifyEvent()
+        : m_uMask(0),
+          m_uCookie(0)
+    {
+        m_pWatch = NULL;
     }
-  }
-  
-  /// Destructor.
-  ~InotifyEvent() {}
-  
-  /// Returns the event watch descriptor.
-  /**
-   * \return watch descriptor
-   * 
-   * \sa InotifyWatch::GetDescriptor()
-   */
-  int32_t GetDescriptor() const;
-  
-  /// Returns the event mask.
-  /**
-   * \return event mask
-   * 
-   * \sa InotifyWatch::GetMask()
-   */
-  inline uint32_t GetMask() const
-  {
-    return m_uMask;
-  }
-  
-  /// Checks a value for the event type.
-  /**
-   * \param[in] uValue checked value
-   * \param[in] uType type which is checked for
-   * \return true = the value contains the given type, false = otherwise
-   */
-  inline static bool IsType(uint32_t uValue, uint32_t uType)
-  {
-    return ((uValue & uType) != 0) && ((~uValue & uType) == 0);
-  }
-  
-  /// Checks for the event type.
-  /**
-   * \param[in] uType type which is checked for
-   * \return true = event mask contains the given type, false = otherwise
-   */
-  inline bool IsType(uint32_t uType) const
-  {
-    return IsType(m_uMask, uType);
-  }
-  
-  /// Returns the event cookie.
-  /**
-   * \return event cookie
-   */
-  inline uint32_t GetCookie() const
-  {
-    return m_uCookie;
-  }
-  
-  /// Returns the event name length.
-  /**
-   * \return event name length
-   */
-  inline uint32_t GetLength() const
-  {
-    return (uint32_t) m_name.length();
-  }
-  
-  /// Returns the event name.
-  /**
-   * \return event name
-   */
-  inline const std::string& GetName() const
-  {
-    return m_name;
-  }
-  
-  /// Extracts the event name.
-  /**
-   * \param[out] rName event name
-   */
-  inline void GetName(std::string& rName) const
-  {
-    rName = GetName();
-  }
-  
-  /// Returns the source watch.
-  /**
-   * \return source watch
-   */
-  inline InotifyWatch* GetWatch()
-  {
-    return m_pWatch;
-  }
-  
-  /// Finds the appropriate mask for a name.
-  /**
-   * \param[in] rName mask name
-   * \return mask for name; 0 on failure
-   */
-  static uint32_t GetMaskByName(const std::string& rName);
-  
-  /// Fills the string with all types contained in an event mask value.
-  /**
-   * \param[in] uValue event mask value
-   * \param[out] rStr dumped event types
-   */
-  static void DumpTypes(uint32_t uValue, std::string& rStr);
-  
-  /// Fills the string with all types contained in the event mask.
-  /**
-   * \param[out] rStr dumped event types
-   */
-  void DumpTypes(std::string& rStr) const;
-  
+
+    /// Constructor.
+    /**
+     * Creates an event based on inotify event data.
+     * For NULL pointers it works the same way as InotifyEvent().
+     *
+     * \param[in] pEvt event data
+     * \param[in] pWatch inotify watch
+     */
+    InotifyEvent(const struct inotify_event* pEvt, InotifyWatch* pWatch)
+        : m_uMask(0),
+          m_uCookie(0)
+    {
+        if (pEvt != NULL)
+        {
+            m_uMask = (uint32_t) pEvt->mask;
+            m_uCookie = (uint32_t) pEvt->cookie;
+            if (pEvt->name != NULL)
+            {
+                m_name = pEvt->len > 0
+                         ? pEvt->name
+                         : "";
+            }
+            m_pWatch = pWatch;
+        }
+        else
+        {
+            m_pWatch = NULL;
+        }
+    }
+
+    /// Destructor.
+    ~InotifyEvent() {}
+
+    /// Returns the event watch descriptor.
+    /**
+     * \return watch descriptor
+     *
+     * \sa InotifyWatch::GetDescriptor()
+     */
+    int32_t GetDescriptor() const;
+
+    /// Returns the event mask.
+    /**
+     * \return event mask
+     *
+     * \sa InotifyWatch::GetMask()
+     */
+    inline uint32_t GetMask() const
+    {
+        return m_uMask;
+    }
+
+    /// Checks a value for the event type.
+    /**
+     * \param[in] uValue checked value
+     * \param[in] uType type which is checked for
+     * \return true = the value contains the given type, false = otherwise
+     */
+    inline static bool IsType(uint32_t uValue, uint32_t uType)
+    {
+        return ((uValue & uType) != 0) && ((~uValue & uType) == 0);
+    }
+
+    /// Checks for the event type.
+    /**
+     * \param[in] uType type which is checked for
+     * \return true = event mask contains the given type, false = otherwise
+     */
+    inline bool IsType(uint32_t uType) const
+    {
+        return IsType(m_uMask, uType);
+    }
+
+    /// Returns the event cookie.
+    /**
+     * \return event cookie
+     */
+    inline uint32_t GetCookie() const
+    {
+        return m_uCookie;
+    }
+
+    /// Returns the event name length.
+    /**
+     * \return event name length
+     */
+    inline uint32_t GetLength() const
+    {
+        return (uint32_t) m_name.length();
+    }
+
+    /// Returns the event name.
+    /**
+     * \return event name
+     */
+    inline const std::string& GetName() const
+    {
+        return m_name;
+    }
+
+    /// Extracts the event name.
+    /**
+     * \param[out] rName event name
+     */
+    inline void GetName(std::string& rName) const
+    {
+        rName = GetName();
+    }
+
+    /// Returns the source watch.
+    /**
+     * \return source watch
+     */
+    inline InotifyWatch* GetWatch()
+    {
+        return m_pWatch;
+    }
+
+    /// Finds the appropriate mask for a name.
+    /**
+     * \param[in] rName mask name
+     * \return mask for name; 0 on failure
+     */
+    static uint32_t GetMaskByName(const std::string& rName);
+
+    /// Fills the string with all types contained in an event mask value.
+    /**
+     * \param[in] uValue event mask value
+     * \param[out] rStr dumped event types
+     */
+    static void DumpTypes(uint32_t uValue, std::string& rStr);
+
+    /// Fills the string with all types contained in the event mask.
+    /**
+     * \param[out] rStr dumped event types
+     */
+    void DumpTypes(std::string& rStr) const;
+
 private:
-  uint32_t m_uMask;           ///< mask
-  uint32_t m_uCookie;         ///< cookie
-  std::string m_name;         ///< name
-  InotifyWatch* m_pWatch;     ///< source watch
+    uint32_t m_uMask;           ///< mask
+    uint32_t m_uCookie;         ///< cookie
+    std::string m_name;         ///< name
+    InotifyWatch* m_pWatch;     ///< source watch
 };
 
 
@@ -378,140 +381,140 @@ private:
 /**
  * It holds information about the inotify watch on a particular
  * inode.
- * 
+ *
  * If the INOTIFY_THREAD_SAFE is defined this class is thread-safe.
  */
 class InotifyWatch
 {
 public:
-  /// Constructor.
-  /**
-   * Creates an inotify watch. Because this watch is
-   * inactive it has an invalid descriptor (-1).
-   * 
-   * \param[in] rPath watched file path
-   * \param[in] uMask mask for events
-   * \param[in] fEnabled events enabled yes/no
-   */
-  InotifyWatch(const std::string& rPath, int32_t uMask, bool fEnabled = true)
-  : m_path(rPath),
-    m_uMask(uMask),
-    m_wd((int32_t) -1),
-    m_fEnabled(fEnabled)
-  {
-    IN_LOCK_INIT
-  }
-  
-  /// Destructor.
-  ~InotifyWatch()
-  {
-    IN_LOCK_DONE
-  }
-  
-  /// Returns the watch descriptor.
-  /**
-   * \return watch descriptor; -1 for inactive watch
-   */
-  inline int32_t GetDescriptor() const
-  {
-    return m_wd;
-  }
-  
-  /// Returns the watched file path.
-  /**
-   * \return file path
-   */
-  inline const std::string& GetPath() const
-  {
-    return m_path;
-  }
-  
-  /// Returns the watch event mask.
-  /**
-   * \return event mask
-   */
-  inline uint32_t GetMask() const
-  {
-    return (uint32_t) m_uMask;
-  }
-  
-  /// Sets the watch event mask.
-  /**
-   * If the watch is active (added to an instance of Inotify)
-   * this method may fail due to unsuccessful re-setting
-   * the watch in the kernel.
-   * 
-   * \param[in] uMask event mask
-   * 
-   * \throw InotifyException thrown if changing fails
-   */
-  void SetMask(uint32_t uMask) throw (InotifyException);   
-  
-  /// Returns the appropriate inotify class instance.
-  /**
-   * \return inotify instance
-   */
-  inline Inotify* GetInotify()
-  {
-    return m_pInotify;
-  }
-  
-  /// Enables/disables the watch.
-  /**
-   * If the watch is active (added to an instance of Inotify)
-   * this method may fail due to unsuccessful re-setting
-   * the watch in the kernel.
-   * 
-   * Re-setting the current state has no effect.
-   * 
-   * \param[in] fEnabled set enabled yes/no
-   * 
-   * \throw InotifyException thrown if enabling/disabling fails
-   */
-  void SetEnabled(bool fEnabled) throw (InotifyException);
-  
-  /// Checks whether the watch is enabled.
-  /**
-   * \return true = enables, false = disabled
-   */
-  inline bool IsEnabled() const
-  {
-    return m_fEnabled;
-  }
-  
-  /// Checks whether the watch is recursive.
-  /**
-   * A recursive watch monitors a directory itself and all
-   * its subdirectories. This watch is a logical object
-   * which may have many underlying kernel watches.
-   * 
-   * \return currently always false (recursive watches not yet supported)
-   * \attention Recursive watches are currently NOT supported.
-   *            They are planned for future versions.
-   */
-  inline bool IsRecursive() const
-  {
-    return false;    
-  }
-  
+    /// Constructor.
+    /**
+     * Creates an inotify watch. Because this watch is
+     * inactive it has an invalid descriptor (-1).
+     *
+     * \param[in] rPath watched file path
+     * \param[in] uMask mask for events
+     * \param[in] fEnabled events enabled yes/no
+     */
+    InotifyWatch(const std::string& rPath, int32_t uMask, bool fEnabled = true)
+        : m_path(rPath),
+          m_uMask(uMask),
+          m_wd((int32_t) -1),
+          m_fEnabled(fEnabled)
+    {
+        IN_LOCK_INIT
+    }
+
+    /// Destructor.
+    ~InotifyWatch()
+    {
+        IN_LOCK_DONE
+    }
+
+    /// Returns the watch descriptor.
+    /**
+     * \return watch descriptor; -1 for inactive watch
+     */
+    inline int32_t GetDescriptor() const
+    {
+        return m_wd;
+    }
+
+    /// Returns the watched file path.
+    /**
+     * \return file path
+     */
+    inline const std::string& GetPath() const
+    {
+        return m_path;
+    }
+
+    /// Returns the watch event mask.
+    /**
+     * \return event mask
+     */
+    inline uint32_t GetMask() const
+    {
+        return (uint32_t) m_uMask;
+    }
+
+    /// Sets the watch event mask.
+    /**
+     * If the watch is active (added to an instance of Inotify)
+     * this method may fail due to unsuccessful re-setting
+     * the watch in the kernel.
+     *
+     * \param[in] uMask event mask
+     *
+     * \throw InotifyException thrown if changing fails
+     */
+    void SetMask(uint32_t uMask) throw (InotifyException);
+
+    /// Returns the appropriate inotify class instance.
+    /**
+     * \return inotify instance
+     */
+    inline Inotify* GetInotify()
+    {
+        return m_pInotify;
+    }
+
+    /// Enables/disables the watch.
+    /**
+     * If the watch is active (added to an instance of Inotify)
+     * this method may fail due to unsuccessful re-setting
+     * the watch in the kernel.
+     *
+     * Re-setting the current state has no effect.
+     *
+     * \param[in] fEnabled set enabled yes/no
+     *
+     * \throw InotifyException thrown if enabling/disabling fails
+     */
+    void SetEnabled(bool fEnabled) throw (InotifyException);
+
+    /// Checks whether the watch is enabled.
+    /**
+     * \return true = enables, false = disabled
+     */
+    inline bool IsEnabled() const
+    {
+        return m_fEnabled;
+    }
+
+    /// Checks whether the watch is recursive.
+    /**
+     * A recursive watch monitors a directory itself and all
+     * its subdirectories. This watch is a logical object
+     * which may have many underlying kernel watches.
+     *
+     * \return currently always false (recursive watches not yet supported)
+     * \attention Recursive watches are currently NOT supported.
+     *            They are planned for future versions.
+     */
+    inline bool IsRecursive() const
+    {
+        return false;
+    }
+
 private:
-  friend class Inotify;
-
-  std::string m_path;   ///< watched file path
-  uint32_t m_uMask;     ///< event mask
-  int32_t m_wd;         ///< watch descriptor
-  Inotify* m_pInotify;  ///< inotify object
-  bool m_fEnabled;      ///< events enabled yes/no
-  
-  IN_LOCK_DECL
-  
-  /// Disables the watch (due to removing by the kernel).
-  /**
-   * This method must be called after receiving an event.
-   * It ensures the watch object is consistent with the kernel
-   * data. 
-   */
-  void __Disable();
+    friend class Inotify;
+
+    std::string m_path;   ///< watched file path
+    uint32_t m_uMask;     ///< event mask
+    int32_t m_wd;         ///< watch descriptor
+    Inotify* m_pInotify;  ///< inotify object
+    bool m_fEnabled;      ///< events enabled yes/no
+
+    IN_LOCK_DECL
+
+    /// Disables the watch (due to removing by the kernel).
+    /**
+     * This method must be called after receiving an event.
+     * It ensures the watch object is consistent with the kernel
+     * data.
+     */
+    void __Disable();
 };
 
 
@@ -526,360 +529,360 @@ typedef std::map<std::string, InotifyWatch*> IN_WP_MAP;
 /**
  * It holds information about the inotify device descriptor
  * and manages the event queue.
- * 
+ *
  * If the INOTIFY_THREAD_SAFE is defined this class is thread-safe.
  */
 class Inotify
 {
 public:
-  /// Constructor.
-  /**
-   * Creates and initializes an instance of inotify communication
-   * object (opens the inotify device).
-   * 
-   * \throw InotifyException thrown if inotify isn't available
-   */
-  Inotify() throw (InotifyException);
-  
-  /// Destructor.
-  /**
-   * Calls Close() due to clean-up.
-   */
-  ~Inotify();
-  
-  /// Removes all watches and closes the inotify device.
-  void Close();
-    
-  /// Adds a new watch.
-  /**
-   * \param[in] pWatch inotify watch
-   * 
-   * \throw InotifyException thrown if adding failed
-   */
-  void Add(InotifyWatch* pWatch) throw (InotifyException);
-  
-  /// Adds a new watch.
-  /**
-   * \param[in] rWatch inotify watch
-   * 
-   * \throw InotifyException thrown if adding failed
-   */
-  inline void Add(InotifyWatch& rWatch) throw (InotifyException)
-  {
-    Add(&rWatch);
-  }
-  
-  /// Removes a watch.
-  /**
-   * If the given watch is not present it does nothing.
-   * 
-   * \param[in] pWatch inotify watch
-   * 
-   * \throw InotifyException thrown if removing failed
-   */
-  void Remove(InotifyWatch* pWatch) throw (InotifyException);
-  
-  /// Removes a watch.
-  /**
-   * If the given watch is not present it does nothing.
-   * 
-   * \param[in] rWatch inotify watch
-   * 
-   * \throw InotifyException thrown if removing failed
-   */
-  inline void Remove(InotifyWatch& rWatch) throw (InotifyException)
-  {
-    Remove(&rWatch);
-  }
-  
-  /// Removes all watches.
-  void RemoveAll();
-  
-  /// Returns the count of watches.
-  /**
-   * This is the total count of all watches (regardless whether
-   * enabled or not).
-   * 
-   * \return count of watches
-   * 
-   * \sa GetEnabledCount()
-   */
-  inline size_t GetWatchCount() const
-  {
-    IN_READ_BEGIN
-    size_t n = (size_t) m_paths.size();
-    IN_READ_END
-    return n;
-  }
-  
-  /// Returns the count of enabled watches.
-  /**
-   * \return count of enabled watches
-   * 
-   * \sa GetWatchCount()
-   */  
-  inline size_t GetEnabledCount() const
-  {
-    IN_READ_BEGIN
-    size_t n = (size_t) m_watches.size();
-    IN_READ_END
-    return n;
-  }
-  
-  /// Waits for inotify events.
-  /**
-   * It waits until one or more events occur. When called
-   * in nonblocking mode it only retrieves occurred events
-   * to the internal queue and exits.
-   * 
-   * \param[in] fNoIntr if true it re-calls the system call after a handled signal
-   * 
-   * \throw InotifyException thrown if reading events failed
-   * 
-   * \sa SetNonBlock()
-   */
-  void WaitForEvents(bool fNoIntr = false) throw (InotifyException);
-  
-  /// Returns the count of received and queued events.
-  /**
-   * This number is related to the events in the queue inside
-   * this object, not to the events pending in the kernel.
-   * 
-   * \return count of events
-   */
-  inline size_t GetEventCount()
-  {
-    IN_READ_BEGIN
-    size_t n = (size_t) m_events.size();
-    IN_READ_END
-    return n;
-  }
-  
-  /// Extracts a queued inotify event.
-  /**
-   * The extracted event is removed from the queue.
-   * If the pointer is NULL it does nothing.
-   * 
-   * \param[in,out] pEvt event object
-   * 
-   * \throw InotifyException thrown if the provided pointer is NULL
-   */
-  bool GetEvent(InotifyEvent* pEvt) throw (InotifyException);
-  
-  /// Extracts a queued inotify event.
-  /**
-   * The extracted event is removed from the queue.
-   * 
-   * \param[in,out] rEvt event object
-   * 
-   * \throw InotifyException thrown only in very anomalous cases
-   */
-  bool GetEvent(InotifyEvent& rEvt) throw (InotifyException)
-  {
-    return GetEvent(&rEvt);
-  }
-  
-  /// Extracts a queued inotify event (without removing).
-  /**
-   * The extracted event stays in the queue.
-   * If the pointer is NULL it does nothing.
-   * 
-   * \param[in,out] pEvt event object
-   * 
-   * \throw InotifyException thrown if the provided pointer is NULL
-   */
-  bool PeekEvent(InotifyEvent* pEvt) throw (InotifyException);
-  
-  /// Extracts a queued inotify event (without removing).
-  /**
-   * The extracted event stays in the queue.
-   * 
-   * \param[in,out] rEvt event object
-   * 
-   * \throw InotifyException thrown only in very anomalous cases
-   */
-  bool PeekEvent(InotifyEvent& rEvt) throw (InotifyException)
-  {
-    return PeekEvent(&rEvt);
-  }
-  
-  /// Searches for a watch by a watch descriptor.
-  /**
-   * It tries to find a watch by the given descriptor.
-   * 
-   * \param[in] iDescriptor watch descriptor
-   * \return pointer to a watch; NULL if no such watch exists
-   */
-  InotifyWatch* FindWatch(int iDescriptor);
-  
-  /// Searches for a watch by a filesystem path.
-  /**
-   * It tries to find a watch by the given filesystem path.
-   * 
-   * \param[in] rPath filesystem path
-   * \return pointer to a watch; NULL if no such watch exists
-   * 
-   * \attention The path must be exactly identical to the one
-   *            used for the searched watch. Be careful about
-   *            absolute/relative and case-insensitive paths.
-   */
-   InotifyWatch* FindWatch(const std::string& rPath);
-  
-  /// Returns the file descriptor.
-  /**
-   * The descriptor can be used in standard low-level file
-   * functions (poll(), select(), fcntl() etc.).
-   * 
-   * \return valid file descriptor or -1 for inactive object
-   * 
-   * \sa SetNonBlock()
-   */
-  inline int GetDescriptor() const
-  {
-    return m_fd;
-  }
-  
-  /// Enables/disables non-blocking mode.
-  /**
-   * Use this mode if you want to monitor the descriptor
-   * (acquired thru GetDescriptor()) in functions such as
-   * poll(), select() etc.
-   * 
-   * Non-blocking mode is disabled by default.
-   * 
-   * \param[in] fNonBlock enable/disable non-blocking mode
-   * 
-   * \throw InotifyException thrown if setting mode failed
-   * 
-   * \sa GetDescriptor(), SetCloseOnExec()
-   */
-  void SetNonBlock(bool fNonBlock) throw (InotifyException);
-  
-  /// Enables/disables closing on exec.
-  /**
-   * Enable this if you want to close the descriptor when
-   * executing another program. Otherwise, the descriptor
-   * will be inherited.
-   * 
-   * Closing on exec is disabled by default.
-   * 
-   * \param[in] fClOnEx enable/disable closing on exec
-   * 
-   * \throw InotifyException thrown if setting failed
-   * 
-   * \sa GetDescriptor(), SetNonBlock()
-   */
-  void SetCloseOnExec(bool fClOnEx) throw (InotifyException);
-  
-  /// Acquires a particular inotify capability/limit.
-  /**
-   * \param[in] cap capability/limit identifier
-   * \return capability/limit value
-   * \throw InotifyException thrown if the given value cannot be acquired
-   */
-  static uint32_t GetCapability(InotifyCapability_t cap) throw (InotifyException);
-  
-  /// Modifies a particular inotify capability/limit.
-  /**
-   * \param[in] cap capability/limit identifier
-   * \param[in] val new capability/limit value
-   * \throw InotifyException thrown if the given value cannot be set
-   * \attention Using this function requires root privileges.
-   *            Beware of setting extensive values - it may seriously
-   *            affect system performance and/or stability.
-   */
-  static void SetCapability(InotifyCapability_t cap, uint32_t val) throw (InotifyException);
-  
-  /// Returns the maximum number of events in the kernel queue.
-  /**
-   * \return maximum number of events in the kernel queue
-   * \throw InotifyException thrown if the given value cannot be acquired
-   */
-  inline static uint32_t GetMaxEvents() throw (InotifyException)
-  {
-    return GetCapability(IN_MAX_EVENTS);
-  }
-  
-  /// Sets the maximum number of events in the kernel queue.
-  /**
-   * \param[in] val new value
-   * \throw InotifyException thrown if the given value cannot be set
-   * \attention Using this function requires root privileges.
-   *            Beware of setting extensive values - the greater value
-   *            is set here the more physical memory may be used for the inotify
-   *            infrastructure.
-   */
-  inline static void SetMaxEvents(uint32_t val) throw (InotifyException)
-  {
-    SetCapability(IN_MAX_EVENTS, val);
-  }
-  
-  /// Returns the maximum number of inotify instances per process.
-  /**
-   * It means the maximum number of open inotify file descriptors
-   * per running process.
-   * 
-   * \return maximum number of inotify instances
-   * \throw InotifyException thrown if the given value cannot be acquired
-   */
-  inline static uint32_t GetMaxInstances() throw (InotifyException)
-  {
-    return GetCapability(IN_MAX_INSTANCES);
-  }
-  
-  /// Sets the maximum number of inotify instances per process.
-  /**
-   * \param[in] val new value
-   * \throw InotifyException thrown if the given value cannot be set
-   * \attention Using this function requires root privileges.
-   *            Beware of setting extensive values - the greater value
-   *            is set here the more physical memory may be used for the inotify
-   *            infrastructure.
-   */
-  inline static void SetMaxInstances(uint32_t val) throw (InotifyException)
-  {
-    SetCapability(IN_MAX_INSTANCES, val);
-  }
-  
-  /// Returns the maximum number of inotify watches per instance.
-  /**
-   * It means the maximum number of inotify watches per inotify
-   * file descriptor.
-   * 
-   * \return maximum number of inotify watches
-   * \throw InotifyException thrown if the given value cannot be acquired
-   */
-  inline static uint32_t GetMaxWatches() throw (InotifyException)
-  {
-    return GetCapability(IN_MAX_WATCHES);
-  }
-  
-  /// Sets the maximum number of inotify watches per instance.
-  /**
-   * \param[in] val new value
-   * \throw InotifyException thrown if the given value cannot be set
-   * \attention Using this function requires root privileges.
-   *            Beware of setting extensive values - the greater value
-   *            is set here the more physical memory may be used for the inotify
-   *            infrastructure.
-   */
-  inline static void SetMaxWatches(uint32_t val) throw (InotifyException)
-  {
-    SetCapability(IN_MAX_WATCHES, val);
-  }
+    /// Constructor.
+    /**
+     * Creates and initializes an instance of inotify communication
+     * object (opens the inotify device).
+     *
+     * \throw InotifyException thrown if inotify isn't available
+     */
+    Inotify() throw (InotifyException);
+
+    /// Destructor.
+    /**
+     * Calls Close() due to clean-up.
+     */
+    ~Inotify();
+
+    /// Removes all watches and closes the inotify device.
+    void Close();
+
+    /// Adds a new watch.
+    /**
+     * \param[in] pWatch inotify watch
+     *
+     * \throw InotifyException thrown if adding failed
+     */
+    void Add(InotifyWatch* pWatch) throw (InotifyException);
+
+    /// Adds a new watch.
+    /**
+     * \param[in] rWatch inotify watch
+     *
+     * \throw InotifyException thrown if adding failed
+     */
+    inline void Add(InotifyWatch& rWatch) throw (InotifyException)
+    {
+        Add(&rWatch);
+    }
+
+    /// Removes a watch.
+    /**
+     * If the given watch is not present it does nothing.
+     *
+     * \param[in] pWatch inotify watch
+     *
+     * \throw InotifyException thrown if removing failed
+     */
+    void Remove(InotifyWatch* pWatch) throw (InotifyException);
+
+    /// Removes a watch.
+    /**
+     * If the given watch is not present it does nothing.
+     *
+     * \param[in] rWatch inotify watch
+     *
+     * \throw InotifyException thrown if removing failed
+     */
+    inline void Remove(InotifyWatch& rWatch) throw (InotifyException)
+    {
+        Remove(&rWatch);
+    }
+
+    /// Removes all watches.
+    void RemoveAll();
+
+    /// Returns the count of watches.
+    /**
+     * This is the total count of all watches (regardless whether
+     * enabled or not).
+     *
+     * \return count of watches
+     *
+     * \sa GetEnabledCount()
+     */
+    inline size_t GetWatchCount() const
+    {
+        IN_READ_BEGIN
+        size_t n = (size_t) m_paths.size();
+        IN_READ_END
+        return n;
+    }
+
+    /// Returns the count of enabled watches.
+    /**
+     * \return count of enabled watches
+     *
+     * \sa GetWatchCount()
+     */
+    inline size_t GetEnabledCount() const
+    {
+        IN_READ_BEGIN
+        size_t n = (size_t) m_watches.size();
+        IN_READ_END
+        return n;
+    }
+
+    /// Waits for inotify events.
+    /**
+     * It waits until one or more events occur. When called
+     * in nonblocking mode it only retrieves occurred events
+     * to the internal queue and exits.
+     *
+     * \param[in] fNoIntr if true it re-calls the system call after a handled signal
+     *
+     * \throw InotifyException thrown if reading events failed
+     *
+     * \sa SetNonBlock()
+     */
+    void WaitForEvents(bool fNoIntr = false) throw (InotifyException);
+
+    /// Returns the count of received and queued events.
+    /**
+     * This number is related to the events in the queue inside
+     * this object, not to the events pending in the kernel.
+     *
+     * \return count of events
+     */
+    inline size_t GetEventCount()
+    {
+        IN_READ_BEGIN
+        size_t n = (size_t) m_events.size();
+        IN_READ_END
+        return n;
+    }
+
+    /// Extracts a queued inotify event.
+    /**
+     * The extracted event is removed from the queue.
+     * If the pointer is NULL it does nothing.
+     *
+     * \param[in,out] pEvt event object
+     *
+     * \throw InotifyException thrown if the provided pointer is NULL
+     */
+    bool GetEvent(InotifyEvent* pEvt) throw (InotifyException);
+
+    /// Extracts a queued inotify event.
+    /**
+     * The extracted event is removed from the queue.
+     *
+     * \param[in,out] rEvt event object
+     *
+     * \throw InotifyException thrown only in very anomalous cases
+     */
+    bool GetEvent(InotifyEvent& rEvt) throw (InotifyException)
+    {
+        return GetEvent(&rEvt);
+    }
+
+    /// Extracts a queued inotify event (without removing).
+    /**
+     * The extracted event stays in the queue.
+     * If the pointer is NULL it does nothing.
+     *
+     * \param[in,out] pEvt event object
+     *
+     * \throw InotifyException thrown if the provided pointer is NULL
+     */
+    bool PeekEvent(InotifyEvent* pEvt) throw (InotifyException);
+
+    /// Extracts a queued inotify event (without removing).
+    /**
+     * The extracted event stays in the queue.
+     *
+     * \param[in,out] rEvt event object
+     *
+     * \throw InotifyException thrown only in very anomalous cases
+     */
+    bool PeekEvent(InotifyEvent& rEvt) throw (InotifyException)
+    {
+        return PeekEvent(&rEvt);
+    }
+
+    /// Searches for a watch by a watch descriptor.
+    /**
+     * It tries to find a watch by the given descriptor.
+     *
+     * \param[in] iDescriptor watch descriptor
+     * \return pointer to a watch; NULL if no such watch exists
+     */
+    InotifyWatch* FindWatch(int iDescriptor);
+
+    /// Searches for a watch by a filesystem path.
+    /**
+     * It tries to find a watch by the given filesystem path.
+     *
+     * \param[in] rPath filesystem path
+     * \return pointer to a watch; NULL if no such watch exists
+     *
+     * \attention The path must be exactly identical to the one
+     *            used for the searched watch. Be careful about
+     *            absolute/relative and case-insensitive paths.
+     */
+    InotifyWatch* FindWatch(const std::string& rPath);
+
+    /// Returns the file descriptor.
+    /**
+     * The descriptor can be used in standard low-level file
+     * functions (poll(), select(), fcntl() etc.).
+     *
+     * \return valid file descriptor or -1 for inactive object
+     *
+     * \sa SetNonBlock()
+     */
+    inline int GetDescriptor() const
+    {
+        return m_fd;
+    }
+
+    /// Enables/disables non-blocking mode.
+    /**
+     * Use this mode if you want to monitor the descriptor
+     * (acquired thru GetDescriptor()) in functions such as
+     * poll(), select() etc.
+     *
+     * Non-blocking mode is disabled by default.
+     *
+     * \param[in] fNonBlock enable/disable non-blocking mode
+     *
+     * \throw InotifyException thrown if setting mode failed
+     *
+     * \sa GetDescriptor(), SetCloseOnExec()
+     */
+    void SetNonBlock(bool fNonBlock) throw (InotifyException);
+
+    /// Enables/disables closing on exec.
+    /**
+     * Enable this if you want to close the descriptor when
+     * executing another program. Otherwise, the descriptor
+     * will be inherited.
+     *
+     * Closing on exec is disabled by default.
+     *
+     * \param[in] fClOnEx enable/disable closing on exec
+     *
+     * \throw InotifyException thrown if setting failed
+     *
+     * \sa GetDescriptor(), SetNonBlock()
+     */
+    void SetCloseOnExec(bool fClOnEx) throw (InotifyException);
+
+    /// Acquires a particular inotify capability/limit.
+    /**
+     * \param[in] cap capability/limit identifier
+     * \return capability/limit value
+     * \throw InotifyException thrown if the given value cannot be acquired
+     */
+    static uint32_t GetCapability(InotifyCapability_t cap) throw (InotifyException);
+
+    /// Modifies a particular inotify capability/limit.
+    /**
+     * \param[in] cap capability/limit identifier
+     * \param[in] val new capability/limit value
+     * \throw InotifyException thrown if the given value cannot be set
+     * \attention Using this function requires root privileges.
+     *            Beware of setting extensive values - it may seriously
+     *            affect system performance and/or stability.
+     */
+    static void SetCapability(InotifyCapability_t cap, uint32_t val) throw (InotifyException);
+
+    /// Returns the maximum number of events in the kernel queue.
+    /**
+     * \return maximum number of events in the kernel queue
+     * \throw InotifyException thrown if the given value cannot be acquired
+     */
+    inline static uint32_t GetMaxEvents() throw (InotifyException)
+    {
+        return GetCapability(IN_MAX_EVENTS);
+    }
+
+    /// Sets the maximum number of events in the kernel queue.
+    /**
+     * \param[in] val new value
+     * \throw InotifyException thrown if the given value cannot be set
+     * \attention Using this function requires root privileges.
+     *            Beware of setting extensive values - the greater value
+     *            is set here the more physical memory may be used for the inotify
+     *            infrastructure.
+     */
+    inline static void SetMaxEvents(uint32_t val) throw (InotifyException)
+    {
+        SetCapability(IN_MAX_EVENTS, val);
+    }
+
+    /// Returns the maximum number of inotify instances per process.
+    /**
+     * It means the maximum number of open inotify file descriptors
+     * per running process.
+     *
+     * \return maximum number of inotify instances
+     * \throw InotifyException thrown if the given value cannot be acquired
+     */
+    inline static uint32_t GetMaxInstances() throw (InotifyException)
+    {
+        return GetCapability(IN_MAX_INSTANCES);
+    }
+
+    /// Sets the maximum number of inotify instances per process.
+    /**
+     * \param[in] val new value
+     * \throw InotifyException thrown if the given value cannot be set
+     * \attention Using this function requires root privileges.
+     *            Beware of setting extensive values - the greater value
+     *            is set here the more physical memory may be used for the inotify
+     *            infrastructure.
+     */
+    inline static void SetMaxInstances(uint32_t val) throw (InotifyException)
+    {
+        SetCapability(IN_MAX_INSTANCES, val);
+    }
+
+    /// Returns the maximum number of inotify watches per instance.
+    /**
+     * It means the maximum number of inotify watches per inotify
+     * file descriptor.
+     *
+     * \return maximum number of inotify watches
+     * \throw InotifyException thrown if the given value cannot be acquired
+     */
+    inline static uint32_t GetMaxWatches() throw (InotifyException)
+    {
+        return GetCapability(IN_MAX_WATCHES);
+    }
+
+    /// Sets the maximum number of inotify watches per instance.
+    /**
+     * \param[in] val new value
+     * \throw InotifyException thrown if the given value cannot be set
+     * \attention Using this function requires root privileges.
+     *            Beware of setting extensive values - the greater value
+     *            is set here the more physical memory may be used for the inotify
+     *            infrastructure.
+     */
+    inline static void SetMaxWatches(uint32_t val) throw (InotifyException)
+    {
+        SetCapability(IN_MAX_WATCHES, val);
+    }
+
+private:
+    int m_fd;                             ///< file descriptor
+    IN_WATCH_MAP m_watches;               ///< watches (by descriptors)
+    IN_WP_MAP m_paths;                    ///< watches (by paths)
+    unsigned char m_buf[INOTIFY_BUFLEN];  ///< buffer for events
+    std::deque<InotifyEvent> m_events;    ///< event queue
+
+    IN_LOCK_DECL
+
+    friend class InotifyWatch;
 
-private: 
-  int m_fd;                             ///< file descriptor
-  IN_WATCH_MAP m_watches;               ///< watches (by descriptors)
-  IN_WP_MAP m_paths;                    ///< watches (by paths)
-  unsigned char m_buf[INOTIFY_BUFLEN];  ///< buffer for events
-  std::deque<InotifyEvent> m_events;    ///< event queue
-  
-  IN_LOCK_DECL
-  
-  friend class InotifyWatch;
-  
-  static std::string GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException);
+    static std::string GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException);
 };