Use a builder to build up the indicator while compiling the table

Author: egli

src/translator.rs

@@ -6,7 +6,7 @@ use trie::Trie;
 use crate::parser::{AnchoredRule, Attribute, Braille, Direction, Rule, dots_to_unicode, fallback};
 
 use self::trie::Boundary;
-use indication::{Indication, NumericIndicator};
+use indication::{Indication, NumericIndicator, NumericIndicatorBuilder};
 
 mod boundaries;
 mod indication;
@@ -181,7 +181,7 @@ pub struct TranslationTable {
     character_attributes: CharacterAttributes,
     translations: Trie,
     match_patterns: MatchPatterns,
-    indicator_signs: IndicatorSigns,
+    numeric_indicator: NumericIndicator,
     direction: Direction,
 }
 
@@ -195,17 +195,20 @@ impl TranslationTable {
         let mut character_attributes = CharacterAttributes::new();
         let mut translations = Trie::new();
         let mut match_patterns = MatchPatterns::new();
-        let mut indicator_signs = IndicatorSigns::new();
+        let mut numeric_indicator_builder = NumericIndicatorBuilder::new();
 
         let rules: Vec<AnchoredRule> = rules
             .into_iter()
             .filter(|r| r.rule.is_direction(direction))
             .collect();
 
-	// FIXME: For some unknown reason the litdigit rule seems to have precedence over the digit
-	// rule. Since they both want to define digits in the same character_definitions slot we
-	// need to make sure litdigits rules are handled before digit rules
-        for rule in rules.iter().filter(|r| matches!(r.rule, Rule::Litdigit { .. })) {
+        // FIXME: For some unknown reason the litdigit rule seems to have precedence over the digit
+        // rule. Since they both want to define digits in the same character_definitions slot we
+        // need to make sure litdigits rules are handled before digit rules
+        for rule in rules
+            .iter()
+            .filter(|r| matches!(r.rule, Rule::Litdigit { .. }))
+        {
             match &rule.rule {
                 Rule::Litdigit {
                     character, dots, ..
@@ -215,9 +218,9 @@ impl TranslationTable {
                     character_definitions.insert(*character, translation);
                     character_attributes.insert(Attribute::Digit, *character);
                 }
-		_ => (),
-	    }
-	}
+                _ => (),
+            }
+        }
 
         // The compilation is done in two passes: The first pass simply collects all character
         // definitions and character attributes, so that they are then known in a second pass, e.g.
@@ -296,10 +299,19 @@ impl TranslationTable {
                     // TODO: should the math opcode not also define a CharacterAttribute?
                 }
                 Rule::Numsign { dots } => {
-                    indicator_signs.insert(Indication::NumericStart, dots_to_unicode(dots));
+                    numeric_indicator_builder =
+                        numeric_indicator_builder.numsign(&dots_to_unicode(dots));
                 }
                 Rule::Nonumsign { dots } => {
-                    indicator_signs.insert(Indication::NumericEnd, dots_to_unicode(dots));
+                    numeric_indicator_builder =
+                        numeric_indicator_builder.nonumsign(&dots_to_unicode(dots));
+                }
+                Rule::Numericnocontchars { chars } => {
+                    numeric_indicator_builder =
+                        numeric_indicator_builder.numericnocontchars(&chars);
+                }
+                Rule::Numericmodechars { chars } => {
+                    numeric_indicator_builder = numeric_indicator_builder.numericmodechars(&chars);
                 }
                 // display rules are ignored for translation tables
                 Rule::Display { .. } => (),
@@ -414,14 +426,19 @@ impl TranslationTable {
             }
         }
 
+        numeric_indicator_builder = numeric_indicator_builder.numeric_characters(
+            character_attributes
+                .get(Attribute::Digit)
+                .unwrap_or(HashSet::default()),
+        );
         Ok(TranslationTable {
             undefined,
             direction,
             character_definitions,
             character_attributes,
             translations,
             match_patterns,
-            indicator_signs,
+            numeric_indicator: numeric_indicator_builder.build(),
         })
     }
 
