Method replace_chars

src/speech.rs:2427–2483

Lookup unicode "pronunciation" of char. Note: TTS is not supported here (not needed and a little less efficient)

(&'r mut self, str: &str, mathml: Element<'c>)

    /// Lookup unicode "pronunciation" of char.
    /// Note: TTS is not supported here (not needed and a little less efficient)
    pub fn replace_chars(&'r mut self, str: &str, mathml: Element<'c>) -> Result<String> {
        if is_quoted_string(str) {
            return Ok(unquote_string(str).to_string());
        }
        let rules = self.speech_rules;
        let mut chars = str.chars();
        // in a string, avoid "a" -> "eigh", "." -> "point", etc
        if rules.translate_single_chars_only {
            let ch = chars.next().unwrap_or(' ');
            if chars.next().is_none() {
                // single char
                return replace_single_char(self, ch, mathml)
            } else {
                // more than one char -- fix up non-breaking space
                return Ok(str.replace('\u{00A0}', " ").replace(['\u{2061}', '\u{2062}', '\u{2063}', '\u{2064}'], ""));    
            }
        };

        let result = chars
            .map(|ch| replace_single_char(self, ch, mathml))
            .collect::<Result<Vec<String>>>()?
            .join("");
        return Ok( result );

        fn replace_single_char<'c, 's:'c, 'm, 'r>(rules_with_context: &'r mut SpeechRulesWithContext<'c,'s,'m>, ch: char, mathml: Element<'c>) -> Result<String> {
            let ch_as_u32 = ch as u32;
            let mut unicode = rules_with_context.speech_rules.unicode_short.borrow();
            let mut replacements = unicode.get( &ch_as_u32 );
            if replacements.is_none() {
                // see if it in the full unicode table (if it isn't loaded already)
                if rules_with_context.speech_rules.unicode_full.borrow().is_empty() {
                    info!("*** Loading full unicode {} for char '{}'/{:#06x}", rules_with_context.speech_rules.name, ch, ch_as_u32);
                    rules_with_context.speech_rules.read_unicode(None, false)?;
                    info!("# Unicode defs = {}/{}", rules_with_context.speech_rules.unicode_short.borrow().len(), rules_with_context.speech_rules.unicode_full.borrow().len());

                }
                unicode = rules_with_context.speech_rules.unicode_full.borrow();
                replacements = unicode.get( &ch_as_u32 );
                if replacements.is_none() {
                    // debug!("*** Did not find unicode {} for char '{}'/{:#06x}", rules_with_context.speech_rules.name, ch, ch_as_u32);
                    rules_with_context.translate_count = 0;     // not in loop
                    return Ok(String::from(ch));   // no replacement, so just return the char and hope for the best
                }
            };

            // map across all the parts of the replacement, collect them up into a Vec, and then concat them together
            let result = replacements.unwrap()
                        .iter()
                        .map(|replacement|
                            rules_with_context.replace(replacement, mathml)
                                    .chain_err(|| format!("Unicode replacement error: {}", replacement)) )
                        .collect::<Result<Vec<String>>>()?
                        .join(" ");
            rules_with_context.translate_count = 0;     // found a replacement, so not in a loop
            return Ok(result);
        }
    }
}