Added simple test giving a report of the generic/specialized op impls.

src/op/dispatch.rs

@@ -132,6 +132,73 @@ lazy_static::lazy_static! {
     pub static ref DISPATCH: KahloDispatch<'static> = KahloDispatch::default();
 }
 
+// generating operation acceleration matrices
+#[cfg(test)]
+mod accel_impls {
+    use crate::formats::*;
+
+    use super::{UnaryDispatch, DISPATCH, BinaryDispatch};
+
+    fn matrix_unary<T>(name: &'static str, op: &UnaryDispatch<T>) {
+        fn cell<F: PixelFormatSpec, T>(op: &UnaryDispatch<T>) -> &'static str {
+            if op.is_generic::<F>() { "-" } else { "X" }
+        }
+
+        println!("\n\n{name}:");
+        println!("-------+---");
+        println!("A8     | {}", cell::<A8, _>(op));
+        println!("Abgr32 | {}", cell::<Abgr32, _>(op));
+        println!("Bgr24  | {}", cell::<Bgr24, _>(op));
+        println!("Bgr32  | {}", cell::<Bgr32, _>(op));
+        println!("Rgb24  | {}", cell::<Rgb24, _>(op));
+        println!("Rgb32  | {}", cell::<Rgb32, _>(op));
+        println!("Rgba32 | {}", cell::<Rgba32, _>(op));
+    }
+
+    fn matrix_binary<T>(name: &'static str, op: &BinaryDispatch<T>) {
+        fn row<F: PixelFormatSpec, T>(op: &BinaryDispatch<T>) -> String {
+            let mut ret = String::new();
+            if !op.is_generic::<F, A8>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Abgr32>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Bgr24>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Bgr32>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Rgb24>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Rgb32>() { ret += "|X" } else { ret += "|-" };
+            if !op.is_generic::<F, Rgba32>() { ret += "|X" } else { ret += "|-" };
+            ret
+        }
+
+        println!("\n\n{name}:");
+        // println!("        |        |        |        |        |        |        |        |");
+        // println!("   A8   | Abgr32 | Bgr24  | Bgr32  | Rgb24  | Rgb32  | Rgba32");
+
+        println!("          A         R ");
+        println!("          b B B R R g ");
+        println!("          g g g g g b ");
+        println!("          r r r b b a ");
+        println!("        A 3 2 3 2 3 3 ");
+        println!("        8 2 4 2 4 2 2 ");
+        println!("       +-+-+-+-+-+-+-+");
+        println!("A8     {}|", row::<A8,_>(op));
+        println!("Abgr32 {}|", row::<Abgr32, _>(op));
+        println!("Bgr24  {}|", row::<Bgr24, _>(op));
+        println!("Bgr32  {}|", row::<Bgr32, _>(op));
+        println!("Rgb24  {}|", row::<Rgb24, _>(op));
+        println!("Rgb32  {}|", row::<Rgb32, _>(op));
+        println!("Rgba32 {}|", row::<Rgba32, _>(op));
+    }
+
+    #[test]
+    fn generate_impl_matrices() {
+        matrix_binary("composite", &DISPATCH.composite);
+        matrix_binary("copy_from", &DISPATCH.copy_from);
+        matrix_unary("fill", &DISPATCH.fill);
+        matrix_unary("fill_region", &DISPATCH.fill_region);
+        matrix_unary("fill_region_masked", &DISPATCH.fill_region_masked);
+        matrix_unary("rectangle", &DISPATCH.rectangle);
+    }
+}
+
 // long but simple implementations
 
 impl<Params> UnaryDispatch<Params> {