Struct ConfigCell 

pub struct ConfigCell<T> { /* private fields */ }

Holds the current configuration snapshot for one type.

ConfigCell::new() is const, so this lives in a static — which is how #[dynamic_config] emits it.

Reads are lock-free. load clones an Arc out of an ArcSwap, so a reload never blocks a request handler and a reader that already holds an Arc keeps observing its own generation until it drops it. Call it once per unit of work: calling it twice within one request can straddle a reload and observe two different configurations.

Example

use dynamic_config::ConfigCell;

static PORT: ConfigCell<u16> = ConfigCell::new();

assert!(PORT.load().is_none());

PORT.store(8080);
assert_eq!(*PORT.load().unwrap(), 8080);

Implementations

impl<T> ConfigCell<T>

pub const fn new() -> Self

An empty cell.

pub fn store(&self, value: T)

Atomically installs value as the current snapshot.

Reload callbacks run, and with the async feature every waiting task is woken. Installing the first snapshot is not a reload, so callbacks do not fire for it — there is nothing to compare against.

pub fn on_reload(&self, hook: impl Fn(&Arc<T>, &Arc<T>) + Send + Sync + 'static)

Registers a callback for every later reload.

The callback receives the outgoing and incoming snapshots, in that order, and runs on whichever thread performed the reload — the watcher thread, usually. Keep it short, and do not store again from inside one: that recurses rather than deadlocking, which is worse.

Callbacks registered this way cannot be removed — a hook for the life of the process, which is what a server wants. Anything with a shorter life — a test, a plugin, a subsystem that can be torn down — should use on_reload_scoped and hold the guard.

A hook that panics is caught, reported, and skipped for that reload; the remaining hooks still run and the watcher thread survives. It is not unregistered — a bug in a hook should be loud on every reload, not once.

pub fn on_reload_scoped( &'static self, hook: impl Fn(&Arc<T>, &Arc<T>) + Send + Sync + 'static, ) -> HookGuard<T>

on_reload, scoped: dropping the returned guard unregisters the hook.

For anything whose life is shorter than the process — the permanent variant would keep a torn-down subsystem’s callback firing forever.

pub fn load(&self) -> Option<Arc<T>>

The current snapshot, or None if nothing has been stored yet.

pub fn get_or_panic(&self, type_name: &str) -> Arc<T>

The current snapshot, panicking if there is none.

type_name is used to build the message; the generated code passes the annotated struct’s name so the panic names the type the caller wrote.

Panics

If nothing has been stored yet.

pub fn changes(&'static self) -> Changes<T>

where T: Send + Sync,

Available on crate feature async only.

A handle woken by every later store.

The snapshot current at this call counts as already seen, so the first changed() waits for the next store. Read the value you start from with load.

Runtime-agnostic: it is a Future, and any executor drives it.

Trait Implementations

impl<T: Debug> Debug for ConfigCell<T>

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

Formats the value using the given formatter.

impl<T> Default for ConfigCell<T>

fn default() -> Self

Returns the “default value” for a type.