Added Comments/Documentation in all .rs files

hw10/task1/src/main.rs

 use srv_config::Config;
 use HashServerError::Parse;
 
+/// Datentyp für die beim Server auftretenden Fehlertypen.
 #[derive(Debug)]
 pub enum HashServerError {
     Parse(srv_commands::ParseError),
     }
 }
 
+/// Funktion zum Abarbeiten eines Clients.
 fn handle_client(stream: &TcpStream, orders: &mut VecDeque<String>, v: bool) {
     let mut reader = BufReader::new(stream);
     let mut writer = BufWriter::new(stream);
     }
 }
 
+/// Hauptfunktion, die beim Starten des Servers ausgeführt wird.
 pub fn main() {
 
     let c = Config::load();

hw10/task1/srv-commands/src/lib.rs

+/// Diese Funktion parst die übergebene Nachricht und erkennt die Befehle
+/// "STAGE", "CONTROL" und "RETRIEVE". Bei den ersten beiden wird der nachfolgende
+/// String als Nachricht zurückgegeben; der Eingabestring wird bis zum ersten
+/// Zeilenumbruch gelesen. Wird kein Befehl erkannt, wird ein entsprechender
+/// Fehler zurückgegeben.
 pub fn parse(message: &str) -> Result<Command, ParseError> {
     let m: String = String::from(message.trim_right());
-    let mut line = m.lines();
-    match line.next() {
+    let mut line = m.lines(); // Eingabestring an Zeilenende abtrennen
+    match line.next() { // Betrachte nur die erste Zeile
         Some(x) => {
-            let mut str = x.split_whitespace();
+            let mut str = x.split_whitespace(); // Teile an Leerzeichen
             match str.next() {
                 Some("STAGE") => {
-                    let msg = m[6..].trim_left();
+                    let msg = m[6..].trim_left(); // msg = Alles außer STAGE
                     Ok(Command::Stage(msg.to_string()))
                 }
                 Some("CONTROL") => {
-                    let cmd = m[8..].trim_left();
+                    let cmd = m[8..].trim_left(); // cmd = Alles außer CONTROL
                     Ok(Command::Control(cmd.to_string()))
                 }
                 Some("RETRIEVE") => Ok(Command::Retrieve),
     }
 }
 
+/// Datentyp zur Beschreibung der durch parse() erkannten Befehle.
+/// Stage und Control liefern die Nachricht als String mit.
 #[derive(Debug, PartialEq)]
 pub enum Command {
     Stage(String),
     Retrieve,
 }
 
+/// Datentyp zur Fehlerbehandlung. ErrorType gibt den Fehlertyp an.
 #[derive(Debug, PartialEq)]
 pub struct ParseError(pub ErrorType);
 
+/// Datentyp zur Beschreibung der in parse() auftretenden Fehlertypen.
 #[derive(Debug, PartialEq)]
 pub enum ErrorType {
     UnknownCommand,

hw10/task1/srv-config/src/lib.rs

 
 use clap::App;
 
+/// Datentyp zur Beschreibung der Konfiguration des Servers.
 pub struct Config {
     pub address: String,
     pub port: String,
 }
 
 impl Config {
+    /// Funktion zum Lesen der Konfigurationsdatei des Servers.
     pub fn load() -> Self {
         let yaml = load_yaml!("cli.yml");
         let matches = App::from_yaml(yaml).get_matches();