From: MegaBrutal <code+git@megabrutal.com>
Date: Sun, 27 Nov 2022 05:30:00 +0000 (+0100)
Subject: Get rid of to_imageresult & to_canvasresult
X-Git-Url: http://git.megabrutal.com/?p=litoprism.git;a=commitdiff_plain;h=e5950c9ed1a670c80c270e63dc356f23626a00e3

Get rid of to_imageresult & to_canvasresult
---

diff --git a/src/main.rs b/src/main.rs
index 854f2c0..4e21a83 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -55,6 +55,12 @@ impl ResponseError for ImageError {
     }
 }
 
+impl From<image::ImageError> for ImageError {
+    fn from(e: image::ImageError) -> Self {
+        Self(e)
+    }
+}
+
 #[derive(Debug)]
 enum CanvasError {
     NotExists,
@@ -117,20 +123,6 @@ impl<T: AsPrimitive<u8> + Zero> Iterator for ToRgbIter<'_, T> {
     }
 }
 
-fn to_imageresult<T> (result: Result<T, image::ImageError>) -> Result<T, ImageError> {
-    match result {
-        Ok(v) => Ok(v),
-        Err(e) => Err(ImageError(e))
-    }
-}
-
-fn to_canvasresult<T: std::fmt::Debug> (result: Result<T, ImageError>) -> Result<T, CanvasError> {
-    match result {
-        Ok(v) => Ok(v),
-        Err(e) => Err(CanvasError::ImageError(e))
-    }
-}
-
 #[derive(Debug)]
 struct Canvas {
     pen: usize,
@@ -142,11 +134,11 @@ impl Canvas {
         Canvas { pen: 0, img: ImageBuffer::new(width, height) }
     }
 
-    fn from_image(img: RgbImage) -> Canvas {
+    /*fn from_image(img: RgbImage) -> Canvas {
         Canvas { pen: 0, img }
     }
 
-    /*fn replace(&self, img: RgbImage, pen: usize) -> Canvas {
+    fn replace(&self, img: RgbImage, pen: usize) -> Canvas {
         self.img = img;
         self.pen = pen;
         self
@@ -170,15 +162,15 @@ async fn greet(name: web::Path<String>, req: HttpRequest) -> impl Responder {
     format!("Hello {name}!\n{:?}", req.headers().get("user-agent"))
 }
 
-fn rgb_encode_to_canvas(mut canvas: Canvas, data: &mut dyn Iterator<Item = u8>) -> Result<Canvas, ImageError> {
-    let mut pixels = canvas.img.pixels_mut().skip(canvas.pen);
+fn rgb_encode_with_pen(img: &mut RgbImage, pen: usize, data: &mut dyn Iterator<Item = u8>) -> Result<usize, ImageError> {
+    let mut pixels = img.pixels_mut().skip(pen);
     let mut counter = 0;
 
     for sp in ToRgbIter::new(data) {
         let mut dp = match pixels.next() {
             Some(pixel) => pixel,
             None => {
-                pixels = canvas.img.pixels_mut().skip(0);
+                pixels = img.pixels_mut().skip(0);
                 pixels.next().ok_or_else(ImageError::dimension_error)?
             }
         };
@@ -186,11 +178,17 @@ fn rgb_encode_to_canvas(mut canvas: Canvas, data: &mut dyn Iterator<Item = u8>)
         counter += 1;
     }
 
+    Ok(counter)
+}
+
+fn rgb_encode_to_canvas(mut canvas: Canvas, data: &mut dyn Iterator<Item = u8>) -> Result<Canvas, CanvasError> {
+    let counter = rgb_encode_with_pen(&mut canvas.img, canvas.pen, data)?;
     Ok(canvas.advance_pen(counter))
 }
 
-fn rgb_encode(img: RgbImage, data: &mut dyn Iterator<Item = u8>) -> Result<RgbImage, ImageError> {
-    Ok(rgb_encode_to_canvas(Canvas::from_image(img), data)?.img)
+fn rgb_encode(mut img: RgbImage, data: &mut dyn Iterator<Item = u8>) -> Result<RgbImage, ImageError> {
+    rgb_encode_with_pen(&mut img, 0, data)?;
+    Ok(img)
 }
 
 fn apply_to_canvas<'a, F>(f: F, canvas_option: &'a mut Option<Canvas>, dimensions: Option<(u32, u32)>, data: &str) -> Result<&'a mut Canvas, CanvasError>
@@ -242,7 +240,7 @@ fn image_to_cursor(img: RgbImage, scale: u32) -> Result<Cursor<Vec<u8>>, ImageEr
 
     let mut cursor = Cursor::new(Vec::new());
     let img = resize(&img, dim_x, dim_y, FilterType::Nearest);
-    to_imageresult(write_buffer_with_format(&mut cursor, &img, dim_x, dim_y, ColorType::Rgb8, Png))?;
+    write_buffer_with_format(&mut cursor, &img, dim_x, dim_y, ColorType::Rgb8, Png)?;
     Ok(cursor)
 }
 
@@ -295,7 +293,7 @@ async fn img_pgen0(req: HttpRequest, canvas0: web::Data<Arc<Mutex<Canvas0>>>) ->
     let scale = 16;
     let img: RgbImage = ({
         let canvas_option = &mut *canvas0.lock().unwrap();
-        Ok(apply_to_canvas( |c, d| to_canvasresult(rgb_encode_to_canvas(c, d)), &mut canvas_option.0, None, data)?.img.clone())
+        Ok(apply_to_canvas( |c, d| rgb_encode_to_canvas(c, d), &mut canvas_option.0, None, data)?.img.clone())
     } as Result<RgbImage, CanvasError>)?;
     let cursor = image_to_cursor(img, scale)?;
     Ok(response_image!(cursor))
@@ -307,7 +305,7 @@ async fn img_pgen1(req: HttpRequest, path: web::Path<(u32, u32, u32)>, canvas1:
     let data = req.uri().path().split('/').nth(6).unwrap();
     let img: RgbImage = ({
         let canvas_option = &mut *canvas1.lock().unwrap();
-        Ok(apply_to_canvas( |c, d| to_canvasresult(rgb_encode_to_canvas(c, d)), &mut canvas_option.0, Some((dim_x, dim_y)), data)?.img.clone())
+        Ok(apply_to_canvas( |c, d| rgb_encode_to_canvas(c, d), &mut canvas_option.0, Some((dim_x, dim_y)), data)?.img.clone())
     } as Result<RgbImage, CanvasError>)?;
     let cursor = image_to_cursor(img, scale)?;
     Ok(response_image!(cursor))
@@ -322,7 +320,7 @@ async fn img_pgen2(req: HttpRequest, path: web::Path<(u32, u32, u32)>, canvas1:
     };
     let img: RgbImage = ({
         let canvas_option = &mut *canvas1.lock().unwrap();
-        Ok(apply_to_canvas( |c, d| to_canvasresult(rgb_encode_to_canvas(c, d)), &mut canvas_option.0, Some((dim_x, dim_y)), data)?.img.clone())
+        Ok(apply_to_canvas( |c, d| rgb_encode_to_canvas(c, d), &mut canvas_option.0, Some((dim_x, dim_y)), data)?.img.clone())
     } as Result<RgbImage, CanvasError>)?;
     let cursor = image_to_cursor(img, scale)?;
     Ok(response_image!(cursor))