Struct WatchOptions 

pub struct WatchOptions { /* private fields */ }

Available on crate feature watch only.

How a file watch waits.

event ──▶ ┌─ debounce ─┐ quiet? ──▶ grace ──▶ read
          └─ restarted by every further event ─┘
                       └─ but never past the ceiling ─┘

• debounce is the quiet period. An editor’s save is three or four filesystem events, and reloading on each of them reads a file that is still being written.
• ceiling bounds it. The quiet period restarts on every event, which is the point — but under a sustained storm of writes it would restart forever and the reload would starve. Four times the debounce unless it is set.
• atomic_save_grace is the pause after the window closes. An atomic save writes a temporary file and renames it into place, and the rename can be observed a hair before the new inode is visible. set_atomic_save_grace’s process-wide value unless it is set here.

A bare Duration converts, so the one-argument form still reads the way it always did:

use dynamic_config::WatchOptions;

// The common case, unchanged.
let handle = Config::builder("svc").watch(Duration::from_millis(100))?;

// And the same watch, with the numbers under it named.
let handle = Config::builder("svc").watch(
    WatchOptions::new(Duration::from_millis(100))
        .ceiling(Duration::from_secs(2))
        .atomic_save_grace(Duration::from_millis(50)),
)?;

Implementations

impl WatchOptions

pub const fn new(debounce: Duration) -> Self

The quiet period, with the other two left at their defaults.

pub const fn ceiling(self, ceiling: Duration) -> Self

The longest the quiet period may keep restarting before the reload happens regardless.

Four times the debounce unless this is called. Raise it where writes arrive in long bursts and reading mid-burst is worse than waiting; lower it where a reload must not be starved.

pub const fn atomic_save_grace(self, grace: Duration) -> Self

The pause between the window closing and the files being read.

The process-wide value unless this is called — which is the right default, because the pause compensates for the filesystem. Set it per watch where one configuration lives on a local disk and another on a mount whose renames take longer to become visible.

pub const fn debounce_of(&self) -> Duration

The quiet period.

Trait Implementations

impl Clone for WatchOptions

fn clone(&self) -> WatchOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for WatchOptions

impl Debug for WatchOptions

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

Formats the value using the given formatter.

impl Eq for WatchOptions

impl From<Duration> for WatchOptions

fn from(debounce: Duration) -> Self

Converts to this type from the input type.

impl PartialEq for WatchOptions

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for WatchOptions