@@ -437,32 +454,23 @@ impl TranslationTable {
         let mut delayed_translations: Vec<Translation> = Vec::new();
         let mut chars = input.chars();
         let mut prev: Option<char> = None;
-        let mut indicator = NumericIndicator::new(
-            self.character_attributes
-                .get(Attribute::Digit)
-                .unwrap_or(HashSet::default()),
-            self.indicator_signs.get(Indication::NumericStart).cloned(),
-            self.indicator_signs.get(Indication::NumericEnd).cloned(),
-        );
+        // FIXME: the following seems weird, but the indicator is a mutable state machine. Since
+        // self (the translation table) is immutable we build a mutable copy of the indicator for
+        // each translation
+        let mut numeric_indicator = self.numeric_indicator.clone();
 
         loop {
             // Check if there is a need for an indication
-            if let Some(indication) = indicator.next(chars.as_str()) {
+            if let Some(indication) = numeric_indicator.next(chars.as_str()) {
                 match indication {
                     Indication::NumericStart => translations.push(Translation::new(
                         "".to_string(),
-                        self.indicator_signs
-                            .get(Indication::NumericStart)
-                            .cloned()
-                            .unwrap(),
+                        numeric_indicator.start_indicator().unwrap(),
                         1,
                     )),
                     Indication::NumericEnd => translations.push(Translation::new(
                         "".to_string(),
-                        self.indicator_signs
-                            .get(Indication::NumericEnd)
-                            .cloned()
-                            .unwrap(),
+                        numeric_indicator.end_indicator().unwrap(),
                         1,
                     )),
                     _ => (),

src/translator/indication.rs

@@ -26,39 +26,90 @@ pub enum Indication {
 }
 
 /// Possible states for the [NumericIndicator] state machine
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 enum State {
     Default,
     Numeric,
 }
 
+#[derive(Debug)]
+pub struct NumericIndicatorBuilder(NumericIndicator);
+
+impl NumericIndicatorBuilder {
+    pub fn new() -> Self {
+        NumericIndicatorBuilder(NumericIndicator {
+            state: State::Default,
+            numeric_chars: HashSet::default(),
+            extra_numeric_chars: HashSet::default(),
+            start_indicator: None,
+            end_indicator: None,
+            terminating_chars: HashSet::default(),
+        })
+    }
+
+    pub fn build(self) -> NumericIndicator {
+        self.0
+    }
+
+    pub fn start_indicator(mut self, s: &str) -> Self {
+        self.0.start_indicator = Some(s.to_string());
+        self
+    }
+
+    pub fn numsign(mut self, s: &str) -> Self {
+        self.0.start_indicator = Some(s.to_string());
+        self
+    }
+
+    pub fn nonumsign(mut self, s: &str) -> Self {
+        self.0.end_indicator = Some(s.to_string());
+        self
+    }
+
+    pub fn numericnocontchars(mut self, s: &str) -> Self {
+        self.0.terminating_chars = HashSet::from_iter(s.chars());
+        self
+    }
+
+    pub fn numericmodechars(mut self, s: &str) -> Self {
+        self.0.extra_numeric_chars = HashSet::from_iter(s.chars());
+        self
+    }
+
+    pub fn numeric_characters(mut self, chars: HashSet<char>) -> Self {
+        self.0.numeric_chars = chars;
+        self
+    }
+}
+
 /// A very simple state machine to keep track when an numeric indication is
 /// required
-#[derive(Debug)]
+///
+/// The state is changed to `State::Numeric` as soon as a character is
+/// encountered that is a member of the set of `numeric_chars`. And if a
+/// character is encountered that is neither in the set of `numeric_chars` nor
+/// in the set of `extra_numeric_chars` the state is changed to
+/// `State::Default`.
+///
+/// An indication for a start is emitted if the `start_indicator` is not None.
+/// Indication for the end is emitted if `end_indicator` is not None and the
+/// character encountered is in the set of terminating_chars.
+#[derive(Debug, Clone)]
 pub struct NumericIndicator {
     state: State,
     /// Characters that will trigger a state change to the [State::Numeric] mode
     numeric_chars: HashSet<char>,
+    /// Characters that will prevent a state change to the [State::Default] mode
+    extra_numeric_chars: HashSet<char>,
     /// The characters to indicate the start of a sequence of numerical characters
     start_indicator: Option<String>,
     /// The characters to indicate the end of a sequence of numerical characters
     end_indicator: Option<String>,
+    /// Characters that will trigger an [`Indication::NumericEndend`] indication
+    terminating_chars: HashSet<char>,
 }
 
 impl NumericIndicator {
-    pub fn new(
-        numeric_chars: HashSet<char>,
-        start_indicator: Option<String>,
-        end_indicator: Option<String>,
-    ) -> Self {
-        Self {
-            state: State::Default,
-            numeric_chars,
-            start_indicator,
-            end_indicator,
-        }
-    }
-
     /// The transition method of the numeric indication state machine.
     ///
     /// Takes a string slice to examine the next character(s). Typically the
@@ -93,6 +144,13 @@ impl NumericIndicator {
             _ => None,
         }
     }
+
+    pub fn start_indicator(&self) -> Option<String> {
+        self.start_indicator.clone()
+    }
+    pub fn end_indicator(&self) -> Option<String> {
+        self.end_indicator.clone()
+    }
 }
 
 #[cfg(test)]
@@ -102,8 +160,11 @@ mod tests {
     #[test]
     fn indicator_test() {
         let numeric_chars: HashSet<char> = HashSet::from(['1', '2', '3']);
-        let mut indicator =
-            NumericIndicator::new(numeric_chars, Some('⠼'.to_string()), Some("⠰".to_string()));
+        let builder = NumericIndicatorBuilder::new()
+            .numeric_characters(numeric_chars)
+            .numsign("⠼")
+            .nonumsign("⠰");
+        let mut indicator = builder.build();
         assert_eq!(indicator.next("ab12 a".into()), None);
         assert_eq!(indicator.next("b12 a".into()), None);
         assert_eq!(