Struct DetectorFactory 

pub struct DetectorFactory {
    pub word_lang_prob_map: HashMap<String, Vec<f64>>,
    pub langlist: Vec<String>,
    pub seed: Option<u64>,
}

Factory for creating language detectors with pre-loaded language profiles.

The DetectorFactory manages a collection of language profiles and provides methods to create Detector instances for language identification.

Examples

use langdetect_rs::detector_factory::DetectorFactory;

// Create factory with built-in profiles
let factory = DetectorFactory::default().build();

// Create a detector
let detector = factory.create(None);

Fields

word_lang_prob_map: HashMap<String, Vec<f64>>

Word-to-language probability mapping for all loaded languages.

langlist: Vec<String>

List of language identifiers in the same order as probability vectors.

seed: Option<u64>

Optional seed for reproducible randomization.

Implementations

impl DetectorFactory

pub fn new() -> DetectorFactoryBuilder

Creates a new DetectorFactory builder.

Use the builder pattern to configure the factory before calling build().

Examples

use langdetect_rs::detector_factory::DetectorFactory;

let factory = DetectorFactory::new()
    .with_seed(Some(42))
    .build();

Examples found in repository

examples/custom_profile/main.rs (line 7)

fn main() {
    // Create an empty factory
    let mut factory = DetectorFactory::new().build();

    // Load language profiles from the crate's profiles directory
    let profiles_dir = Path::new("./").join("profiles");

    println!("Read JSON profiles from {}", profiles_dir.display());

    // Load Russian profile
    let ru_json = LangProfileJson::new_from_file(profiles_dir.join("ru"));
    match &ru_json {
        Ok(_) => println!("\tRead Russian JSON profile"),
        Err(e) => {
            println!("Error reading Russian JSON profile: {:?}", e);
            return;
        }
    }
    let ru_profile = match LangProfile::from_json(ru_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Russian LangProfile: {}", e);
            return;
        }
    };

    // Load English profile
    let en_json = LangProfileJson::new_from_file(profiles_dir.join("en"));
    match &en_json {
        Ok(_) => println!("\tRead English JSON profile"),
        Err(e) => {
            println!("Error reading English JSON profile: {:?}", e);
            return;
        }
    }
    let en_profile = match LangProfile::from_json(en_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating English LangProfile: {}", e);
            return;
        }
    };
    
    println!("Adding custom language profiles to the factory...");
    // Add profiles to the factory
    // Make sure to use correct language IDs as per your profiles
    // And provide correct FINAL size of languages array
    let final_size = 2; // Update this if you add more profiles
    if let Err(e) = factory.add_profile(ru_profile, 0, final_size
    ) {
        println!("Error adding Russian profile: {:?}", e);
        return;
    }
    println!("\tLoaded Russian profile");
    if let Err(e) = factory.add_profile(en_profile, 1, final_size) {
        println!("Error adding English profile: {:?}", e);
        return;
    }
    println!("\tLoaded English profile");

    println!("Factory loaded with {} languages: {:?}", factory.get_lang_list().len(), factory.get_lang_list());

    println!("Testing language detection...");

    // Test Russian text
    match factory.detect("Привет, меня зовут Дима, и я разработчик", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("Hello world! My name is Dima and I am a developer", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test French text (will be detected as the closest match from available languages)
    // IMPORTANT: The algorithm always returns the best guess from loaded languages, never fails
    // EXCEPTIONS: Returns error if no recognizable n-grams found, or "unknown" if all probabilities ≤ 0.1
    // If you want to detect "unknown" languages, check probability thresholds or handle the error cases
    match factory.detect("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(lang) => println!("\tFrench text detected as: {} (closest match from ru/en)", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Show probabilities for the French text to see why it was classified as English
    match factory.get_probabilities("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(probs) => {
            println!("\tFrench text probabilities:");
            for lang in probs {
                println!("\t\t{}: {:.3}", lang.lang.unwrap_or_default(), lang.prob);
            }
        }
        Err(e) => println!("Probability error: {:?}", e),
    }
}

examples/extend_default/main.rs (line 40)

fn main() {
    // Load language profiles from the crate's profiles directory
    let profiles_dir = DetectorFactory::get_default_profiles_path();

    println!("Read all default JSON profiles from {}", profiles_dir.display());

    let mut lang_profiles = vec![];
    // Load every profile in the directory
    for entry in std::fs::read_dir(&profiles_dir).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        if !path.is_file() {
            continue;
        }
        let lang_json = LangProfileJson::new_from_file(path);
        match &lang_json {
            Ok(_) => println!("\tRead {} JSON profile", entry.file_name().to_string_lossy()),
            Err(e) => {
                println!("Error reading {} JSON profile: {:?}", entry.file_name().to_string_lossy(), e);
                return;
            }
        }
        let lang_profile = match LangProfile::from_json(lang_json.unwrap()) {
            Ok(profile) => profile,
            Err(e) => {
                println!("Error creating {} LangProfile: {}", entry.file_name().to_string_lossy(), e);
                return;
            }
        };
        lang_profiles.push(lang_profile);
    }

    println!("Adding all default languages profiles to the factory...");

    // Create an EMPTY factory
    let mut factory = DetectorFactory::new().build();

    // Get number of profiles to set final size
    let mut profile_count = lang_profiles.len();
    // Since we know that we are going to add another profile which is not in the default set
    // we increase the final size by 1
    profile_count += 1;

    println!("Final size (assuming we are going to extend default set) of languages array will be: {}", profile_count);
    
    for (i, profile) in lang_profiles.into_iter().enumerate() {
        let profile_name = if let Some(name) = &profile.name {
            name.clone()
        } else {
            "unknown".to_string()
        };
        println!("\tAdding profile: {} at index {}", profile_name, i);
        if let Err(e) = factory.add_profile(profile, i, profile_count) {
            println!("Error adding {} profile: {:?}", profile_name, e);
            return;
        }
    }

    // Load another profile (in documentation for generating profiles it is Sakha (Yakut) language - "sah")
    let sah_path = Path::new("./scripts/datasets/generated").join("sah_generated.json");
    let sah_json = LangProfileJson::new_from_file(sah_path);
    match &sah_json {
        Ok(_) => println!("Read Sakha JSON profile"),
        Err(e) => {
            println!("Error reading Sakha JSON profile: {:?}", e);
            return;
        }
    }
    let sah_profile = match LangProfile::from_json(sah_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Sakha LangProfile: {}", e);
            return;
        }
    };
    println!("Adding Sakha language profile to the factory");
    if let Err(e) = factory.add_profile(sah_profile, profile_count - 1, profile_count) {
        println!("Error adding Sakha profile: {:?}", e);
        return;
    }

    println!("Testing language detection...");
    // Test Russian text
    match factory.detect("В своём глазу бревна не замечает, а в чужом соломинку видит", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("He pays no attention to the plank in his own eye", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test Sakha (Yakut) text
    match factory.detect("Айаҕыттан тахсар сытыканы билбэт.", None) {
        Ok(lang) => println!("\tSakha text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn default() -> DetectorFactoryBuilder

Creates a DetectorFactoryBuilder with all built-in language profiles loaded.

This method loads the 55 built-in language profiles from the crate’s profiles directory and returns a builder that can be further re-configured. The profiles are cached for performance.

Example

use langdetect_rs::detector_factory::DetectorFactory;

let factory = DetectorFactory::default()
    .with_seed(Some(42))
    .build();

Examples found in repository

examples/simple/main.rs (line 4)

fn main() {
    let factory = DetectorFactory::default().build();

    // let mut detector = factory.create(None);
    match factory.detect("War doesn't show who's right, just who's left.", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // let mut detector = factory.create(None);
    match factory.detect("Ein, zwei, drei, vier", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    match factory.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // For reproducibility use a fixed seed within explicitly defined detector
    let mut detector = factory.create(None);
    detector.seed = Some(42);
    detector.append("Otec matka syn.");
    match detector.get_probabilities() {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Or you can set the seed for the factory itself and it will be inherited by detectors
    let factory_with_seed = DetectorFactory::default()
        .with_seed(Some(43))
        .build();
    match factory_with_seed.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn get_default_profiles_path() -> PathBuf

Returns the path to the default language profiles directory.

This method provides the path to the built-in language profile files that ship with the crate. End-users can use this path to load default profiles when extending or customizing the factory.

Note: This path is only accessible when the crate is used as a source dependency or when running from the crate’s directory. When used as a published dependency, the profiles may not be available as filesystem files.

Returns

A PathBuf pointing to the default profiles directory.

Example

use langdetect_rs::detector_factory::DetectorFactory;
use langdetect_rs::utils::lang_profile::{LangProfileJson, LangProfile};

// Get path to default profiles
let profiles_path = DetectorFactory::get_default_profiles_path();
println!("Default profiles are located at: {:?}", profiles_path);

// Load a specific profile
let en_profile = LangProfileJson::new_from_file(profiles_path.join("en")).unwrap();
let profile = LangProfile::from_json(en_profile).unwrap();

// Add to custom factory
let mut factory = DetectorFactory::new().build();
factory.add_profile(profile, 0, 1).unwrap();

Examples found in repository

examples/extend_default/main.rs (line 7)

fn main() {
    // Load language profiles from the crate's profiles directory
    let profiles_dir = DetectorFactory::get_default_profiles_path();

    println!("Read all default JSON profiles from {}", profiles_dir.display());

    let mut lang_profiles = vec![];
    // Load every profile in the directory
    for entry in std::fs::read_dir(&profiles_dir).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        if !path.is_file() {
            continue;
        }
        let lang_json = LangProfileJson::new_from_file(path);
        match &lang_json {
            Ok(_) => println!("\tRead {} JSON profile", entry.file_name().to_string_lossy()),
            Err(e) => {
                println!("Error reading {} JSON profile: {:?}", entry.file_name().to_string_lossy(), e);
                return;
            }
        }
        let lang_profile = match LangProfile::from_json(lang_json.unwrap()) {
            Ok(profile) => profile,
            Err(e) => {
                println!("Error creating {} LangProfile: {}", entry.file_name().to_string_lossy(), e);
                return;
            }
        };
        lang_profiles.push(lang_profile);
    }

    println!("Adding all default languages profiles to the factory...");

    // Create an EMPTY factory
    let mut factory = DetectorFactory::new().build();

    // Get number of profiles to set final size
    let mut profile_count = lang_profiles.len();
    // Since we know that we are going to add another profile which is not in the default set
    // we increase the final size by 1
    profile_count += 1;

    println!("Final size (assuming we are going to extend default set) of languages array will be: {}", profile_count);
    
    for (i, profile) in lang_profiles.into_iter().enumerate() {
        let profile_name = if let Some(name) = &profile.name {
            name.clone()
        } else {
            "unknown".to_string()
        };
        println!("\tAdding profile: {} at index {}", profile_name, i);
        if let Err(e) = factory.add_profile(profile, i, profile_count) {
            println!("Error adding {} profile: {:?}", profile_name, e);
            return;
        }
    }

    // Load another profile (in documentation for generating profiles it is Sakha (Yakut) language - "sah")
    let sah_path = Path::new("./scripts/datasets/generated").join("sah_generated.json");
    let sah_json = LangProfileJson::new_from_file(sah_path);
    match &sah_json {
        Ok(_) => println!("Read Sakha JSON profile"),
        Err(e) => {
            println!("Error reading Sakha JSON profile: {:?}", e);
            return;
        }
    }
    let sah_profile = match LangProfile::from_json(sah_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Sakha LangProfile: {}", e);
            return;
        }
    };
    println!("Adding Sakha language profile to the factory");
    if let Err(e) = factory.add_profile(sah_profile, profile_count - 1, profile_count) {
        println!("Error adding Sakha profile: {:?}", e);
        return;
    }

    println!("Testing language detection...");
    // Test Russian text
    match factory.detect("В своём глазу бревна не замечает, а в чужом соломинку видит", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("He pays no attention to the plank in his own eye", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test Sakha (Yakut) text
    match factory.detect("Айаҕыттан тахсар сытыканы билбэт.", None) {
        Ok(lang) => println!("\tSakha text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn clear(&mut self)

Clears all loaded language profiles and mappings.

pub fn set_seed(&mut self, seed: u64)

Sets the randomization seed for reproducible results.

Arguments

• seed - The seed value to use for randomization.

pub fn get_lang_list(&self) -> Vec<String>

Returns a list of all loaded language identifiers.

Returns

A vector of language codes (ISO 639-1) in the order they were loaded.

Examples found in repository

examples/custom_profile/main.rs (line 65)

fn main() {
    // Create an empty factory
    let mut factory = DetectorFactory::new().build();

    // Load language profiles from the crate's profiles directory
    let profiles_dir = Path::new("./").join("profiles");

    println!("Read JSON profiles from {}", profiles_dir.display());

    // Load Russian profile
    let ru_json = LangProfileJson::new_from_file(profiles_dir.join("ru"));
    match &ru_json {
        Ok(_) => println!("\tRead Russian JSON profile"),
        Err(e) => {
            println!("Error reading Russian JSON profile: {:?}", e);
            return;
        }
    }
    let ru_profile = match LangProfile::from_json(ru_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Russian LangProfile: {}", e);
            return;
        }
    };

    // Load English profile
    let en_json = LangProfileJson::new_from_file(profiles_dir.join("en"));
    match &en_json {
        Ok(_) => println!("\tRead English JSON profile"),
        Err(e) => {
            println!("Error reading English JSON profile: {:?}", e);
            return;
        }
    }
    let en_profile = match LangProfile::from_json(en_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating English LangProfile: {}", e);
            return;
        }
    };
    
    println!("Adding custom language profiles to the factory...");
    // Add profiles to the factory
    // Make sure to use correct language IDs as per your profiles
    // And provide correct FINAL size of languages array
    let final_size = 2; // Update this if you add more profiles
    if let Err(e) = factory.add_profile(ru_profile, 0, final_size
    ) {
        println!("Error adding Russian profile: {:?}", e);
        return;
    }
    println!("\tLoaded Russian profile");
    if let Err(e) = factory.add_profile(en_profile, 1, final_size) {
        println!("Error adding English profile: {:?}", e);
        return;
    }
    println!("\tLoaded English profile");

    println!("Factory loaded with {} languages: {:?}", factory.get_lang_list().len(), factory.get_lang_list());

    println!("Testing language detection...");

    // Test Russian text
    match factory.detect("Привет, меня зовут Дима, и я разработчик", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("Hello world! My name is Dima and I am a developer", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test French text (will be detected as the closest match from available languages)
    // IMPORTANT: The algorithm always returns the best guess from loaded languages, never fails
    // EXCEPTIONS: Returns error if no recognizable n-grams found, or "unknown" if all probabilities ≤ 0.1
    // If you want to detect "unknown" languages, check probability thresholds or handle the error cases
    match factory.detect("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(lang) => println!("\tFrench text detected as: {} (closest match from ru/en)", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Show probabilities for the French text to see why it was classified as English
    match factory.get_probabilities("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(probs) => {
            println!("\tFrench text probabilities:");
            for lang in probs {
                println!("\t\t{}: {:.3}", lang.lang.unwrap_or_default(), lang.prob);
            }
        }
        Err(e) => println!("Probability error: {:?}", e),
    }
}

pub fn create(&self, alpha: Option<f64>) -> Detector

Creates a new Detector instance with the current profiles.

Arguments

• alpha - Optional alpha smoothing parameter (default: 0.5).

Returns

A configured Detector ready for language detection.

Examples found in repository

examples/simple/main.rs (line 24)

fn main() {
    let factory = DetectorFactory::default().build();

    // let mut detector = factory.create(None);
    match factory.detect("War doesn't show who's right, just who's left.", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // let mut detector = factory.create(None);
    match factory.detect("Ein, zwei, drei, vier", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    match factory.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // For reproducibility use a fixed seed within explicitly defined detector
    let mut detector = factory.create(None);
    detector.seed = Some(42);
    detector.append("Otec matka syn.");
    match detector.get_probabilities() {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Or you can set the seed for the factory itself and it will be inherited by detectors
    let factory_with_seed = DetectorFactory::default()
        .with_seed(Some(43))
        .build();
    match factory_with_seed.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn override_profile( &mut self, profile: LangProfile, index: usize, langsize: usize, ) -> Result<(), DetectorFactoryError>

Overrides an existing language profile at the specified index.

This is an internal method used during profile loading.

Arguments

• profile - The language profile to add.
• index - The index in the language list.
• langsize - Total number of languages.

pub fn add_profile( &mut self, profile: LangProfile, index: usize, langsize: usize, ) -> Result<(), DetectorFactoryError>

Adds a new language profile to the factory.

Arguments

• profile - The language profile to add.
• index - The index position for this language.
• langsize - Total number of languages in the profile set.

Errors

Returns DetectorFactoryError::DuplicatedLanguage if the language already exists.

Examples found in repository

examples/custom_profile/main.rs (lines 53-54)

fn main() {
    // Create an empty factory
    let mut factory = DetectorFactory::new().build();

    // Load language profiles from the crate's profiles directory
    let profiles_dir = Path::new("./").join("profiles");

    println!("Read JSON profiles from {}", profiles_dir.display());

    // Load Russian profile
    let ru_json = LangProfileJson::new_from_file(profiles_dir.join("ru"));
    match &ru_json {
        Ok(_) => println!("\tRead Russian JSON profile"),
        Err(e) => {
            println!("Error reading Russian JSON profile: {:?}", e);
            return;
        }
    }
    let ru_profile = match LangProfile::from_json(ru_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Russian LangProfile: {}", e);
            return;
        }
    };

    // Load English profile
    let en_json = LangProfileJson::new_from_file(profiles_dir.join("en"));
    match &en_json {
        Ok(_) => println!("\tRead English JSON profile"),
        Err(e) => {
            println!("Error reading English JSON profile: {:?}", e);
            return;
        }
    }
    let en_profile = match LangProfile::from_json(en_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating English LangProfile: {}", e);
            return;
        }
    };
    
    println!("Adding custom language profiles to the factory...");
    // Add profiles to the factory
    // Make sure to use correct language IDs as per your profiles
    // And provide correct FINAL size of languages array
    let final_size = 2; // Update this if you add more profiles
    if let Err(e) = factory.add_profile(ru_profile, 0, final_size
    ) {
        println!("Error adding Russian profile: {:?}", e);
        return;
    }
    println!("\tLoaded Russian profile");
    if let Err(e) = factory.add_profile(en_profile, 1, final_size) {
        println!("Error adding English profile: {:?}", e);
        return;
    }
    println!("\tLoaded English profile");

    println!("Factory loaded with {} languages: {:?}", factory.get_lang_list().len(), factory.get_lang_list());

    println!("Testing language detection...");

    // Test Russian text
    match factory.detect("Привет, меня зовут Дима, и я разработчик", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("Hello world! My name is Dima and I am a developer", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test French text (will be detected as the closest match from available languages)
    // IMPORTANT: The algorithm always returns the best guess from loaded languages, never fails
    // EXCEPTIONS: Returns error if no recognizable n-grams found, or "unknown" if all probabilities ≤ 0.1
    // If you want to detect "unknown" languages, check probability thresholds or handle the error cases
    match factory.detect("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(lang) => println!("\tFrench text detected as: {} (closest match from ru/en)", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Show probabilities for the French text to see why it was classified as English
    match factory.get_probabilities("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(probs) => {
            println!("\tFrench text probabilities:");
            for lang in probs {
                println!("\t\t{}: {:.3}", lang.lang.unwrap_or_default(), lang.prob);
            }
        }
        Err(e) => println!("Probability error: {:?}", e),
    }
}

examples/extend_default/main.rs (line 57)

fn main() {
    // Load language profiles from the crate's profiles directory
    let profiles_dir = DetectorFactory::get_default_profiles_path();

    println!("Read all default JSON profiles from {}", profiles_dir.display());

    let mut lang_profiles = vec![];
    // Load every profile in the directory
    for entry in std::fs::read_dir(&profiles_dir).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        if !path.is_file() {
            continue;
        }
        let lang_json = LangProfileJson::new_from_file(path);
        match &lang_json {
            Ok(_) => println!("\tRead {} JSON profile", entry.file_name().to_string_lossy()),
            Err(e) => {
                println!("Error reading {} JSON profile: {:?}", entry.file_name().to_string_lossy(), e);
                return;
            }
        }
        let lang_profile = match LangProfile::from_json(lang_json.unwrap()) {
            Ok(profile) => profile,
            Err(e) => {
                println!("Error creating {} LangProfile: {}", entry.file_name().to_string_lossy(), e);
                return;
            }
        };
        lang_profiles.push(lang_profile);
    }

    println!("Adding all default languages profiles to the factory...");

    // Create an EMPTY factory
    let mut factory = DetectorFactory::new().build();

    // Get number of profiles to set final size
    let mut profile_count = lang_profiles.len();
    // Since we know that we are going to add another profile which is not in the default set
    // we increase the final size by 1
    profile_count += 1;

    println!("Final size (assuming we are going to extend default set) of languages array will be: {}", profile_count);
    
    for (i, profile) in lang_profiles.into_iter().enumerate() {
        let profile_name = if let Some(name) = &profile.name {
            name.clone()
        } else {
            "unknown".to_string()
        };
        println!("\tAdding profile: {} at index {}", profile_name, i);
        if let Err(e) = factory.add_profile(profile, i, profile_count) {
            println!("Error adding {} profile: {:?}", profile_name, e);
            return;
        }
    }

    // Load another profile (in documentation for generating profiles it is Sakha (Yakut) language - "sah")
    let sah_path = Path::new("./scripts/datasets/generated").join("sah_generated.json");
    let sah_json = LangProfileJson::new_from_file(sah_path);
    match &sah_json {
        Ok(_) => println!("Read Sakha JSON profile"),
        Err(e) => {
            println!("Error reading Sakha JSON profile: {:?}", e);
            return;
        }
    }
    let sah_profile = match LangProfile::from_json(sah_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Sakha LangProfile: {}", e);
            return;
        }
    };
    println!("Adding Sakha language profile to the factory");
    if let Err(e) = factory.add_profile(sah_profile, profile_count - 1, profile_count) {
        println!("Error adding Sakha profile: {:?}", e);
        return;
    }

    println!("Testing language detection...");
    // Test Russian text
    match factory.detect("В своём глазу бревна не замечает, а в чужом соломинку видит", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("He pays no attention to the plank in his own eye", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test Sakha (Yakut) text
    match factory.detect("Айаҕыттан тахсар сытыканы билбэт.", None) {
        Ok(lang) => println!("\tSakha text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn delete_profile(&mut self, lang: &str) -> Result<(), DetectorFactoryError>

Removes a language profile from the factory.

Arguments

• lang - The language code to remove.

Errors

Returns DetectorFactoryError::DuplicatedLanguage if the language doesn’t exist.

pub fn load_json_profile( &mut self, json_profiles: &[&str], ) -> Result<(), DetectorFactoryError>

Loads language profiles from JSON strings.

Arguments

• json_profiles - Array of JSON strings representing language profiles.

Errors

Returns DetectorFactoryError::NotEnoughProfiles if fewer than 2 profiles provided.

pub fn detect( &self, text: &str, alpha: Option<f64>, ) -> Result<String, DetectorError>

Shortcut method to detect language from text in one call.

Arguments

• text - The text to analyze.
• alpha - Optional alpha smoothing parameter.

Returns

The detected language code or an error.

Example

use langdetect_rs::detector_factory::DetectorFactory;

let factory = DetectorFactory::default().build();
let result = factory.detect("Hello world!", None);

Examples found in repository

examples/simple/main.rs (line 7)

fn main() {
    let factory = DetectorFactory::default().build();

    // let mut detector = factory.create(None);
    match factory.detect("War doesn't show who's right, just who's left.", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // let mut detector = factory.create(None);
    match factory.detect("Ein, zwei, drei, vier", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    match factory.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // For reproducibility use a fixed seed within explicitly defined detector
    let mut detector = factory.create(None);
    detector.seed = Some(42);
    detector.append("Otec matka syn.");
    match detector.get_probabilities() {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Or you can set the seed for the factory itself and it will be inherited by detectors
    let factory_with_seed = DetectorFactory::default()
        .with_seed(Some(43))
        .build();
    match factory_with_seed.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

examples/custom_profile/main.rs (line 70)

fn main() {
    // Create an empty factory
    let mut factory = DetectorFactory::new().build();

    // Load language profiles from the crate's profiles directory
    let profiles_dir = Path::new("./").join("profiles");

    println!("Read JSON profiles from {}", profiles_dir.display());

    // Load Russian profile
    let ru_json = LangProfileJson::new_from_file(profiles_dir.join("ru"));
    match &ru_json {
        Ok(_) => println!("\tRead Russian JSON profile"),
        Err(e) => {
            println!("Error reading Russian JSON profile: {:?}", e);
            return;
        }
    }
    let ru_profile = match LangProfile::from_json(ru_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Russian LangProfile: {}", e);
            return;
        }
    };

    // Load English profile
    let en_json = LangProfileJson::new_from_file(profiles_dir.join("en"));
    match &en_json {
        Ok(_) => println!("\tRead English JSON profile"),
        Err(e) => {
            println!("Error reading English JSON profile: {:?}", e);
            return;
        }
    }
    let en_profile = match LangProfile::from_json(en_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating English LangProfile: {}", e);
            return;
        }
    };
    
    println!("Adding custom language profiles to the factory...");
    // Add profiles to the factory
    // Make sure to use correct language IDs as per your profiles
    // And provide correct FINAL size of languages array
    let final_size = 2; // Update this if you add more profiles
    if let Err(e) = factory.add_profile(ru_profile, 0, final_size
    ) {
        println!("Error adding Russian profile: {:?}", e);
        return;
    }
    println!("\tLoaded Russian profile");
    if let Err(e) = factory.add_profile(en_profile, 1, final_size) {
        println!("Error adding English profile: {:?}", e);
        return;
    }
    println!("\tLoaded English profile");

    println!("Factory loaded with {} languages: {:?}", factory.get_lang_list().len(), factory.get_lang_list());

    println!("Testing language detection...");

    // Test Russian text
    match factory.detect("Привет, меня зовут Дима, и я разработчик", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("Hello world! My name is Dima and I am a developer", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test French text (will be detected as the closest match from available languages)
    // IMPORTANT: The algorithm always returns the best guess from loaded languages, never fails
    // EXCEPTIONS: Returns error if no recognizable n-grams found, or "unknown" if all probabilities ≤ 0.1
    // If you want to detect "unknown" languages, check probability thresholds or handle the error cases
    match factory.detect("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(lang) => println!("\tFrench text detected as: {} (closest match from ru/en)", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Show probabilities for the French text to see why it was classified as English
    match factory.get_probabilities("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(probs) => {
            println!("\tFrench text probabilities:");
            for lang in probs {
                println!("\t\t{}: {:.3}", lang.lang.unwrap_or_default(), lang.prob);
            }
        }
        Err(e) => println!("Probability error: {:?}", e),
    }
}

examples/extend_default/main.rs (line 88)

fn main() {
    // Load language profiles from the crate's profiles directory
    let profiles_dir = DetectorFactory::get_default_profiles_path();

    println!("Read all default JSON profiles from {}", profiles_dir.display());

    let mut lang_profiles = vec![];
    // Load every profile in the directory
    for entry in std::fs::read_dir(&profiles_dir).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        if !path.is_file() {
            continue;
        }
        let lang_json = LangProfileJson::new_from_file(path);
        match &lang_json {
            Ok(_) => println!("\tRead {} JSON profile", entry.file_name().to_string_lossy()),
            Err(e) => {
                println!("Error reading {} JSON profile: {:?}", entry.file_name().to_string_lossy(), e);
                return;
            }
        }
        let lang_profile = match LangProfile::from_json(lang_json.unwrap()) {
            Ok(profile) => profile,
            Err(e) => {
                println!("Error creating {} LangProfile: {}", entry.file_name().to_string_lossy(), e);
                return;
            }
        };
        lang_profiles.push(lang_profile);
    }

    println!("Adding all default languages profiles to the factory...");

    // Create an EMPTY factory
    let mut factory = DetectorFactory::new().build();

    // Get number of profiles to set final size
    let mut profile_count = lang_profiles.len();
    // Since we know that we are going to add another profile which is not in the default set
    // we increase the final size by 1
    profile_count += 1;

    println!("Final size (assuming we are going to extend default set) of languages array will be: {}", profile_count);
    
    for (i, profile) in lang_profiles.into_iter().enumerate() {
        let profile_name = if let Some(name) = &profile.name {
            name.clone()
        } else {
            "unknown".to_string()
        };
        println!("\tAdding profile: {} at index {}", profile_name, i);
        if let Err(e) = factory.add_profile(profile, i, profile_count) {
            println!("Error adding {} profile: {:?}", profile_name, e);
            return;
        }
    }

    // Load another profile (in documentation for generating profiles it is Sakha (Yakut) language - "sah")
    let sah_path = Path::new("./scripts/datasets/generated").join("sah_generated.json");
    let sah_json = LangProfileJson::new_from_file(sah_path);
    match &sah_json {
        Ok(_) => println!("Read Sakha JSON profile"),
        Err(e) => {
            println!("Error reading Sakha JSON profile: {:?}", e);
            return;
        }
    }
    let sah_profile = match LangProfile::from_json(sah_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Sakha LangProfile: {}", e);
            return;
        }
    };
    println!("Adding Sakha language profile to the factory");
    if let Err(e) = factory.add_profile(sah_profile, profile_count - 1, profile_count) {
        println!("Error adding Sakha profile: {:?}", e);
        return;
    }

    println!("Testing language detection...");
    // Test Russian text
    match factory.detect("В своём глазу бревна не замечает, а в чужом соломинку видит", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("He pays no attention to the plank in his own eye", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test Sakha (Yakut) text
    match factory.detect("Айаҕыттан тахсар сытыканы билбэт.", None) {
        Ok(lang) => println!("\tSakha text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

pub fn get_probabilities( &self, text: &str, alpha: Option<f64>, ) -> Result<Vec<Language>, DetectorError>

Shortcut method to get language probabilities from text in one call.

Arguments

• text - The text to analyze.
• alpha - Optional alpha smoothing parameter.

Returns

A vector of languages with their probabilities, sorted by probability descending.

Example

use langdetect_rs::detector_factory::DetectorFactory;

let factory = DetectorFactory::default().build();
let result = factory.get_probabilities("Hello world!", None);

Examples found in repository

examples/simple/main.rs (line 18)

fn main() {
    let factory = DetectorFactory::default().build();

    // let mut detector = factory.create(None);
    match factory.detect("War doesn't show who's right, just who's left.", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // let mut detector = factory.create(None);
    match factory.detect("Ein, zwei, drei, vier", None) {
        Ok(lang) => println!("Detected language: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    match factory.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // For reproducibility use a fixed seed within explicitly defined detector
    let mut detector = factory.create(None);
    detector.seed = Some(42);
    detector.append("Otec matka syn.");
    match detector.get_probabilities() {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Or you can set the seed for the factory itself and it will be inherited by detectors
    let factory_with_seed = DetectorFactory::default()
        .with_seed(Some(43))
        .build();
    match factory_with_seed.get_probabilities("Otec matka syn.", None) {
        Ok(probs) => println!("Language probabilities with seed: {:?}", probs),
        Err(e) => println!("Detection error: {:?}", e),
    }
}

examples/custom_profile/main.rs (line 91)

fn main() {
    // Create an empty factory
    let mut factory = DetectorFactory::new().build();

    // Load language profiles from the crate's profiles directory
    let profiles_dir = Path::new("./").join("profiles");

    println!("Read JSON profiles from {}", profiles_dir.display());

    // Load Russian profile
    let ru_json = LangProfileJson::new_from_file(profiles_dir.join("ru"));
    match &ru_json {
        Ok(_) => println!("\tRead Russian JSON profile"),
        Err(e) => {
            println!("Error reading Russian JSON profile: {:?}", e);
            return;
        }
    }
    let ru_profile = match LangProfile::from_json(ru_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating Russian LangProfile: {}", e);
            return;
        }
    };

    // Load English profile
    let en_json = LangProfileJson::new_from_file(profiles_dir.join("en"));
    match &en_json {
        Ok(_) => println!("\tRead English JSON profile"),
        Err(e) => {
            println!("Error reading English JSON profile: {:?}", e);
            return;
        }
    }
    let en_profile = match LangProfile::from_json(en_json.unwrap()) {
        Ok(profile) => profile,
        Err(e) => {
            println!("Error creating English LangProfile: {}", e);
            return;
        }
    };
    
    println!("Adding custom language profiles to the factory...");
    // Add profiles to the factory
    // Make sure to use correct language IDs as per your profiles
    // And provide correct FINAL size of languages array
    let final_size = 2; // Update this if you add more profiles
    if let Err(e) = factory.add_profile(ru_profile, 0, final_size
    ) {
        println!("Error adding Russian profile: {:?}", e);
        return;
    }
    println!("\tLoaded Russian profile");
    if let Err(e) = factory.add_profile(en_profile, 1, final_size) {
        println!("Error adding English profile: {:?}", e);
        return;
    }
    println!("\tLoaded English profile");

    println!("Factory loaded with {} languages: {:?}", factory.get_lang_list().len(), factory.get_lang_list());

    println!("Testing language detection...");

    // Test Russian text
    match factory.detect("Привет, меня зовут Дима, и я разработчик", None) {
        Ok(lang) => println!("\tRussian text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test English text
    match factory.detect("Hello world! My name is Dima and I am a developer", None) {
        Ok(lang) => println!("\tEnglish text detected as: {}", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Test French text (will be detected as the closest match from available languages)
    // IMPORTANT: The algorithm always returns the best guess from loaded languages, never fails
    // EXCEPTIONS: Returns error if no recognizable n-grams found, or "unknown" if all probabilities ≤ 0.1
    // If you want to detect "unknown" languages, check probability thresholds or handle the error cases
    match factory.detect("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(lang) => println!("\tFrench text detected as: {} (closest match from ru/en)", lang),
        Err(e) => println!("Detection error: {:?}", e),
    }

    // Show probabilities for the French text to see why it was classified as English
    match factory.get_probabilities("Bonjour tout le monde! Je m'appelle Dima et je suis développeur", None) {
        Ok(probs) => {
            println!("\tFrench text probabilities:");
            for lang in probs {
                println!("\t\t{}: {:.3}", lang.lang.unwrap_or_default(), lang.prob);
            }
        }
        Err(e) => println!("Probability error: {:?}", e),
    }
}

pub fn load_profile<P: AsRef<Path>>( &mut self, profile_directory: P, ) -> Result<(), String>

Loads all language profiles from a directory of JSON files.

Arguments

• profile_directory - Path to directory containing JSON profile files.

Returns

Ok(()) on success, or an error string on failure.

Example

use langdetect_rs::detector_factory::DetectorFactory;

let mut factory = DetectorFactory::new().build();
factory.load_profile("profiles/").unwrap();

Trait Implementations

impl Clone for DetectorFactory

fn clone(&self) -> DetectorFactory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.