Struct AlphabetsConfig 

pub struct AlphabetsConfig {
    pub alphabets: HashMap<String, AlphabetConfig>,
}

Collection of alphabet configurations loaded from TOML files.

Fields

alphabets: HashMap<String, AlphabetConfig>

Map of alphabet names to their configurations

Implementations

impl AlphabetsConfig

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

Parses alphabet configurations from TOML content.

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

Loads the built-in alphabet configurations.

Returns the default alphabets bundled with the library.

Examples found in repository

examples/hello_world.rs (line 4)

fn main() {
    let config = AlphabetsConfig::load_default().unwrap();
    let alphabet_config = config.get_alphabet("cards").expect("cards alphabet not found");
    let chars: Vec<char> = alphabet_config.chars.chars().collect();
    let padding = alphabet_config.padding.as_ref().and_then(|s| s.chars().next());
    let alphabet = Alphabet::new_with_mode(chars, alphabet_config.mode.clone(), padding).unwrap();
    
    let data = b"Hello, World!";
    
    println!("Original: {}", String::from_utf8_lossy(data));
    println!("Alphabet: cards (base-{})", alphabet.base());
    let encoded = encode(data, &alphabet);
    println!("Encoded:  {}", encoded);
    
    let decoded = decode(&encoded, &alphabet).unwrap();
    println!("Decoded:  {}", String::from_utf8_lossy(&decoded));
    println!("\nRoundtrip successful: {}", data == &decoded[..]);
}

examples/list_alphabets.rs (line 4)

fn main() {
    let config = AlphabetsConfig::load_default().unwrap();
    
    println!("Available alphabets:\n");
    
    for (name, alphabet_config) in config.alphabets.iter() {
        let (char_count, preview) = match alphabet_config.mode {
            base_d::EncodingMode::ByteRange => {
                if let Some(start) = alphabet_config.start_codepoint {
                    let preview_chars: String = (0..10)
                        .filter_map(|i| std::char::from_u32(start + i))
                        .collect();
                    (256, preview_chars)
                } else {
                    (256, String::from("(invalid)"))
                }
            }
            _ => {
                let count = alphabet_config.chars.chars().count();
                let preview: String = alphabet_config.chars.chars().take(10).collect();
                (count, preview)
            }
        };
        let mode_str = match alphabet_config.mode {
            base_d::EncodingMode::BaseConversion => "math",
            base_d::EncodingMode::Chunked => "chunk",
            base_d::EncodingMode::ByteRange => "range",
        };
        println!("  {} (base-{}, {}): {}...", name, char_count, mode_str, preview);
    }
}

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 alphabets (from library)
2. ~/.config/base-d/alphabets.toml (user overrides)
3. ./alphabets.toml (project-local overrides)

Later configurations override earlier ones for matching alphabet names.

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

Merges another configuration into this one.

Alphabets from other override alphabets with the same name in self.

pub fn get_alphabet(&self, name: &str) -> Option<&AlphabetConfig>

Retrieves an alphabet configuration by name.

Examples found in repository

examples/hello_world.rs (line 5)

fn main() {
    let config = AlphabetsConfig::load_default().unwrap();
    let alphabet_config = config.get_alphabet("cards").expect("cards alphabet not found");
    let chars: Vec<char> = alphabet_config.chars.chars().collect();
    let padding = alphabet_config.padding.as_ref().and_then(|s| s.chars().next());
    let alphabet = Alphabet::new_with_mode(chars, alphabet_config.mode.clone(), padding).unwrap();
    
    let data = b"Hello, World!";
    
    println!("Original: {}", String::from_utf8_lossy(data));
    println!("Alphabet: cards (base-{})", alphabet.base());
    let encoded = encode(data, &alphabet);
    println!("Encoded:  {}", encoded);
    
    let decoded = decode(&encoded, &alphabet).unwrap();
    println!("Decoded:  {}", String::from_utf8_lossy(&decoded));
    println!("\nRoundtrip successful: {}", data == &decoded[..]);
}

Trait Implementations

impl Debug for AlphabetsConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AlphabetsConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.