Using yaml funcionality of clap. Cleanup.

hw8/task1/Cargo.toml

 
 [dependencies]
 sha2 = "0.7.0"
-clap = "2.28"
+clap = {version = "~2.29.0", features = ["yaml"]}
 time = "0.1"
 sys-info = "*"

hw8/task1/src/cli.yml

+name: "task1"
+args:
+    - base:
+        value_name: "base"
+        help: "Sets the base to use"
+        takes_value: true
+        required: true
+
+    - difficulty:
+        value_name: "difficulty"
+        help: "Sets the difficulty to use"
+        takes_value: true
+        required: true
+         
+    - threads:
+        value_name: "threads"
+        help: "Sets the number of the threads to use (default = number of cpus)"
+        takes_value: true
+        required: false
+
+    - verbose:
+        short: "v"
+        help: "Prints help information"
+        multiple: true
+        required: false
+             
+    - sync:
+        short: "s"
+        long: "sync"
+        help: "enables sync when solution found"
+        required: false
+
+    - wait:
+        short: "w"
+        long: "wait"
+        help: "consumer waits for all producers"
+        required: false
+
+    - special:
+        long: "special"
+        value_name: "VALUE"
+        help: "sets special sync parameter"
+        takes_value: true
+
+subcommands:
+    - timings:
+        about: "controls timing features"
+        version: "1.0"
+        author: "Lorenz Bung & Joshua Rutschmann"
+

hw8/task1/src/main.rs

+#[macro_use]
 extern crate clap;
 extern crate time;
 extern crate task1;
 
 use std::sync::mpsc::channel;
 use time::get_time;
-use clap::{Arg, App, SubCommand};
+use clap::App;
 use std::{process, thread};
 use task1::verify_product;
 use std::sync::Arc;
 
 pub fn main() {
-    let matches = create_app().get_matches();
+    let yaml = load_yaml!("cli.yml");
+    let matches = App::from_yaml(yaml).get_matches();
     let base = matches.value_of("base").unwrap_or("1");
     let diff = Arc::new(matches.value_of("difficulty").unwrap_or("1").to_string());
     let cpus = sys_info::cpu_num().unwrap_or(1).to_string();
                         }
 
                         if let Some(solution) = verify_product(b, n, &d) {
-                            let end = get_time();
                             found = sync;
-                            
-                            if time_measurement {
-                                let diff = end - start;
-                                let s = diff.num_seconds();
-                                let ms = diff.num_milliseconds();
-                                let us = diff.num_microseconds().unwrap_or(ms * 1000);
-                                println!("(Duration {}s / {}ms / {}us)", s, ms, us);
-                            }
                             tx.send(solution).unwrap();
                         }
                         n += t;
 
             match rx.recv() {
                 Ok(sol) => {
+                    let end = get_time();
                     println!("Number: {} --> hash: {}", sol.number, sol.hash);
+                    if time_measurement {
+                        let diff = end - start;
+                        let s = diff.num_seconds();
+                        let ms = diff.num_milliseconds();
+                        let us = diff.num_microseconds().unwrap_or(ms * 1000);
+                        println!("(Duration {}s / {}ms / {}us)", s, ms, us);
+                    }
                 }
                 Err(_) => {}
             }
         }
     };
 }
-
-fn create_app<'a, 'b>() -> App<'a, 'b> {
-    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("Sets the base to use")
-                .takes_value(true)
-                .required(true),
-        )
-        .arg(
-            Arg::with_name("difficulty")
-                .value_name("difficulty")
-                .help("Sets the difficulty to use")
-                .takes_value(true)
-                .required(true),
-        )
-        .arg(
-            Arg::with_name("threads")
-                .value_name("threads")
-                .help(
-                    "Sets the number of the threads to use (default = number of cpus)",
-                )
-                .takes_value(true)
-                .required(false),
-        ).arg(Arg::with_name("verbose")
-              .short("v")
-              .multiple(true)
-              .required(false),
-        )
-    .arg(Arg::with_name("sync")
-            .short("s")
-            .required(false),
-    )
-    .arg(Arg::with_name("config")
-            .long("config")
-            .value_name("VALUE")
-            .help("sets special sync parameter")
-                               .takes_value(true))
-    .subcommand(
-            SubCommand::with_name("timings")
-                .about("controls timing features")
-                .version("1.0")
-                .author("Lorenz Bung & Joshua Rutschmann"),
-        )
-}