Impl: Simple Parsing

src/main.rs

@@ -1,5 +1,7 @@
 use clap::Parser;
 
+use regex::Regex;
+
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
 struct Cli {
@@ -12,16 +14,16 @@ struct Cli {
     field_size: usize,
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 struct Playfield {
     fields: Vec<Vec<Field>>,
-    open_fields: Vec<u8>,
+    open_fields: Vec<u32>,
 }
 
 #[derive(Clone, PartialEq, Debug)]
 struct Field {
-    possible_values: Vec<u8>,
-    value: Option<u8>,
+    possible_values: Vec<u32>,
+    value: Option<u32>,
 }
 
 impl Playfield {
@@ -29,31 +31,30 @@ impl Playfield {
         let fields = vec![
             vec![
                 Field {
-                    possible_values: Vec::<u8>::new(),
+                    possible_values: Vec::<u32>::new(),
                     value: None
                 };
                 size
             ];
             size
         ];
-        let open_fields = Vec::<u8>::new();
         Self {
             fields,
-            open_fields,
+            open_fields: Vec::<u32>::new(),
         }
     }
 }
 
 impl Field {
-    fn new(value: u8) -> Field {
+    fn new(value: u32) -> Field {
         Self {
-            possible_values: Vec::<u8>::new(),
+            possible_values: Vec::<u32>::new(),
             value: Some(value),
         }
     }
     fn default() -> Field {
         Self {
-            possible_values: Vec::<u8>::new(),
+            possible_values: Vec::<u32>::new(),
             value: None,
         }
     }
@@ -63,12 +64,30 @@ fn main() {
     let cli = Cli::parse();
 
     let playfield = parse_playfield(&cli.field, cli.field_size);
-
-    println!("Hello, world!");
 }
 
 fn parse_playfield(field: &String, field_size: usize) -> Playfield {
-    Playfield::new(field_size)
+    let playfield = &mut Playfield::new(field_size);
+
+    let chars = field.split(" ").collect::<Vec<&str>>();
+
+    for row in 0..field_size {
+        for col in 0..field_size {
+            let field = &mut playfield.fields[row][col];
+            let char_field = chars.get(row * field_size + col).expect(&format!(
+                "Input must have dimension of size {size}x{size}",
+                size = field_size
+            ));
+
+            if *char_field == "0" {
+                continue;
+            }
+
+            field.value = Some(char_field.to_string().parse::<u32>().unwrap());
+        }
+    }
+
+    return playfield.clone();
 }
 
 #[cfg(test)]
@@ -78,7 +97,7 @@ mod tests {
     #[test]
     fn test_parse_field() {
         let input = "1 2 3 0 0 0 3 2 1";
-        let field_size = 2;
+        let field_size = 3;
 
         let playfield = parse_playfield(&input.to_string(), field_size);