CharacterAttributes are a mapping from an attribute to a set of chars

Since a character can have multiple attributes

Author: egli

src/translator.rs

@@ -133,20 +133,16 @@ impl CharacterDefinition {
     }
 }
 
-#[derive(Debug)]
-struct CharacterAttributes(HashSet<(char, Attribute)>);
+#[derive(Debug, Default)]
+struct CharacterAttributes(HashMap<Attribute, HashSet<char>>);
 
 impl CharacterAttributes {
     fn new() -> Self {
-        Self(HashSet::new())
-    }
-
-    fn insert(&mut self, c: char, attribute: Attribute) {
-        self.0.insert((c, attribute));
+        Self(HashMap::new())
     }
 
-    fn contains(&self, c: char, attribute: Attribute) -> bool {
-        self.0.contains(&(c, attribute))
+    fn insert(&mut self, attribute: Attribute, c: char) {
+        self.0.entry(attribute).or_default().insert(c);
     }
 }
 
@@ -190,15 +186,15 @@ impl TranslationTable {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Space);
+                    character_attributes.insert(Attribute::Space, *character);
                 }
                 Rule::Punctuation {
                     character, dots, ..
                 } => {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Punctuation);
+                    character_attributes.insert(Attribute::Punctuation, *character);
                 }
                 Rule::Digit {
                     character, dots, ..
@@ -209,39 +205,39 @@ impl TranslationTable {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Digit);
+                    character_attributes.insert(Attribute::Digit, *character);
                 }
                 Rule::Letter {
                     character, dots, ..
                 } => {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Letter);
+                    character_attributes.insert(Attribute::Letter, *character);
                 }
                 Rule::Lowercase {
                     character, dots, ..
                 } => {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Lowercase);
+                    character_attributes.insert(Attribute::Lowercase, *character);
                 }
                 Rule::Uppercase {
                     character, dots, ..
                 } => {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Uppercase);
+                    character_attributes.insert(Attribute::Uppercase, *character);
                 }
                 Rule::Sign {
                     character, dots, ..
                 } => {
                     let translation =
                         Translation::new(character.to_string(), dots_to_unicode(dots), 1);
                     character_definitions.insert(*character, translation);
-                    character_attributes.insert(*character, Attribute::Sign);
+                    character_attributes.insert(Attribute::Sign, *character);
                 }
                 Rule::Math {
                     character, dots, ..