Struct Event

pub struct Event {
    pub kind: EventKind,
    pub paths: Vec<PathBuf>,
    pub attrs: EventAttributes,
}

Notify event.

You might want to check Event::need_rescan to make sure no event was missed before you received this one.

Fields

kind: EventKind

Kind or type of the event.

This is a hierarchy of enums describing the event as precisely as possible. All enums in the hierarchy have two variants always present, Any and Other, accompanied by one or more specific variants.

Any should be used when more detail about the event is not known beyond the variant already selected. For example, AccessMode::Any means a file has been accessed, but that’s all we know.

Other should be used when more detail is available, but cannot be encoded as one of the defined variants. When specifying Other, the event attributes should contain an Info entry with a short string identifying this detail. That string is to be considered part of the interface of the backend (i.e. a change should probably be breaking).

For example, CreateKind::Other with an Info("mount") may indicate the binding of a mount. The documentation of the particular backend should indicate if any Other events are generated, and what their description means.

The EventKind::Any variant should be used as the “else” case when mapping native kernel bitmasks or bitmaps, such that if the mask is ever extended with new event types the backend will not gain bugs due to not matching new unknown event types.

paths: Vec<PathBuf>

Paths the event is about, if known.

If an event concerns two or more paths, and the paths are known at the time of event creation, they should all go in this Vec. Otherwise, using the Tracker attr may be more appropriate.

The order of the paths is likely to be significant! For example, renames where both ends of the name change are known will have the “source” path first, and the “target” path last.

attrs: EventAttributes

Additional attributes of the event.

Arbitrary data may be added to this field, without restriction beyond the Sync and Clone properties. Some data added here is considered for comparing and hashing, but not all: at this writing this is Tracker, Flag, Info, and Source.

Implementations

impl Event

pub fn need_rescan(&self) -> bool

Returns whether some events may have been missed. If true, you should assume any file or folder might have been modified.

See Flag::Rescan for more information.

pub fn tracker(&self) -> Option<usize>

Retrieves the tracker ID for an event directly, if present.

pub fn flag(&self) -> Option<Flag>

Retrieves the Notify flag for an event directly, if present.

pub fn info(&self) -> Option<&str>

Retrieves the additional info for an event directly, if present.

pub fn source(&self) -> Option<&str>

Retrieves the source for an event directly, if present.

pub fn new(kind: EventKind) -> Event

Creates a new Event given a kind.

pub fn set_kind(self, kind: EventKind) -> Event

Sets the kind.

pub fn add_path(self, path: PathBuf) -> Event

Adds a path to the event.

pub fn add_some_path(self, path: Option<PathBuf>) -> Event

Adds a path to the event if the argument is Some.

pub fn set_tracker(self, tracker: usize) -> Event

Sets the tracker.

pub fn set_info(self, info: &str) -> Event

Sets additional info onto the event.

pub fn set_flag(self, flag: Flag) -> Event

Sets the Notify flag onto the event.

pub fn set_process_id(self, process_id: u32) -> Event

Sets the process id onto the event.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Event

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Event

fn default() -> Event

Returns the “default value” for a type.

impl Hash for Event

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Event

fn eq(&self, other: &Event) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Event