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 cannot be removed. A reload hook that should stop firing should check a flag of its own; the alternative is handing out registration tokens nobody would remember to drop.

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.