load extern crates in main.rs

hw5/task1/src/child/mod.rs

 use nix::sys::wait::wait;
 use nix::unistd::ForkResult::{Child, Parent};
 
+mod pstree;
 
 pub fn run_childs(start_pid: i32, arg: &str) -> Result<(), String> {
     let count = arg.parse::<u8>();
                     Err(_) => panic!("fork failed"),
                 }
             }
+            pstree::print(start_pid);
             Ok(())
         },
         Err(_) => {

hw5/task1/src/child/pstree.rs

 /// Datenstruktur für einen Prozess.
 pub struct Process {
     name: String,
-    pid: u32,
-    ppid: u32,
+    pid: i32,
+    ppid: i32,
 }
 
 impl Process {
     /// Erstellt eine Prozess-Datenstruktur aus procinfo::Stat.
-    pub fn new(with_pid: u32) -> Self {
+    pub fn new(with_pid: i32) -> Self {
         if let Ok(stat) = pid::stat(with_pid) {
             Process {
                 name: stat.command,
     }
 
     /// Prüft ob das Prozess-Struct einen (entfernten) Elternprozess mit dem übergebenen pid hat.
-    pub fn has_parent_with_pid(&self, pid: u32) -> bool {
+    pub fn has_parent_with_pid(&self, pid: i32) -> bool {
         if self.pid == pid {
             return true;
         }
     }
 
     /// Gibt über Rekursion über die Eltern eine Prozesskette aus.
-    pub fn print_recursive(&self, to_pid: u32, output: &mut String) {
+    pub fn print_recursive(&self, to_pid: i32, output: &mut String) {
 
         if output.len() == 0 {
             *output = format!("{}({}){}", self.name, self.pid, output);
 
 /// Geht von eigenem Prozess aus und gibt die Prozesskette bis zum übergebenem PID aus
 /// und fängt mögliche Fehler ab.
-pub fn print(pid: u32) -> bool {
+pub fn print(pid: i32) -> bool {
 
     if let Err(_) = pid::stat(pid) {
         println!("Invalid PID");

hw5/task1/src/main.rs

 
         match procinfo::pid::stat_self(){
             Ok(stat) => {
-                child::run_childs(stat.pid, &arguments[2]);
+                let result = child::run_childs(stat.pid, &arguments[2]);
+                match result {
+                    Ok(_) => {},
+                    Err(_) => {},
+                }
             },
             Err(_) => {},
         }