WebSVN - public - Diff - Rev 23 and 29 - /inotify-cxx/trunk/inotify-cxx.h

 /**
  * It prepends the message by the function name.
  */
 #define IN_EXC_MSG(msg) (std::string(__PRETTY_FUNCTION__) + ": " + msg)
+/// 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
+} InotifyCapability_t;
 /// inotify-cxx thread safety
 /**
  * If this symbol is defined you can use this interface safely
  * threaded applications. Remember that it slightly degrades
  * performance.
   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
    * \throw InotifyException thrown if setting mode failed
+   *
    * \sa GetDescriptor()
    */
   void SetNonBlock(bool fNonBlock) 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)
   std::deque<InotifyEvent> m_events;    ///< event queue
   IN_LOCK_DECL
   friend class InotifyWatch;
+  static std::string GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException);
 };
 #endif //_INOTIFYCXX_H_

Subversion Repositories public

(root)/inotify-cxx/trunk/inotify-cxx.h @ 33 - Rev 23 → 29