Struct Registry 

pub struct Registry { /* private fields */ }

One slot per type, allocated on first use and never freed.

Each generated accessor has its own Registry, so the snapshot, the two runtime layers and the diff baseline do not collide on a shared key.

Example

use dynamic_config::{ConfigCell, Registry};

fn cell<T: Send + Sync + 'static>() -> &'static ConfigCell<T> {
    // Shared by every instantiation: a `static` in a function body is not
    // monomorphized.
    static REGISTRY: Registry = Registry::new();

    REGISTRY.entry::<T, ConfigCell<T>>()
}

cell::<u16>().store(8080);
assert_eq!(*cell::<u16>().load().unwrap(), 8080);

// A different type is a different slot.
assert!(cell::<String>().load().is_none());

Implementations

impl Registry

pub const fn new() -> Self

An empty registry.

pub fn entry<K, V>(&self) -> &'static V

where K: 'static, V: Default + Send + Sync + 'static,

The slot for K, created on first use.

The value is leaked deliberately. A configuration snapshot lives as long as the process, and the alternative — handing out an Arc and reference counting on every read — would cost more than the lookup it replaced. The leak is bounded by the number of monomorphizations, which is fixed at compile time.

Trait Implementations

impl Default for Registry

fn default() -> Registry

Returns the “default value” for a type.