Finished.

hw5/task1/src/child/mod.rs

@@ -16,20 +16,22 @@ pub fn run_childs(start_pid: i32, arg: &str) -> Result<(), String> {
             if value > 0 {
                 fork_children(0, value - 1, start_pid);
             } else {
-                return Err("Number of forks must not be zero.".to_string())
+                return Err("Number of forks must not be zero.".to_string());
             }
 
             Ok(())
-        },
+        }
         Err(_) => {
-            Err("Failed to parse arguments. PIDs must be decimal.".to_string())
-        },
+            Err(
+                "Failed to parse arguments. PIDs must be decimal.".to_string(),
+            )
+        }
     }
 }
 
 
 /// Private function, which forks specified amount of processes (*count*) through recursion
-fn fork_children(count: u8, to:u8, start_pid: i32) {
+fn fork_children(count: u8, to: u8, start_pid: i32) {
     let pid = fork();
     match pid {
         Ok(Child) => {
@@ -45,11 +47,17 @@ fn fork_children(count: u8, to:u8, start_pid: i32) {
         Ok(Parent { child }) => {
             if let Ok(ws) = wait() {
                 if let WaitStatus::Exited(child_pid, exit_code) = ws {
-                    println!("I am {} and my child is {}. After I waited for {}, it sent me status {:?}", getpid(), child, child_pid, exit_code);
+                    println!(
+                        "I am {} and my child is {}. After I waited for {}, it sent me status {:?}",
+                        getpid(),
+                        child,
+                        child_pid,
+                        exit_code
+                    );
                 }
             }
         }
 
         Err(_) => {}
     }
-}
+}

hw5/task1/src/main.rs

@@ -11,21 +11,21 @@ mod child;
 
 
 fn main() {
-    let arguments:Vec<String> = args().collect();
+    let arguments: Vec<String> = args().collect();
 
     if arguments.len() == 2 {
 
-        let result = child::run_childs(getpid(), &arguments[1]);
+        let result = child::run_childs(i32::from(getpid()), &arguments[1]);
         match result {
-            Ok(_) => {},
+            Ok(_) => {}
             Err(e) => {
                 println!("{}", e);
                 process::exit(1)
-            },
+            }
         }
 
     } else {
         zombie::run_zombie();
     }
 
-}
+}

hw5/task1/src/unit_tests.rs

@@ -5,17 +5,23 @@ mod tests {
     use child::*;
 
     #[test]
-    fn test_zero_forks(){
-        assert_eq!(run_childs(123,"0"), Err("Number of forks must not be zero.".to_string()))
+    fn test_zero_forks() {
+        assert_eq!(
+            run_childs(123, "0"),
+            Err("Number of forks must not be zero.".to_string())
+        )
     }
 
     #[test]
-    fn test_one_fork(){
-        assert_eq!(run_childs(procinfo::pid::stat_self().unwrap().pid,"1"), Ok(()))
+    fn test_one_fork() {
+        assert_eq!(
+            run_childs(procinfo::pid::stat_self().unwrap().pid, "1"),
+            Ok(())
+        )
     }
 
     #[test]
-    fn test_wrong_pid(){
-        assert_eq!(run_childs(2,"1"), Ok(()))
+    fn test_wrong_pid() {
+        assert_eq!(run_childs(2, "1"), Ok(()))
     }
-}
+}

hw5/task2/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task2"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]

hw5/task2/src/main.rs

@@ -0,0 +1,54 @@
+use std::fmt;
+
+struct Roman(String);
+
+impl fmt::Display for Roman {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<i32> for Roman {
+    fn from(arabic_number: i32) -> Self {
+        let stages = vec![1000, 500, 100, 50, 10, 7, 6, 5, 4, 3, 2, 1];
+        let mut an = arabic_number;
+        let mut value = String::new();
+        for s in stages {
+            while an >= s{
+                value.push_str(&Roman::to_roman(s));
+                an -= s;
+            }
+        }
+        Roman::new(value)
+    }
+}
+
+impl Roman {
+    fn to_roman(number:i32) -> String {
+        match number {
+            1 => "I",
+            2 => "II",
+            3 => "III",
+            4 => "IV",
+            5 => "V",
+            6 => "VI",
+            7 => "VII",
+            10 => "X",
+            50 => "L",
+            100 => "C",
+            500 => "D",
+            1000 => "M",
+            _ => "",
+        }.to_string()
+    }
+
+    fn new(string: String) -> Self {
+        Roman(string)
+    }
+}
+
+
+fn main() {
+    println!("Hello, world!");
+    println!("{} into {}", 2012, Roman::from(2012));
+}