feat: hide Mapping implementation details

Author: Xiphoseer

crates/signum/src/chsets/code.rs

@@ -2,7 +2,7 @@
 
 use std::fmt;
 
-use super::encoding::Mapping;
+use super::encoding::{Mapping, MappingImpl};
 
 /// Write a mapping as rust code
 pub fn write_map<W: fmt::Write>(mapping: &Mapping, out: &mut W, ident: &str) -> fmt::Result {
@@ -17,7 +17,7 @@ pub fn write_map<W: fmt::Write>(mapping: &Mapping, out: &mut W, ident: &str) ->
             writeln!(out,)?;
         }
         writeln!(out, "]}};")?;
-    } else if let Mapping::Dynamic { chars } = mapping {
+    } else if let MappingImpl::Dynamic(chars) = &mapping.0 {
         writeln!(out, "pub const {ident}: ::signum::chsets::encoding::Mapping = signum::chsets::encoding::Mapping::BiLevel {{ chars: &[")?;
         for row in chars.chunks(16) {
             write!(out, "    ")?;

crates/signum/src/chsets/encoding/mod.rs

@@ -1,5 +1,5 @@
 //! # Mapping charsets to unicode
-use std::char::REPLACEMENT_CHARACTER;
+use std::{char::REPLACEMENT_CHARACTER, fmt};
 
 use displaydoc::Display;
 use nom::{
@@ -58,29 +58,29 @@ impl ToUnicode for [[char; 2]; 128] {
     }
 }
 
+#[derive(Clone, PartialEq)]
+pub(super) enum MappingImpl {
+    Single(Box<[char; 128]>),
+    Static(&'static [char; 128]),
+    Dynamic(Box<[SmallVec<[char; 2]>; 128]>),
+    BiLevel(&'static [&'static [char]; 128]),
+}
+
 /// A mapping table for a charset
-#[derive(Debug, Clone, PartialEq)]
-pub enum Mapping {
-    /// The corresponding unicode characters
-    Single {
-        /// characters in this variant
-        chars: Box<[char; 128]>,
-    },
-    /// The corresponding unicode characters
-    Static {
-        /// characters in this variant
-        chars: &'static [char; 128],
-    },
-    /// The corresponding unicode characters
-    Dynamic {
-        /// characters in this variant
-        chars: Box<[SmallVec<[char; 2]>; 128]>,
-    },
-    /// The corresponding unicode characters
-    BiLevel {
-        /// characters in this variant
-        chars: &'static [&'static [char]; 128],
-    },
+#[derive(Clone, PartialEq)]
+pub struct Mapping(pub(super) MappingImpl);
+
+impl fmt::Debug for Mapping {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s = f.debug_struct("Mapping");
+        match &self.0 {
+            MappingImpl::Single(chars) => s.field("chars", chars),
+            MappingImpl::Static(chars) => s.field("chars", chars),
+            MappingImpl::Dynamic(chars) => s.field("chars", chars),
+            MappingImpl::BiLevel(chars) => s.field("chars", chars),
+        };
+        s.finish()
+    }
 }
 
 impl Mapping {
@@ -96,52 +96,49 @@ impl Mapping {
 
     /// If the mapping can be encoded as a char array, return it
     pub fn as_char_array(&self) -> Option<&[char; 128]> {
-        match self {
-            Mapping::Single { chars } => Some(chars),
-            Mapping::Static { chars } => Some(chars),
-            Mapping::Dynamic { chars: _ } => None,
-            Mapping::BiLevel { chars: _ } => None,
+        match &self.0 {
+            MappingImpl::Single(chars) => Some(chars),
+            MappingImpl::Static(chars) => Some(chars),
+            MappingImpl::Dynamic(_) => None,
+            MappingImpl::BiLevel(_) => None,
         }
     }
-}
 
-impl ToUnicode for Mapping {
-    fn decode(&self, cval: u8) -> &[char] {
-        match self {
-            Mapping::Single { chars } => chars.decode(cval),
-            Mapping::Static { chars } => chars.decode(cval),
-            Mapping::Dynamic { chars } => chars.decode(cval),
-            Mapping::BiLevel { chars } => chars.decode(cval),
-        }
+    /// Create a new static instance
+    pub const fn new_static(map: &'static [char; 128]) -> Self {
+        Self(MappingImpl::Static(map))
     }
-}
 
-impl Mapping {
-    fn new(chars: [SmallVec<[char; 2]>; 128]) -> Self {
+    /// Create a new static instance
+    pub const fn new_static_slices(map: &'static [&'static [char]; 128]) -> Self {
+        Self(MappingImpl::BiLevel(map))
+    }
+
+    /// Create a new instance from an array of vectors
+    pub fn new(chars: [SmallVec<[char; 2]>; 128]) -> Self {
         if chars.iter().all(|c| c.len() <= 1) {
             let chars = chars.map(|v| v.first().copied().unwrap_or(REPLACEMENT_CHARACTER));
-            Self::Single {
-                chars: Box::new(chars),
-            }
+            Self(MappingImpl::Single(Box::new(chars)))
         } else {
-            Self::Dynamic {
-                chars: Box::new(chars),
-            }
+            Self(MappingImpl::Dynamic(Box::new(chars)))
         }
     }
 }
 
-/// The mapping for ANTIKRO
-pub const ANTIKRO_MAP: Mapping = Mapping::Static {
-    chars: &antikro::MAP,
-};
-
-impl Default for &'_ Mapping {
-    fn default() -> Self {
-        &ANTIKRO_MAP
+impl ToUnicode for Mapping {
+    fn decode(&self, cval: u8) -> &[char] {
+        match &self.0 {
+            MappingImpl::Single(chars) => chars.decode(cval),
+            MappingImpl::Static(chars) => chars.decode(cval),
+            MappingImpl::Dynamic(chars) => chars.decode(cval),
+            MappingImpl::BiLevel(chars) => chars.decode(cval),
+        }
     }
 }
 
+/// The mapping for ANTIKRO
+pub static ANTIKRO_MAP: Mapping = Mapping::new_static(&antikro::MAP);
+
 /// Error when parsing a mapping
 #[derive(Debug, Display, Error)]
 pub enum MappingError {

src/cli/sdoc/html.rs

@@ -7,7 +7,7 @@ use color_eyre::eyre;
 use signum::{
     chsets::{
         cache::{ChsetCache, DocumentFontCacheInfo},
-        encoding::ToUnicode,
+        encoding::{ToUnicode, ANTIKRO_MAP},
         metrics::widths::{self, standard_widths},
     },
     docs::tebu::{Char, Flags, Line, Style},
@@ -90,7 +90,7 @@ impl<'a> HtmlGen<'a> {
 
         for k in data {
             let cset = self.fc.cset(k.cset as usize);
-            let mapping = cset.and_then(|c| c.map()).unwrap_or_default();
+            let mapping = cset.and_then(|c| c.map()).unwrap_or(&ANTIKRO_MAP);
             let decoded = mapping.decode(k.cval);
 
             /*