inventory

The inventory crate uses runtime initialization functions (similar to C's __attribute__((constructor)) or the ctor crate) to register plugins.

• Registration Timing: Registration happens dynamically during the 'life-before-main' phase for statically linked elements. For dynamically loaded libraries, registration occurs when dlopen is called.
• Platform Support: Supported on Linux, macOS, iOS, FreeBSD, Android, Windows, and WebAssembly. On unsupported platforms, the registry will simply be empty (no plugins will be registered).

Add inventory to your Cargo.toml dependencies to use typed distributed plugin registration.

[dependencies]
inventory = "0.3"

While inventory supports WebAssembly (Wasm) targets, the Wasm linker may not automatically call the constructors required for plugin registration depending on the module's linkage style.

If you are building a Wasm module that relies on inventory and might be instantiated multiple times, it is best practice to explicitly export and call __wasm_call_ctors immediately after instantiation to ensure all constructors run and to avoid unnecessary overhead.

Note: inventory's internal registration is idempotent, so calling constructors multiple times is generally safe but inefficient.

#[cfg(target_family = "wasm")]
unsafe extern "C" {
    fn __wasm_call_ctors();
}

fn main() {
    #[cfg(target_family = "wasm")]
    unsafe {
        __wasm_call_ctors();
    }
}

Use the inventory::submit! macro to register an instance of a type into a registry. This can be done from any source file or crate that has access to the plugin type. Like collect!, submit! must be placed outside of any function body. All submit! calls across all linked source files take effect automatically during the application's initialization phase (before main runs).

inventory::submit! {
    Flag::new('v', "verbose")
}

To create a registry for a specific type, use the inventory::collect! macro. This macro must be called in the same crate that defines the plugin type and must be placed outside of any function body (at the module level). It does not execute any code at runtime; it simply sets up the collection mechanism for that type.

pub struct Flag {
    short: char,
    name: &'static str,
    /* ... */
}

impl Flag {
    pub const fn new(short: char, name: &'static str) -> Self {
        Flag { short, name }
    }
}

inventory::collect!(Flag);

To access the registered plugins, use inventory::iter::<T>(). This returns an iterator yielding elements of type &'static T. Note that the order of iteration for plugins of the same type is not guaranteed.

for flag in inventory::iter::<Flag> {
    println!("-{}, --{}", flag.short, flag.name);
}

To access all registered plugins of a specific type, use the inventory::iter::<T> value. This provides an iterator that yields references of type &'static T for every item submitted to the registry of type T.

Note:

• There is no guarantee regarding the order in which plugins are visited; they may appear in any order.

// Assuming Flag has been collected and submitted to
for flag in inventory::iter::<Flag> {
    println!("-{}, --{}", flag.short, flag.name);
}