Pack color name into DynamicColor flags

A rough implementation of the ideas in
linebender#26 (comment).

The ergonomics require some tweaking, and perhaps the performance too,
though it should be easy to write this in a form where the compiler can
easily optimize the bitwise operations. I haven't verified what the
compiler does with the current form.

An alternative is to keep `Missing` unchanged, and add something similar
to `Flags` as a new field on `DynamicColor`. But adding a new field
makes constructing `DynamicColor` a bit less ergonomic.

Author: tomcur

color/src/dynamic.rs

@@ -5,7 +5,8 @@
 
 use crate::{
     color::{add_alpha, fixup_hues_for_interpolate, split_alpha},
-    AlphaColor, ColorSpace, ColorSpaceLayout, ColorSpaceTag, HueDirection, LinearSrgb, Missing,
+    AlphaColor, ColorSpace, ColorSpaceLayout, ColorSpaceTag, Flags, HueDirection, LinearSrgb,
+    Missing,
 };
 
 /// A color with a color space tag decided at runtime.
@@ -29,8 +30,9 @@ use crate::{
 pub struct DynamicColor {
     /// The color space.
     pub cs: ColorSpaceTag,
-    /// A bitmask of missing components.
-    pub missing: Missing,
+    /// The state of this color, tracking whether it has missing components and how it was
+    /// constructed. See the documentation of [`Flags`] for more information.
+    pub flags: Flags,
     /// The components.
     ///
     /// The first three components are interpreted according to the
@@ -39,6 +41,11 @@ pub struct DynamicColor {
     pub components: [f32; 4],
 }
 
+// `DynamicColor` was carefully packed. Ensure its size doesn't accidentally change.
+const _: () = if size_of::<DynamicColor>() != 20 {
+    panic!("`DynamicColor` size changed");
+};
+
 /// An intermediate struct used for interpolating between colors.
 ///
 /// This is the return value of [`DynamicColor::interpolate`].
@@ -75,7 +82,7 @@ impl DynamicColor {
         if let Some(cs) = CS::TAG {
             Self {
                 cs,
-                missing: Missing::default(),
+                flags: Flags::default(),
                 components: color.components,
             }
         } else {
@@ -95,33 +102,36 @@ impl DynamicColor {
             let (opaque, alpha) = split_alpha(self.components);
             let mut components = add_alpha(self.cs.convert(cs, opaque), alpha);
             // Reference: §12.2 of Color 4 spec
-            let missing = if !self.missing.is_empty() {
+            let missing = if self.flags.has_missing() {
                 if self.cs.same_analogous(cs) {
                     for (i, component) in components.iter_mut().enumerate() {
-                        if self.missing.contains(i) {
+                        if self.flags.missing(i) {
                             *component = 0.0;
                         }
                     }
-                    self.missing
+                    Flags::from_missing(self.flags.extract_missing())
                 } else {
-                    let mut missing = self.missing & Missing::single(3);
-                    if self.cs.h_missing(self.missing) {
-                        cs.set_h_missing(&mut missing, &mut components);
+                    let mut flags = Flags::from_missing(
+                        self.flags.extract_missing()
+                            & Flags::from_single_missing(3).extract_missing(),
+                    );
+                    if self.cs.h_missing(self.flags) {
+                        cs.set_h_missing(&mut flags, &mut components);
                     }
-                    if self.cs.c_missing(self.missing) {
-                        cs.set_c_missing(&mut missing, &mut components);
+                    if self.cs.c_missing(self.flags) {
+                        cs.set_c_missing(&mut flags, &mut components);
                     }
-                    if self.cs.l_missing(self.missing) {
-                        cs.set_l_missing(&mut missing, &mut components);
+                    if self.cs.l_missing(self.flags) {
+                        cs.set_l_missing(&mut flags, &mut components);
                     }
-                    missing
+                    Flags::from_missing(self.flags.extract_missing())
                 }
             } else {
-                Missing::default()
+                Flags::default()
             };
             let mut result = Self {
                 cs,
-                missing,
+                flags: missing,
                 components,
             };
             result.powerless_to_missing();
@@ -135,9 +145,9 @@ impl DynamicColor {
     /// a corresponding component which is 0. This method restores that
     /// invariant after manipulation which might invalidate it.
     fn zero_missing_components(mut self) -> Self {
-        if !self.missing.is_empty() {
+        if self.flags.has_missing() {
             for (i, component) in self.components.iter_mut().enumerate() {
-                if self.missing.contains(i) {
+                if self.flags.missing(i) {
                     *component = 0.0;
                 }
             }
@@ -154,7 +164,7 @@ impl DynamicColor {
         let components = self.cs.scale_chroma(opaque, scale);
         Self {
             cs: self.cs,
-            missing: self.missing,
+            flags: self.flags,
             components: add_alpha(components, alpha),
         }
         .zero_missing_components()
@@ -171,15 +181,15 @@ impl DynamicColor {
         let alpha = alpha.clamp(0., 1.);
         Self {
             cs: self.cs,
-            missing: self.missing,
+            flags: self.flags,
             components: add_alpha(components, alpha),
         }
     }
 
     fn premultiply_split(self) -> ([f32; 3], f32) {
         // Reference: §12.3 of Color 4 spec
         let (opaque, alpha) = split_alpha(self.components);
-        let premul = if alpha == 1.0 || self.missing.contains(3) {
+        let premul = if alpha == 1.0 || self.flags.missing(3) {
             opaque
         } else {
             self.cs.layout().scale(opaque, alpha)
@@ -195,8 +205,7 @@ impl DynamicColor {
         if self.cs.layout() != ColorSpaceLayout::Rectangular
             && self.components[1] < POWERLESS_EPSILON
         {
-            self.cs
-                .set_h_missing(&mut self.missing, &mut self.components);
+            self.cs.set_h_missing(&mut self.flags, &mut self.components);
         }
     }
 
@@ -214,12 +223,14 @@ impl DynamicColor {
     ) -> Interpolator {
         let mut a = self.convert(cs);
         let mut b = other.convert(cs);
-        let missing = a.missing & b.missing;
-        if self.missing != other.missing {
+        let a_missing = a.flags.extract_missing();
+        let b_missing = b.flags.extract_missing();
+        let missing = a_missing & b_missing;
+        if a_missing != b_missing {
             for i in 0..4 {
-                if (a.missing & !b.missing).contains(i) {
+                if (a_missing & !b_missing).contains(i) {
                     a.components[i] = b.components[i];
-                } else if (!a.missing & b.missing).contains(i) {
+                } else if (!a_missing & b_missing).contains(i) {
                     b.components[i] = a.components[i];
                 }
             }
@@ -262,7 +273,7 @@ impl DynamicColor {
         let [x, y, z, a] = self.components;
         Self {
             cs: self.cs,
-            missing: self.missing,
+            flags: Flags::from_missing(self.flags.extract_missing()),
             components: f(x, y, z, a),
         }
         .zero_missing_components()
@@ -320,7 +331,7 @@ impl Interpolator {
         let components = add_alpha(opaque, alpha);
         DynamicColor {
             cs: self.cs,
-            missing: self.missing,
+            flags: Flags::from_missing(self.missing),
             components,
         }
     }

color/src/gradient.rs

@@ -54,11 +54,11 @@ pub fn gradient<CS: ColorSpace>(
     tolerance: f32,
 ) -> GradientIter<CS> {
     let interpolator = color0.interpolate(color1, interp_cs, direction);
-    if !color0.missing.is_empty() {
+    if color0.flags.has_missing() {
         color0 = interpolator.eval(0.0);
     }
     let target0 = color0.to_alpha_color().premultiply();
-    if !color1.missing.is_empty() {
+    if color1.flags.has_missing() {
         color1 = interpolator.eval(1.0);
     }
     let target1 = color1.to_alpha_color().premultiply();

color/src/lib.rs

@@ -40,7 +40,7 @@ pub use colorspace::{
 };
 pub use dynamic::{DynamicColor, Interpolator};
 pub use gradient::{gradient, GradientIter};
-pub use missing::Missing;
+pub use missing::{Flags, Missing};
 pub use parse::{parse_color, ParseError};
 pub use tag::ColorSpaceTag;
 

color/src/missing.rs

@@ -3,27 +3,124 @@
 
 //! A simple bitset.
 
-/// A simple bitset for representing missing components.
+use crate::x11_colors;
+
+/// Flags indicating [`DynamicColor`](crate::DynamicColor) state.
+///
+/// This tracks missing color components of a `DynamicColor` and details of how a `DynamicColor`
+/// was constructed.
+///
+/// The "missing" flags indicate whether a specific color component is missing. The "named" flag
+/// represents whether the dynamic color was generated from one of the named colors in [CSS Color
+/// Module Level 4 § 6.1][css-named-colors] or named color space functions in [CSS Color Module
+/// Level 4 § 4.1][css-named-color-spaces].
+///
+/// The latter is primarily useful for serializing.
+///
+/// [css-named-colors]: https://www.w3.org/TR/css-color-4/#named-colors
+/// [css-named-color-spaces]: https://www.w3.org/TR/css-color-4/#color-syntax
+//
+// The flags are tracked with 16 bits. The first three are for missing components, the fourth
+// indicates whether the color was generated from a named color or named color space function. The
+// remaining bits indicate the named color.
+#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Flags(u16);
+
+/// Missing color components, extracted from [`Flags`]. Some bitwise operations are implemented on
+/// this type, making certain manipulations more ergonomic.
 #[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
 pub struct Missing(u8);
 
+impl Flags {
+    /// Construct flags indicating the given color component is missing. The component index must
+    /// be 0, 1, 2, or 3.
+    pub const fn from_single_missing(ix: usize) -> Self {
+        debug_assert!(ix <= 3, "color component index must be 0, 1, 2 or 3");
+        Self(1 << ix)
+    }
+
+    /// Construct flags with the given missing components.
+    pub const fn from_missing(missing: Missing) -> Self {
+        Self(missing.0 as u16)
+    }
+
+    /// Construct flags indicating the color was generated from one of the named colors.
+    pub(crate) fn set_from_named_color(&mut self, name_ix: u16) {
+        let missing = self.0 & 0b1111;
+        self.0 = missing | 1 << 4 | (name_ix + 1) << 5;
+    }
+
+    /// Construct flags indicating the color was generated from one of the named color space
+    /// functions.
+    pub(crate) fn set_from_named_color_space(&mut self) {
+        let missing = self.0 & 0b1111;
+        self.0 = missing | 1 << 4;
+    }
+
+    /// Set the given component as missing.
+    pub fn set_missing(&mut self, ix: usize) {
+        self.0 |= Self::from_single_missing(ix).0;
+    }
+
+    /// Extract the missing components from the flags.
+    #[inline]
+    pub fn extract_missing(self) -> Missing {
+        Missing((self.0 & 0b1111) as u8)
+    }
+
+    /// Returns `true` if the flags indicate the given color component is missing. The component
+    /// index must be 0, 1 or 2.
+    #[inline]
+    pub fn missing(self, ix: usize) -> bool {
+        self.extract_missing().contains(ix)
+    }
+
+    /// Returns `true` if at least one component is missing.
+    #[inline]
+    pub fn has_missing(self) -> bool {
+        !self.extract_missing().is_empty()
+    }
+
+    /// Returns `true` if the flags indicate the color was generated from a named color or named
+    /// color space function.
+    pub fn named(self) -> bool {
+        self.0 & 1 << 4 != 0
+    }
+
+    /// If the color was constructed from a named color, returns that name.
+    ///
+    /// See also [`parse_color`][crate::parse_color].
+    pub fn color_name(self) -> Option<&'static str> {
+        let name_ix = self.0 >> 5;
+        if name_ix == 0 {
+            None
+        } else {
+            Some(x11_colors::NAMES[name_ix as usize - 1])
+        }
+    }
+}
+
 impl Missing {
     /// Returns `true` if the set contains the component index.
+    #[inline]
     pub fn contains(self, ix: usize) -> bool {
         (self.0 & (1 << ix)) != 0
     }
 
     /// Adds a component index to the set.
+    #[inline]
     pub fn insert(&mut self, ix: usize) {
         self.0 |= 1 << ix;
     }
 
     /// The set containing a single component index.
+    #[inline]
     pub fn single(ix: usize) -> Self {
         Self(1 << ix)
     }
 
     /// Returns `true` if the set contains no indices.
+    #[inline]
     pub fn is_empty(self) -> bool {
         self.0 == 0
     }