Ran rustfmt on various files

hw7/task1/src/hash256.rs

     let hash = Sha256::hash(bytes).hex();
 
     if hash.ends_with(difficulty) {
-        return Some(Solution{ number: number, hash: hash,});
+        return Some(Solution {
+            number: number,
+            hash: hash,
+        });
     }
 
     None

hw7/task1/src/main.rs

     let diff = matches.value_of("difficulty").unwrap_or("1");
     let mut time_measurement = false;
 
-    if diff.chars().any( |c| !c.is_digit(16)) {
+    if diff.chars().any(|c| !c.is_digit(16)) {
         println!("Difficulty is not hexadecimal.");
         process::exit(1)
     }
                 if let Some(x) = hash256::verify_product(b, n, &diff.to_string()) {
                     let end = get_time();
                     println!("Number: {} --> hash: {}", x.number, x.hash);
-                    if time_measurement{
+                    if time_measurement {
                         let diff = end - start;
                         let s = diff.num_seconds();
                         let ms = diff.num_milliseconds();
     App::new("Hash256")
         .version("1.0")
         .author("Lorenz Bung & Joshua Rutschmann")
-        .about("Calculates the Hashvalue of the given base, number and difficulty.")
-        .arg(Arg::with_name("base")
-            .value_name("base")
-            .help("The base of the hash to be calculated on.")
-            .takes_value(true)
-            .required(true))
-        .arg(Arg::with_name("difficulty")
-            .value_name("difficulty")
-            .help("The difficulty of the calculated hash.")
-            .takes_value(true)
-            .required(true))
-        .subcommand(SubCommand::with_name("timings")
-            .about("controls timing features")
-            .version("1.0")
-            .author("Lorenz Bung & Joshua Rutschmann"))
+        .about(
+            "Calculates the Hashvalue of the given base, number and difficulty.",
+        )
+        .arg(
+            Arg::with_name("base")
+                .value_name("base")
+                .help("The base of the hash to be calculated on.")
+                .takes_value(true)
+                .required(true),
+        )
+        .arg(
+            Arg::with_name("difficulty")
+                .value_name("difficulty")
+                .help("The difficulty of the calculated hash.")
+                .takes_value(true)
+                .required(true),
+        )
+        .subcommand(
+            SubCommand::with_name("timings")
+                .about("controls timing features")
+                .version("1.0")
+                .author("Lorenz Bung & Joshua Rutschmann"),
+        )
 }

hw7/task2/src/lib.rs

         match parts.next() {
             Some("exit") => Ok(Command::Exit),
             Some("cd") => Ok(Command::parse_cd(parts.next())),
-            Some(_) => {
-                Ok(Command::Program(s.to_string()))
-            }
+            Some(_) => Ok(Command::Program(s.to_string())),
             None => Ok(Command::Empty),
         }
     }
     fn run(&mut self, command: Command) -> Result<(), ErrorType> {
 
         match command {
-            Command::Empty => {},
+            Command::Empty => {}
             Command::Program(cmd) => {
 
                 let commands = cmd.split('|');
                 let needs_pipe = commands_vec.len() == 2;
 
 
-                    let fi = fork();
-                    match fi {
-                        Ok(Parent { child: _child }) => {
-                            let _ = wait();
+                let fi = fork();
+                match fi {
+                    Ok(Parent { child: _child }) => {
+                        let _ = wait();
 
-                        }
-                        Ok(Child) => {
-                            if let Ok((reader, writer)) = pipe() {
-                                let sec = fork();
-                                match sec {
-                                    Ok(Parent { child: _child }) => {
-                                        let _ = wait();
-                                        if let Some(second) = commands_vec.get(1) {
-                                            match close(writer) {
-                                                Ok(_) => {},
-                                                Err(_) => return Err(ErrorType::BrokenPipeError),
-                                            }
-                                            dup2(reader, 0).unwrap();
-                                            self.execute(second);
+                    }
+                    Ok(Child) => {
+                        if let Ok((reader, writer)) = pipe() {
+                            let sec = fork();
+                            match sec {
+                                Ok(Parent { child: _child }) => {
+                                    let _ = wait();
+                                    if let Some(second) = commands_vec.get(1) {
+                                        match close(writer) {
+                                            Ok(_) => {}
+                                            Err(_) => return Err(ErrorType::BrokenPipeError),
                                         }
+                                        dup2(reader, 0).unwrap();
+                                        self.execute(second);
                                     }
-                                    Ok(Child) => {
-                                        if let Some(first) = commands_vec.get(0) {
-                                            if needs_pipe {
-                                                close(reader).unwrap();
-                                                dup2(writer, 1).unwrap();
-                                            }
-                                            self.execute(first);
+                                }
+                                Ok(Child) => {
+                                    if let Some(first) = commands_vec.get(0) {
+                                        if needs_pipe {
+                                            close(reader).unwrap();
+                                            dup2(writer, 1).unwrap();
                                         }
+                                        self.execute(first);
                                     }
-                                    Err(_) => return Err(ErrorType::ForkError),
                                 }
+                                Err(_) => return Err(ErrorType::ForkError),
                             }
                         }
-                        Err(_) => return Err(ErrorType::ForkError),
                     }
+                    Err(_) => return Err(ErrorType::ForkError),
+                }
 
-            },
+            }
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
                 command.exec_cd();
         Ok(())
     }
 
-    fn execute(&self, cmd: &str){
-        let parts:Vec<&str> = cmd.split_whitespace().collect();
-        let args:Vec<CString> = parts.iter().map(|f| CString::new(*f).unwrap()).collect();
+    fn execute(&self, cmd: &str) {
+        let parts: Vec<&str> = cmd.split_whitespace().collect();
+        let args: Vec<CString> = parts.iter().map(|f| CString::new(*f).unwrap()).collect();
         let t = args.into_boxed_slice();
 
         execvp(&t[0], &t).unwrap();
     }
 }
-