Struct FileRegistry 

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

Generic registry for file-based resources.

Manages loading and accessing resources from multiple directories with consistent behavior for extension priority, collision detection, and dev/release modes.

Type Parameter

• T: The content type. Must implement Clone for get() to return owned values.

Example

let config = FileRegistryConfig {
    extensions: &[".yaml", ".yml"],
    transform: |content| serde_yaml::from_str(content).map_err(|e| LoadError::Transform {
        name: String::new(),
        message: e.to_string(),
    }),
};

let mut registry = FileRegistry::new(config);
registry.add_dir("./styles")?;

let definitions = registry.get("darcula")?;

Implementations

impl<T: Clone> FileRegistry<T>

pub fn new(config: FileRegistryConfig<T>) -> Self

Creates a new registry with the given configuration.

The registry starts empty. Call add_dir to register directories, then refresh or access resources to trigger initialization.

pub fn add_dir<P: AsRef<Path>>(&mut self, path: P) -> Result<(), LoadError>

Adds a directory to search for files.

Directories are searched in registration order. If files with the same name exist in multiple directories, a collision error is raised.

Lazy Initialization

The directory is validated but not walked immediately. Walking happens on first access or explicit refresh call.

Errors

Returns LoadError::DirectoryNotFound if the path doesn’t exist or isn’t a directory.

pub fn add_embedded(&mut self, name: &str, content: T)

Adds pre-embedded content (for release builds).

Embedded resources are stored directly in memory, avoiding filesystem access at runtime. Useful for deployment scenarios.

Note

Embedded resources shadow file-based resources with the same name.

pub fn refresh(&mut self) -> Result<(), LoadError>

Initializes/refreshes the registry from registered directories.

This walks all registered directories, discovers files, and builds the resolution map. Call this to:

• Pick up newly added files (in dev mode)
• Force re-initialization after adding directories

Panics

Panics if a collision is detected (same name from different directories). This is intentional—collisions are configuration errors that must be fixed.

Errors

Returns an error if directory walking fails.

pub fn get(&mut self, name: &str) -> Result<T, LoadError>

Gets a resource by name, applying the transform if reading from disk.

In dev mode (when using LoadedEntry::File): re-reads file and transforms on each call, enabling hot reload.

In release mode (when using LoadedEntry::Embedded): returns embedded content directly.

Errors

• LoadError::NotFound if the name doesn’t exist
• LoadError::Io if the file can’t be read
• LoadError::Transform if the transform function fails

pub fn get_entry(&self, name: &str) -> Option<&LoadedEntry<T>>

Returns a reference to the entry if it exists.

Unlike get, this doesn’t trigger initialization or file reading. Useful for checking if a name exists without side effects.

pub fn names(&self) -> impl Iterator<Item = &str>

Returns an iterator over all registered names.

pub fn len(&self) -> usize

Returns the number of registered resources.

Note: This counts both extensionless and with-extension entries, so it may be higher than the number of unique files.

pub fn is_empty(&self) -> bool

Returns true if no resources are registered.

pub fn clear(&mut self)

Clears all entries from the registry.

pub fn dirs(&self) -> &[PathBuf]

Returns the registered directories.