Struct WatchOptions 

#[non_exhaustive]
pub struct WatchOptions {
    pub debounce: Duration,
    pub watch_group_policy: bool,
    pub poll_interval: Option<Duration>,
}

Tuning knobs for ProxyWatcher::with_options (#[non_exhaustive] — use WatchOptions::new / with_*).

use proxy_watch::WatchOptions;
use std::time::Duration;

let opts = WatchOptions::new()
    .with_debounce(Duration::from_millis(50))
    .with_group_policy(false);
assert_eq!(opts.debounce, Duration::from_millis(50));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

debounce: Duration

Debounce before re-read (default DEFAULT_DEBOUNCE); anything over 24 h is lowered to it.

A fixed window, not a sliding one: it opens on the first change, and further changes inside it are folded into the same emission rather than pushing it back. The wait after a change is therefore bounded by this value however long the storm of changes behind it lasts.

watch_group_policy: bool

Also read and watch per-machine group policy (default true; Windows only).

The one source no failure of which can fail a read. Whatever goes wrong here — an HKLM key this process cannot read, a policy AutoConfigURL this crate refuses as malformed — is reported as no policy, and ProxyConfig::fallbacks records that something went wrong without saying what. That is affordable because a ProxyConfigSource::GroupPolicy entry is never effective — see that variant for the measurement — so failing the whole read on its account would refuse a machine whose per-user store answers perfectly well. A value stored under a type the key’s own name does not carry is not a failure at all: a ProxyEnable written as a REG_SZ rather than the documented REG_DWORD reads here exactly like one that was never written, and the policy is reported as absent.

Watching it is worth more than reading it. The key holds one value Windows does act on — ProxySettingsPerUser, the only one inetres.admx defines there — and switching it changes what WinHttpGetIEProxyConfigForCurrentUser returns, so a change under this key can change the effective configuration even though nothing under it is ever the effective configuration.

poll_interval: Option<Duration>

Timer re-read in addition to notifications; anything under 200 ms is raised to it, and on macOS anything over an hour is lowered to an hour — the run loop wait this becomes is bounded so that it is never literally infinite.

It also decides how a notification route that will not arm reaches the caller. With no interval set, the platform’s primary route failing to arm is fatal: ProxyWatcher::with_options returns Error::Io, naming this option as the fix. With one set, that same failure only reaches WatchHealth::degraded, on a watcher that starts. Every other route degrades either way.

Implementations

impl WatchOptions

pub const fn new() -> Self

Default: 200 ms debounce, group policy on, polling off.

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

Set the debounce window (builder style).

pub const fn with_group_policy(self, watch: bool) -> Self

Enable or disable reading and watching per-machine group policy (builder style).

pub const fn with_poll_interval(self, interval: Option<Duration>) -> Self

Set or clear the polling interval (see WatchOptions::poll_interval).

use proxy_watch::WatchOptions;
use std::time::Duration;

let opts = WatchOptions::new().with_poll_interval(Some(Duration::from_secs(30)));
assert_eq!(opts.poll_interval, Some(Duration::from_secs(30)));

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 Debug for WatchOptions

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

Formats the value using the given formatter.

impl Default for WatchOptions

fn default() -> Self

Returns the “default value” for a type.

impl Eq for WatchOptions

impl PartialEq for WatchOptions

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for WatchOptions