rust: add NcPixel methods.

- finish updating the functions.

rust/src/pixel.rs

@@ -9,19 +9,20 @@
 //
 // functions manually reimplemented: 10
 // ------------------------------------------
-// (+) implement : 10 /  0
+// (+) done: 10 /  0
-// (#) unit tests:  0 / 10
+// (#) test:  0
+// (W) wrap: 10
 // ------------------------------------------
-// + ncpixel
+//W+ ncpixel
-// + ncpixel_a
+//W+ ncpixel_a
-// + ncpixel_b
+//W+ ncpixel_b
-// + ncpixel_g
+//W+ ncpixel_g
-// + ncpixel_r
+//W+ ncpixel_r
-// + ncpixel_set_a
+//W+ ncpixel_set_a
-// + ncpixel_set_b
+//W+ ncpixel_set_b
-// + ncpixel_set_g
+//W+ ncpixel_set_g
-// + ncpixel_set_r
+//W+ ncpixel_set_r
-// + ncpixel_set_rgb8
+//W+ ncpixel_set_rgb8
 
 use crate::NcColor;
 
@@ -55,8 +56,8 @@ pub type NcPixel = u32;
 
 /// Constructs a libav-compatible ABGR pixel from [NcColor] RGB components.
 #[inline]
-pub const fn ncpixel(r: NcColor, g: NcColor, b: NcColor) -> NcPixel {
+pub const fn ncpixel(red: NcColor, green: NcColor, blue: NcColor) -> NcPixel {
-    0xff000000 as NcPixel | r as NcPixel | (b as NcPixel) << 8 | (g as NcPixel) << 16
+    0xff000000 as NcPixel | red as NcPixel | (blue as NcPixel) << 8 | (green as NcPixel) << 16
 }
 
 /// Extracts the 8-bit alpha component from an ABGR pixel.
@@ -65,15 +66,15 @@ pub const fn ncpixel_a(pixel: NcPixel) -> NcColor {
     ((pixel.to_le() & 0xff000000) >> 24) as NcColor
 }
 
-/// Extracts the 8 bit green component from an ABGR pixel.
+/// Extracts the 8 bit blue component from an ABGR pixel.
 #[inline]
-pub const fn ncpixel_g(pixel: NcPixel) -> NcColor {
+pub const fn ncpixel_b(pixel: NcPixel) -> NcColor {
     ((pixel.to_le() & 0x00ff0000) >> 16) as NcColor
 }
 
-/// Extracts the 8 bit blue component from an ABGR pixel.
+/// Extracts the 8 bit green component from an ABGR pixel.
 #[inline]
-pub const fn ncpixel_b(pixel: NcPixel) -> NcColor {
+pub const fn ncpixel_g(pixel: NcPixel) -> NcColor {
     ((pixel.to_le() & 0x0000ff00) >> 8) as NcColor
 }
 
@@ -89,18 +90,18 @@ pub fn ncpixel_set_a(pixel: &mut NcPixel, alpha: NcColor) {
     *pixel = (((*pixel).to_le() & 0x00ffffff) | ((alpha as NcPixel) << 24)).to_le();
 }
 
-/// Sets the 8-bit green component of an ABGR pixel.
-#[inline]
-pub fn ncpixel_set_g(pixel: &mut NcPixel, green: NcColor) {
-    *pixel = (((*pixel).to_le() & 0xff00ffff) | ((green as NcPixel) << 16)).to_le();
-}
-
 /// Sets the 8-bit blue component of an ABGR pixel.
 #[inline]
 pub fn ncpixel_set_b(pixel: &mut NcPixel, blue: NcColor) {
     *pixel = (((*pixel).to_le() & 0xffff00ff) | ((blue as NcPixel) << 8)).to_le();
 }
 
+/// Sets the 8-bit green component of an ABGR pixel.
+#[inline]
+pub fn ncpixel_set_g(pixel: &mut NcPixel, green: NcColor) {
+    *pixel = (((*pixel).to_le() & 0xff00ffff) | ((green as NcPixel) << 16)).to_le();
+}
+
 /// Sets the 8-bit red component of an ABGR pixel.
 #[inline]
 pub fn ncpixel_set_r(pixel: &mut NcPixel, red: NcColor) {
@@ -114,3 +115,72 @@ pub fn ncpixel_set_rgb8(pixel: &mut NcPixel, red: NcColor, green: NcColor, blue:
     ncpixel_set_g(pixel, green);
     ncpixel_set_b(pixel, blue);
 }
+
+/// Enables the [NcPixel] methods.
+//
+// NOTE: waiting for: https://github.com/rust-lang/rust/issues/56546
+// to move doc comments to the trait and appear unhidden at the implementation.
+pub trait NcPixelMethods {
+    fn new(r: NcColor, g: NcColor, b: NcColor) -> NcPixel;
+    fn a(self) -> NcColor;
+    fn b(self) -> NcColor;
+    fn g(self) -> NcColor;
+    fn r(self) -> NcColor;
+    fn set_a(&mut self, green: NcColor);
+    fn set_b(&mut self, blue: NcColor);
+    fn set_g(&mut self, green: NcColor);
+    fn set_r(&mut self, red: NcColor);
+    fn set_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor);
+}
+
+impl NcPixelMethods for NcPixel {
+    /// Constructs a libav-compatible ABGR pixel from [NcColor] RGB components.
+    fn new(red: NcColor, green: NcColor, blue: NcColor) -> NcPixel {
+        ncpixel(red, green, blue)
+    }
+
+    /// Extracts the 8-bit alpha component from an ABGR pixel.
+    fn a(self) -> NcColor {
+        ncpixel_a(self)
+    }
+
+    /// Extracts the 8 bit blue component from an ABGR pixel.
+    fn b(self) -> NcColor {
+        ncpixel_b(self)
+    }
+
+    /// Extracts the 8 bit green component from an ABGR pixel.
+    fn g(self) -> NcColor {
+        ncpixel_g(self)
+    }
+
+    /// Extracts the 8 bit red component from an ABGR pixel.
+    fn r(self) -> NcColor {
+        ncpixel_r(self)
+    }
+
+    /// Sets the 8-bit alpha component of an ABGR pixel.
+    fn set_a(&mut self, alpha: NcColor) {
+        ncpixel_set_a(self, alpha)
+    }
+
+    /// Sets the 8-bit green component of an ABGR pixel.
+    fn set_g(&mut self, green: NcColor) {
+        ncpixel_set_b(self, green)
+    }
+
+    /// Sets the 8-bit blue component of an ABGR pixel.
+    fn set_b(&mut self, blue: NcColor) {
+        ncpixel_set_b(self, blue)
+    }
+
+    /// Sets the 8-bit red component of an ABGR pixel.
+    fn set_r(&mut self, red: NcColor) {
+        ncpixel_set_r(self, red)
+    }
+
+    /// Sets the [NcColor] RGB components of an ABGR pixel.
+    fn set_rgb8(&mut self, red: NcColor, green: NcColor, blue: NcColor) {
+        ncpixel_set_rgb8(self, red, green, blue);
+    }
+}