      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110

    //! Idiomatic inotify wrapper for the Rust programming language
    //!
    //! # About
    //!
    //! [inotify-rs] is an idiomatic wrapper around the Linux kernel's [inotify] API
    //! for the Rust programming language. It can be used for monitoring changes to
    //! files or directories.
    //!
    //! The [`Inotify`] struct is the main entry point into the API.
    //!
    //! # Example
    //!
    //! ```
    //! use inotify::{
    //!     Inotify,
    //!     WatchMask,
    //! };
    //!
    //! let mut inotify = Inotify::init()
    //!     .expect("Error while initializing inotify instance");
    //!
    //! # // Create a temporary file, so `add_watch` won't return an error.
    //! # use std::fs::File;
    //! # let mut test_file = File::create("/tmp/inotify-rs-test-file")
    //! #     .expect("Failed to create test file");
    //! #
    //! // Watch for modify and close events.
    //! inotify
    //!     .add_watch(
    //!         "/tmp/inotify-rs-test-file",
    //!         WatchMask::MODIFY | WatchMask::CLOSE,
    //!     )
    //!     .expect("Failed to add file watch");
    //!
    //! # // Modify file, so the following `read_events_blocking` won't block.
    //! # use std::io::Write;
    //! # write!(&mut test_file, "something\n")
    //! #     .expect("Failed to write something to test file");
    //! #
    //! // Read events that were added with `add_watch` above.
    //! let mut buffer = [0; 1024];
    //! let events = inotify.read_events_blocking(&mut buffer)
    //!     .expect("Error while reading events");
    //!
    //! for event in events {
    //!     // Handle event
    //! }
    //! ```
    //!
    //! # Attention: inotify gotchas
    //!
    //! inotify (as in, the Linux API, not this wrapper) has many edge cases, making
    //! it hard to use correctly. This can lead to weird and hard to find bugs in
    //! applications that are based on it. inotify-rs does its best to fix these
    //! issues, but sometimes this would require an amount of runtime overhead that
    //! is just unacceptable for a low-level wrapper such as this.
    //!
    //! We've documented any issues that inotify-rs has inherited from inotify, as
    //! far as we are aware of them. Please watch out for any further warnings
    //! throughout this documentation. If you want to be on the safe side, in case
    //! we have missed something, please read the [inotify man pages] carefully.
    //!
    //! [inotify-rs]: https://crates.io/crates/inotify
    //! [inotify]: https://en.wikipedia.org/wiki/Inotify
    //! [`Inotify`]: struct.Inotify.html
    //! [inotify man pages]: http://man7.org/linux/man-pages/man7/inotify.7.html

    #![deny(missing_docs)]
    #![deny(warnings)]

    #[macro_use]
    extern crate bitflags;

    extern crate libc;
    extern crate inotify_sys;

    #[cfg(feature = "stream")]
    #[macro_use]
    extern crate futures;

    #[cfg(feature = "stream")]
    extern crate tokio_reactor;

    mod events;
    mod fd_guard;
    mod inotify;
    mod util;
    mod watches;

    #[cfg(feature = "stream")]
    mod stream;

    pub use events::{
        Event,
        EventMask,
        EventOwned,
        Events,
    };
    pub use inotify::Inotify;
    pub use watches::{
        WatchDescriptor,
        WatchMask,
    };

    #[cfg(feature = "stream")]
    pub use self::stream::EventStream;

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)