Struct DictionaryRegistry 

pub struct DictionaryRegistry {
    pub dictionaries: HashMap<String, DictionaryConfig>,
    pub compression: HashMap<String, CompressionConfig>,
    pub settings: Settings,
}

Collection of dictionary configurations loaded from TOML files.

Fields

dictionaries: HashMap<String, DictionaryConfig>

Map of dictionary names to their configurations

compression: HashMap<String, CompressionConfig>

Compression algorithm configurations

settings: Settings

Global settings

Implementations

impl DictionaryRegistry

pub fn from_toml(content: &str) -> Result<Self, Error>

Parses dictionary configurations from TOML content.

pub fn load_default() -> Result<Self, Box<dyn Error>>

Loads the built-in dictionary configurations.

Returns the default dictionaries bundled with the library.

pub fn load_from_file(path: &Path) -> Result<Self, Box<dyn Error>>

Loads configuration from a custom file path.

pub fn load_with_overrides() -> Result<Self, Box<dyn Error>>

Loads configuration with user overrides from standard locations.

Searches in priority order:

1. Built-in dictionaries (from library)
2. ~/.config/base-d/dictionaries.toml (user overrides)
3. ./dictionaries.toml (project-local overrides)

Later configurations override earlier ones for matching dictionary names.

pub fn merge(&mut self, other: DictionaryRegistry)

Merges another configuration into this one.

Dictionaries from other override dictionaries with the same name in self.

pub fn get_dictionary(&self, name: &str) -> Option<&DictionaryConfig>

Retrieves an dictionary configuration by name.

pub fn dictionary( &self, name: &str, ) -> Result<Dictionary, DictionaryNotFoundError>

Builds a ready-to-use Dictionary from a named configuration.

This is a convenience method that handles the common pattern of:

1. Looking up the dictionary config
2. Getting effective chars
3. Building the Dictionary with proper mode/padding

Example

let registry = DictionaryRegistry::load_default()?;
let dict = registry.dictionary("base64")?;
let encoded = base_d::encode(b"Hello", &dict);

pub fn random(&self) -> Result<(String, Dictionary), Box<dyn Error>>

Returns a random dictionary suitable for encoding.

Only selects from dictionaries marked as common = true (the default). These are dictionaries that render consistently across platforms.

Example

let registry = DictionaryRegistry::load_default()?;
let (name, dict) = registry.random()?;
let encoded = base_d::encode(b"Hello", &dict);

pub fn names(&self) -> Vec<&str>

Returns a list of all dictionary names.

pub fn common_names(&self) -> Vec<&str>

Returns a list of common dictionary names (suitable for random selection).

pub fn word_dictionary( &self, name: &str, ) -> Result<WordDictionary, DictionaryNotFoundError>

Builds a WordDictionary from a named configuration.

Errors

Returns error if:

• Dictionary not found
• Dictionary is not word-type
• Word list file cannot be read
• Word dictionary building fails

Example

let registry = DictionaryRegistry::load_default()?;
// Would work if bip39 is defined as a word dictionary
// let dict = registry.word_dictionary("bip39")?;

pub fn alternating_word_dictionary( &self, name: &str, ) -> Result<AlternatingWordDictionary, DictionaryNotFoundError>

Builds an AlternatingWordDictionary from a named configuration.

This is used for PGP-style biometric word lists where even/odd bytes use different dictionaries.

Errors

Returns error if:

• Dictionary not found
• Dictionary is not word-type
• Dictionary does not have alternating field set
• Any of the sub-dictionaries cannot be loaded

Example

let registry = DictionaryRegistry::load_default()?;
let dict = registry.alternating_word_dictionary("pgp")?;

pub fn dictionary_type(&self, name: &str) -> Option<DictionaryType>

Returns the dictionary type for a named dictionary.

Returns None if the dictionary is not found.

pub fn is_word_dictionary(&self, name: &str) -> bool

Checks if a dictionary is word-based.

Trait Implementations

impl Debug for DictionaryRegistry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DictionaryRegistry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.