From d8a9a1be055c767e1e489a14e314d6fc2b5ec1c7 Mon Sep 17 00:00:00 2001
From: FloriN <lisa.nicomisch@tutamail.com>
Date: Fri, 29 Nov 2019 12:49:41 +0100
Subject: [PATCH 1/4] Doku Walze

---
 src/main/java/enigma/model/Walze.java | 460 ++++++++++++++------------
 1 file changed, 244 insertions(+), 216 deletions(-)

diff --git a/src/main/java/enigma/model/Walze.java b/src/main/java/enigma/model/Walze.java
index 42d9c87..a89b634 100644
--- a/src/main/java/enigma/model/Walze.java
+++ b/src/main/java/enigma/model/Walze.java
@@ -2,244 +2,272 @@ package enigma.model;
 
 /**
  * Klasse Walze
- * <p>
+ * <br>
  * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
- * <p>
+ * <br>
  * 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
  * 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
  * paarweise vertauschen)
- * <p>
+ * <br>
  * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
  * den Drehzeitpunkt der linken Nachbarwalze)
  */
 public class Walze {
 
+    /**
+     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+     */
+    private Character[] alphabet;
+
 	/**
-	 * Konstanten und Variablen der Klasse Walze
-	 * <p>
-	 * ringstellung : Bestimmt den Umspringpunkt der Walze
-	 * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
+	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
 	 */
-	private Character[] walzeAlpha;
 	private char ringstellung;
-	private int walzennr;
-	private Character[] alphabet;
-
 
 	/**
-	 * Gibt die Parameter der Walze mit
-	 *
-	 * @param walzennr     : int : Nummer der gewaehlten Walze
-	 * @param ringstellung : Character : Einstellung des Notch
+	 *  walzennr : int : Bestimmt, welche Walze genutzt wird
 	 */
-	public Walze(int walzennr, int ringstellung) {
-		this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-		this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-		// Setzen der Walzennummer
-		this.setWalzennr(walzennr);
-
-		// Setzen der Ringstellung
-		this.setRingstellung(ringstellung);
-	}
+    private int walzennr;
 
 	/**
-	 * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
-	 *
-	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+	 *  alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+	 *  aber immer wieder ueberschrieben.
 	 */
-	private Character[] walzenNummer() {
-
-		Character[] walze = new Character[26];
-		Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-		Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-		Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-		Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
-		Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
-
-		switch (this.walzennr) {
-			case 1:
-				walze = walzeEins;
-				break;
-			case 2:
-				walze = walzeZwei;
-				break;
-			case 3:
-				walze = walzeDrei;
-				break;
-			case 4:
-				walze = walzeVier;
-				break;
-			case 5:
-				walze = walzeFuenf;
-				break;
-		}
-
-		return walze;
-	}
-
-	/**
-	 * TODO: Dokumentieren
+    private Character[] walzeAlpha;
+
+    /**
+     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
+     *
+     * @param walzennr     : int : Nummer der gewaehlten Walze
+     * @param ringstellung : int : Einstellung des Umsprungpunktes
+     */
+    public Walze(int walzennr, int ringstellung) {
+        this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+        this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+        this.setWalzennr(walzennr);
+        this.setRingstellung(ringstellung);
+    }
+
+    /**
+     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    private Character[] walzenNummer() {
+        Character[] walze = new Character[26];
+
+        // Character-Arrays fuer die Codierung jeder Walze
+        Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+        Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+        Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+        Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+        Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+        switch (this.walzennr) {
+            case 1:
+                walze = walzeEins;
+                break;
+            case 2:
+                walze = walzeZwei;
+                break;
+            case 3:
+                walze = walzeDrei;
+                break;
+            case 4:
+                walze = walzeVier;
+                break;
+            case 5:
+                walze = walzeFuenf;
+                break;
+        }
+
+        return walze;
+    }
+
+    /**
+     * TODO: Dokumentieren
+     *
+     * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
+     */
+    public char getRingstellung() {
+        return ringstellung;
+    }
+
+    /**
+     * Setzt die Initiale Ringstellung der Walze.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
 	 *
-	 * @return ringstellung : Character : gibt die neue Ringstellung zurueck
-	 */
-	public char getRingstellung() {
-		return ringstellung;
-	}
-
-	/**
-	 * Gibt die Initiale Ringstellung der Walze an.
-	 * Es sind nur Zahlen von 1 - 26 zugelassen.
-	 * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+	 * Die Ringstellung wird zum char umgewandelt.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+     *
+     * @param ringstellung : int : Punkt an dem die Walze umspringt
+     */
+    //TODO ??? Setter Ringstellung
+    public void setRingstellung(int ringstellung) {
+        if (ringstellung > 0 && ringstellung <= 26) {
+            this.ringstellung = this.alphabet[ringstellung - 1];
+        } else {
+            this.ringstellung = 'Z';
+        }
+    }
+
+    /**
+     * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
+	 * das Array alphabet mit der neuen Anordnung.
 	 *
-	 * @param ringstellung : Character : Punkt an dem die Walze umspringt
-	 */
-	public void setRingstellung(int ringstellung) {
-		if (ringstellung > 0 && ringstellung <= 26) {
-			this.ringstellung = this.alphabet[ringstellung - 1];
-		} else {
-			this.ringstellung = 'Z';
-		}
-	}
-
-	/**
-	 * dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
-	 * TODO: Doku
-	 */
-	public boolean dreheWalze(int... drehung) {
-
-		boolean checkRing = false;
-
-		verschiebung();
-
-		if (drehung.length > 0) {
-			for (int i = 1; i < drehung[0]; i++) {
-				verschiebung();
-			}
-		}
-
-		if (this.getPosition().equals(this.ringstellung)) {
-			checkRing = true;
-		}
-
-		return checkRing;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 */
-	private void verschiebung() {
-
-		Character[] neueWalze = new Character[26];
-
-		for (int index = 0; index < neueWalze.length; index++) {
-			neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
-		}
-		this.walzeAlpha = neueWalze;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 * @return
-	 */
-	public char getAnzeige() {
-		int temp = this.getArrayIndex('A', this.walzeAlpha);
-
-		return this.alphabet[temp];
-	}
-
-	/**
-	 * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
-	 * anhand der gewaehlten Walze.
+	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
 	 *
-	 * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
-	 */
-	public char codiere(char buchstabe) {
-		for (int i = 0; i < walzeAlpha.length; i++) {
-			if (walzeAlpha[i].equals(buchstabe)) {
-				buchstabe = walzenNummer()[i];
-				break;
-			}
-		}
-
-		return buchstabe;
-	}
-
-	/**
-	 * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
-	 * anhand der AlphaWalze.
+	 * @param drehung : int[] : Anzahl der Drehungen
+	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+     * TODO: Doku
+     */
+    public boolean dreheWalze(int... drehung) {
+        boolean checkRing = false;
+
+        // fuehrt die Verschiebung des Alphabets um eine Stelle durch
+        verschiebung();
+
+        // fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
+        if (drehung.length > 0) {
+            for (int i = 1; i < drehung[0]; i++) {
+                verschiebung();
+            }
+        }
+
+        // gleicht die Ringstellung mit der aktuellen Position ab
+        if (this.getPosition().equals(this.ringstellung)) {
+            checkRing = true;
+        }
+
+        return checkRing;
+    }
+
+    /**
+	 * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
+     * TODO: Dokumentieren
+     */
+    private void verschiebung() {
+        Character[] neueWalze = new Character[26];
+
+        for (int index = 0; index < neueWalze.length; index++) {
+            neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
+        }
+
+        this.walzeAlpha = neueWalze;
+    }
+
+    /**
+     * TODO: Dokumentieren // dass selbe wie getPosition
+     * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
 	 *
-	 * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
-	 */
-	public char codiere2(char buchstabe) {
-		for (int i = 0; i < walzenNummer().length; i++) {
-			if (walzenNummer()[i].equals(buchstabe)) {
-				buchstabe = walzeAlpha[i];
-				break;
-			}
-		}
-
-		return buchstabe;
-	}
-
-	/**
-	 * TODO: Dokumentieren
+     * @return char an der Stelle temp des Alphabets
+     */
+    public char getAnzeige() {
+        int temp = this.getArrayIndex('A', this.walzeAlpha);
+        return this.alphabet[temp];
+    }
+
+    /**
+     * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+     *
+	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+     * @return buchstabe : char : verschluesselter Buchstabe
+     */
+    public char codiere(char buchstabe) {
+        /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
+        uebertraegt den Index auf die gewaehlte Codierwalze*/
+        buchstabe = walzenNummer()[getArrayIndex(buchstabe, walzeAlpha)];
+//    	for (int i = 0; i < walzeAlpha.length; i++) {
+//            if (walzeAlpha[i].equals(buchstabe)) {
+//                buchstabe = walzenNummer()[i];
+//                break;
+//            }
+//        }
+
+        return buchstabe;
+    }
+
+    /**
+     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+     *
+	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
+     * @return buchstabe : char : decodierter Buchstabe
+     */
+    public char codiere2(char buchstabe) {
+        /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
+        uebertraegt den Index auf die (verschobene) Alphabetswalze*/
+		buchstabe = walzeAlpha[getArrayIndex(buchstabe, walzenNummer())];
+//    	for (int i = 0; i < walzenNummer().length; i++) {
+//            if (walzenNummer()[i].equals(buchstabe)) {
+//                buchstabe = walzeAlpha[i];
+//                break;
+//            }
+//        }
+
+        return buchstabe;
+    }
+
+    /**
+     * TODO: Dokumentieren
+     * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
 	 *
-	 * @param buchstabe : Character
-	 * @param array : Character[]
-	 * @return int
-	 */
-	private int getArrayIndex(Character buchstabe, Character[] array) {
-
-		int result = -1;
-
-		for (int i = 0; i < array.length; i++) {
-			if (array[i].equals(buchstabe)) {
-				result = i;
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	/**
-	 * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
-	 *
-	 * @param walzennr : int : setzt die Walzennummer
-	 */
-	public void setWalzennr(int walzennr) {
-		if (walzennr > 0 && walzennr < 6) {
-			this.walzennr = walzennr;
-		} else {
-			System.err.println("Keine gültige Walzennummer");
-		}
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 *
-	 * @return Character
-	 */
-	public Character getPosition() {
-		return walzeAlpha[0];
-	}
-
-	/**
-	 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-	 * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-	 * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
+     * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
+     * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll
+     * @return result : int : index des Buchstaben
+     */
+    private int getArrayIndex(Character buchstabe, Character[] array) {
+        // wird mit ungueltigem Wert initialisiert
+    	int result = -1;
+
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(buchstabe)) {
+                result = i;
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+     *
+     * @param walzennr : int : Walzennummer
+     */
+    public void setWalzennr(int walzennr) {
+        if (walzennr > 0 && walzennr < 6) {
+            this.walzennr = walzennr;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
+    }
+
+    /**
+     * TODO: Dokumentieren // das selbe wie getAnzeig?
+	 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+     *
+     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     */
+    public Character getPosition() {
+        return walzeAlpha[0];
+    }
+
+    /**
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
 	 * TODO: Funktionsname hat sich geändert
-	 *
-	 * @param buchstabe : Character : Grundeinstellung der Walze
-	 */
-	public void setPosition(Character buchstabe) {
-		if (Character.isLetter(buchstabe)) {
-			buchstabe = Character.toUpperCase(buchstabe);
-			System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
-			if (buchstabe > 'A') {
-				dreheWalze(this.getArrayIndex(buchstabe, this.alphabet));
-			}
-		}
-	}
+     *
+     * @param buchstabe : Character : Einstellung der Walze
+     */
+    public void setPosition(Character buchstabe) {
+        if (Character.isLetter(buchstabe)) {
+            buchstabe = Character.toUpperCase(buchstabe);
+//            System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+            if (buchstabe > 'A') {
+                dreheWalze(this.getArrayIndex(buchstabe, this.alphabet));
+            }
+        }
+    }
 }
-- 
GitLab


From ea986f7d5d23d887939c68a789fa323a5f8ac06c Mon Sep 17 00:00:00 2001
From: FloriN <lisa.nicomisch@tutamail.com>
Date: Fri, 29 Nov 2019 13:36:37 +0100
Subject: [PATCH 2/4] Doku Walze

---
 src/main/java/projekt/enigma/model/Walze.java | 39 ++++++++-----------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index e9d0203..5e6966c 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -42,8 +42,10 @@ public class Walze {
      * @param ringstellung : int : Einstellung des Umsprungpunktes
      */
     public Walze(int walzennr, int ringstellung) {
-        this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-        this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+        this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                                        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+        this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
 
         this.setWalzennr(walzennr);
         this.setRingstellung(ringstellung);
@@ -58,11 +60,16 @@ public class Walze {
         Character[] walze = new Character[26];
 
         // Character-Arrays fuer die Codierung jeder Walze
-        Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-        Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-        Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-        Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
-        Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+        Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
+                                 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+        Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
+                                 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+        Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
+                                 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+        Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
+                                 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+        Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
+                                  'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
 
         switch (this.walzennr) {
             case 1:
@@ -178,12 +185,6 @@ public class Walze {
         /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die gewaehlte Codierwalze*/
         buchstabe = walzenNummer()[getArrayIndex(buchstabe, walzeAlpha)];
-//    	for (int i = 0; i < walzeAlpha.length; i++) {
-//            if (walzeAlpha[i].equals(buchstabe)) {
-//                buchstabe = walzenNummer()[i];
-//                break;
-//            }
-//        }
 
         return buchstabe;
     }
@@ -198,12 +199,6 @@ public class Walze {
         /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die (verschobene) Alphabetswalze*/
 		buchstabe = walzeAlpha[getArrayIndex(buchstabe, walzenNummer())];
-//    	for (int i = 0; i < walzenNummer().length; i++) {
-//            if (walzenNummer()[i].equals(buchstabe)) {
-//                buchstabe = walzeAlpha[i];
-//                break;
-//            }
-//        }
 
         return buchstabe;
     }
@@ -254,19 +249,19 @@ public class Walze {
     }
 
     /**
+     * 	 * TODO: Funktionsname hat sich geändert
      * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
      * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
      * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
-	 * TODO: Funktionsname hat sich geändert
      *
      * @param buchstabe : Character : Einstellung der Walze
      */
     public void setPosition(Character buchstabe) {
         if (Character.isLetter(buchstabe)) {
             buchstabe = Character.toUpperCase(buchstabe);
-//            System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+            System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
             if (buchstabe > 'A') {
-                dreheWalze(this.getArrayIndex(buchstabe, this.alphabet));
+                dreheWalze(this.getArrayIndex(buchstabe, this.walzeAlpha));
             }
         }
     }
-- 
GitLab


From 0ce8f17ff5e5d087304452cd2bc6348ebc3b2099 Mon Sep 17 00:00:00 2001
From: FloriN <lisa.nicomisch@tutamail.com>
Date: Fri, 29 Nov 2019 14:31:23 +0100
Subject: [PATCH 3/4] =?UTF-8?q?Doku=20Walze=20und=20Codebuch(mit=20TODOs?=
 =?UTF-8?q?=20f=C3=BCr=20zweifelhafte=20Kommentare)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/projekt/enigma/model/Codebuch.java   | 46 +++++++++++++------
 src/main/java/projekt/enigma/model/Walze.java | 14 +++---
 2 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
index aacb58c..9ded525 100644
--- a/src/main/java/projekt/enigma/model/Codebuch.java
+++ b/src/main/java/projekt/enigma/model/Codebuch.java
@@ -7,7 +7,7 @@ import java.time.ZoneId;
 
 /**
  * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
- * Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
+ * Jeder Enigma gehörte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschlüsseln.
  * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
  * mussten um die Texte zu ver/entschlüsseln.
  * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
@@ -22,22 +22,36 @@ import java.time.ZoneId;
  * geben kann.
  */
 public class Codebuch {
+
 	/**
-	 * TODO: Dokumentieren
+	 * TODO: Dokumentieren tag
+	 * tag : int : gibt den Tag an
 	 */
 	private int tag;
+
+	/**
+	 * walzenlage : int[] : legt die Positionen der Walzen fest
+	 */
 	private int[] walzenlage;
+
+	/**
+	 * ringstellung : int[] : TODO ringstellung: char || int ?
+	 */
 	private int[] ringstellung;
+
+	/**
+	 * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
+	 */
 	private char[][] steckverbindung;
 
 	/**
-	 * Im Konstruktor werden die Standart Werte gesetzt
+	 * Im Konstruktor werden die Standardwerte gesetzt
 	 * <p>
 	 * walzenlage : int[3] :            Hier wird die Position der drei Walzen festgelegt.
 	 * ringstellung : char[3] :         Jede Walze hat einen Ring. Der Index steht für die Walze und der Value für
 	 * die Position des Ringes.
 	 * steckverbindung : char[10][] :   Zehn Kabel können in das Steckbrett gesteckt werden. In diesem Array werden
-	 * die Kabel mit ihren jeweiligen Buchsen hinterlegt.
+	 * 									die Kabel mit ihren jeweiligen Buchsen hinterlegt.
 	 */
 	public Codebuch() {
 		this.walzenlage = new int[3];
@@ -53,12 +67,16 @@ public class Codebuch {
 
 	/**
 	 * TODO: Dokumentieren
-	 * @param tag
+	 * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
+	 * Aus dem Tagesschluessel werden die Werte fuer die Walzenlage, Ringstellung und Steckverbindung
+	 * gesetzt.
+	 *
+	 * @param tag : int[] : gibt einen Tag oder mehrere Tage mit
 	 */
 	public void fetchTagesschluessel(int... tag) {
 		String[] walzenlage, ringstellung, db;
 
-		if(tag.length > 0) {
+		if (tag.length > 0) {
 			db = new DatenbankSqlite().getCodebuch(tag[0]);
 		} else {
 			db = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
@@ -82,7 +100,7 @@ public class Codebuch {
 
 	/**
 	 * Gibt die aktuelle Instanz des Codebuches als String zurück.
-	 * Hierbei werden der Tag die Walzenlagen, Ring/Grundstellung sowie die Steckverbindungen zurück gegeben.
+	 * Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurück gegeben.
 	 *
 	 * @return String : String des gesamten Objektes
 	 */
@@ -138,16 +156,14 @@ public class Codebuch {
 	/**
 	 * Setzt den Tag dieser Instanz
 	 *
-	 * @param tag : int
+	 * @param tag : int : Tag
 	 */
-	void setTag(int tag) {
-		this.tag = tag;
-	}
+	void setTag(int tag) { this.tag = tag; }
 
 	/**
 	 * Gibt die Walzenlage dieser Instanz zurück
 	 *
-	 * @return String[] : Walzenlage
+	 * @return String[] : Walzenlage TODO: String[] || int[]?
 	 */
 	public int[] getWalzenlage() {
 		return walzenlage;
@@ -156,7 +172,7 @@ public class Codebuch {
 	/**
 	 * Gibt die Ringstellung dieser Instanz zurück
 	 *
-	 * @return String[] : Ringstellung
+	 * @return String[] : Ringstellung TODO: String[] || int[]?
 	 */
 	public int[] getRingstellung() {
 		return ringstellung;
@@ -177,7 +193,7 @@ public class Codebuch {
 	 *
 	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
 	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
-	 *              Diese werden in zwei char zerlegt und anschließend im globalen
+	 *              Diese werden in zwei chars zerlegt und anschließend im globalen
 	 *              Array gespeichert.
 	 */
 	private void setSteckverbindung(String[] kabel) {
@@ -205,7 +221,7 @@ public class Codebuch {
 	 * Setzt die Ringstellung dieser Instanz
 	 *
 	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
-	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.
+	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
 	 */
 	private void setRingstellung(int position, int ringstellung) {
 		this.ringstellung[position] = ringstellung;
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 5e6966c..51bf3a8 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -112,7 +112,7 @@ public class Walze {
      */
     //TODO ??? Setter Ringstellung
     public void setRingstellung(int ringstellung) {
-        if (ringstellung > 0 && ringstellung <= 26) {
+        if ((ringstellung > 0) && (ringstellung <= 26)) {
             this.ringstellung = this.alphabet[ringstellung - 1];
         } else {
             this.ringstellung = 'Z';
@@ -171,7 +171,7 @@ public class Walze {
      * @return char an der Stelle temp des Alphabets
      */
     public char getAnzeige() {
-        int temp = this.getArrayIndex('A', this.walzeAlpha);
+        int temp = this.fetchArrayIndex('A', this.walzeAlpha);
         return this.alphabet[temp];
     }
 
@@ -184,7 +184,7 @@ public class Walze {
     public char codiere(char buchstabe) {
         /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die gewaehlte Codierwalze*/
-        buchstabe = walzenNummer()[getArrayIndex(buchstabe, walzeAlpha)];
+        buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
 
         return buchstabe;
     }
@@ -198,7 +198,7 @@ public class Walze {
     public char codiere2(char buchstabe) {
         /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die (verschobene) Alphabetswalze*/
-		buchstabe = walzeAlpha[getArrayIndex(buchstabe, walzenNummer())];
+		buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
 
         return buchstabe;
     }
@@ -211,7 +211,7 @@ public class Walze {
      * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll
      * @return result : int : index des Buchstaben
      */
-    private int getArrayIndex(Character buchstabe, Character[] array) {
+    private int fetchArrayIndex(Character buchstabe, Character[] array) {
         // wird mit ungueltigem Wert initialisiert
     	int result = -1;
 
@@ -231,7 +231,7 @@ public class Walze {
      * @param walzennr : int : Walzennummer
      */
     public void setWalzennr(int walzennr) {
-        if (walzennr > 0 && walzennr < 6) {
+        if ((walzennr > 0) && (walzennr < 6)) {
             this.walzennr = walzennr;
         } else {
             System.err.println("Keine gültige Walzennummer");
@@ -261,7 +261,7 @@ public class Walze {
             buchstabe = Character.toUpperCase(buchstabe);
             System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
             if (buchstabe > 'A') {
-                dreheWalze(this.getArrayIndex(buchstabe, this.walzeAlpha));
+                dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
             }
         }
     }
-- 
GitLab


From 59e0c1d3f9d6dde178ad302205ab0828ec160255 Mon Sep 17 00:00:00 2001
From: FloriN <lisa.nicomisch@tutamail.com>
Date: Mon, 2 Dec 2019 13:06:00 +0100
Subject: [PATCH 4/4] threading, Funkraum als public

---
 src/main/java/projekt/enigma/Main.java        |  9 ++++-
 .../java/projekt/enigma/model/Funkraum.java   | 40 +++++++++----------
 src/main/java/projekt/enigma/model/Walze.java | 25 +++++-------
 .../projekt/enigma/threads/ThreadApp.java     | 17 ++++++++
 .../enigma/threads/ThreadFunkraum.java        | 26 ++++++++++++
 5 files changed, 81 insertions(+), 36 deletions(-)
 create mode 100644 src/main/java/projekt/enigma/threads/ThreadApp.java
 create mode 100644 src/main/java/projekt/enigma/threads/ThreadFunkraum.java

diff --git a/src/main/java/projekt/enigma/Main.java b/src/main/java/projekt/enigma/Main.java
index f016016..31b558d 100644
--- a/src/main/java/projekt/enigma/Main.java
+++ b/src/main/java/projekt/enigma/Main.java
@@ -1,11 +1,18 @@
 package projekt.enigma;
 
 
+import projekt.enigma.threads.ThreadApp;
+import projekt.enigma.threads.ThreadFunkraum;
+
 import java.sql.SQLException;
 
 public class Main {
 
     public static void main(String[] args) throws SQLException {
-        App.main(args);
+        Thread app = new Thread(new ThreadApp());
+//        Thread funk = new Thread(new ThreadFunkraum());
+
+        app.start();
+//        funk.start();
     }
 }
diff --git a/src/main/java/projekt/enigma/model/Funkraum.java b/src/main/java/projekt/enigma/model/Funkraum.java
index 96a3a35..f596cfa 100644
--- a/src/main/java/projekt/enigma/model/Funkraum.java
+++ b/src/main/java/projekt/enigma/model/Funkraum.java
@@ -19,24 +19,25 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Hier sitzt der Funker
- * Der Funkraum kann Funksprüche empfangen und senden.
- * Hierfür wird eine Verbindung zu einem externen Service aufgebaut.
+ * Hier sitzt der Funker.
+ * Der Funkraum kann Funksprueche empfangen und senden.
+ * Hierfuer wird eine Verbindung zu einem externen Service aufgebaut.
  * Dieser Servive erwartet die Nachrichten im JSON Format. Dazu wird ein k als Kenngruppe
- * (Benutzername) übergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
+ * (Benutzername) uebergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
  * Beides wird als String gesendet.
  */
-class Funkraum {
+public class Funkraum {
+
 	/**
-	 * Zum Empfangen liefert der Server, anstatt der Kenngruppe (k) den Empfangstag der Nachricht mit damit man
+	 * Zum Empfangen liefert der Server, anstatt der Kenngruppe (k), den Empfangstag (t) der Nachricht mit, damit man
 	 * die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
 	 * {'m': 'Hello world', 't': '26'}
 	 *
-	 * @param kenngruppe : String : Kenngruppe dieser Engiam
-	 * @return String[] : String Array wobei Index 0 dem Empfangstag entspricht und index 1 der empfangenen Nachricht
+	 * @param kenngruppe : String : Kenngruppe dieser Enigma
+	 * @return funkspruch : String[] : String Array wobei Index 0 dem Empfangstag entspricht und Index 1
+	 * der empfangenen Nachricht
 	 */
-	String[] empfangeFunkspruch(String kenngruppe) {
-
+	public String[] empfangeFunkspruch(String kenngruppe) {
 		String[] funkspruch = new String[2];
 
 		HttpClient httpclient = HttpClients.createDefault();
@@ -73,22 +74,21 @@ class Funkraum {
 
 	/**
 	 * Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
-	 * Dieser nimmt die Daten entgegeb und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
-	 * irgendwann, auf Anfrage, wieder abgerufen werden können.
+	 * Dieser nimmt die Daten entgegen und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
+	 * irgendwann, auf Anfrage, wieder abgerufen werden koennen.
 	 * <p>
-	 * Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
+	 * Darauf antwortet der Server mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
 	 * {'result': 200}
 	 * <p>
-	 * Die 200 heißt hier das alles erfolgreich durchgeführt werden konnte. Steht hier etwas anderes, ist ein Fehler
+	 * Die 200 heißt hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
 	 * aufgetreten und die Anfrage war nicht erfolgreich.
-	 * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggF später erneut versucht.
+	 * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf spaeter erneut versucht werden.
 	 *
-	 * @param funkspruch : String : Der zu sendede Funkspruch
+	 * @param funkspruch : String : Der zu sendende Funkspruch
 	 * @param kenngruppe : String : Die Kenngruppe dieser Engima
 	 * @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
 	 */
-	void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
-
+	public void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
 		HttpClient httpclient = HttpClients.createDefault();
 		HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
 
@@ -106,9 +106,9 @@ class Funkraum {
 			BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
 			JSONObject result = new JSONObject(reader.readLine());
 			if (result.getInt("result") != 200) {
-				throw new HttpException("Der andere Funker mag deine Nachricht nicht. Rüge ihn wenn du ihn wieder siehst...");
+				throw new HttpException("Der andere Funker mag deine Nachricht nicht. " +
+										"Rüge ihn wenn du ihn wieder siehst...");
 			}
 		}
-
 	}
 }
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 118ad4f..2cd9039 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -18,12 +18,12 @@ public class Walze {
 
     //region Variablen
     /**
-     * Das String Array aller bekannter aktuellen Walzen
+     * Das String Array aller bekannter aktueller Walzen
      */
     String[] walzen;
 
     /**
-     * alphabet : String dass die Buchstaben des Alphabets enthaelt
+     * alphabet : String : dass die Buchstaben des Alphabets enthaelt
      */
     private String alphabet;
 
@@ -33,12 +33,12 @@ public class Walze {
     private char ringstellung;
 
     /**
-     * walzennr : int : Bestimmt, welche Walze genutzt wird
+     * walzenNr : int : Bestimmt, welche Walze genutzt wird
      */
     private int walzenNr;
 
     /**
-     * Die Anzahl der getätigten Walzen Drehungen
+     * turns : int : Die Anzahl der getätigten Walzen Drehungen
      */
     private int turns;
     //endregion
@@ -46,12 +46,12 @@ public class Walze {
     //region Konstruktor
     /**
      * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
+     * und die Walzen initialisiert.
      *
      * @param walzenNr     : int : Nummer der gewaehlten Walze
      * @param ringstellung : int : Einstellung des Umsprungpunktes
      */
     public Walze(int walzenNr, int ringstellung) {
-
         this.walzen = new String[5];
         this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
         this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
@@ -77,7 +77,6 @@ public class Walze {
      * TODO: Doku
      */
     public boolean dreheWalze(int richtung) {
-
         boolean checkRing = false;
 
         if (richtung == -1 || richtung == 1) {
@@ -113,11 +112,11 @@ public class Walze {
      * @return buchstabe : char : decodierter Buchstabe
      */
     public char codiere2(char buchstabe) {
-
         int zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns;
         if (zwischensumme < 0) {
             zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns + 26;
         }
+
         return this.alphabet.charAt(zwischensumme % 26);
     }
 
@@ -126,18 +125,14 @@ public class Walze {
      *
      * @return walze : Character[] : gibt die gewaehlte Walze zurueck
      */
-    private String fetchWalze() {
-
-        return walzen[walzenNr];
-    }
+    private String fetchWalze() { return walzen[walzenNr]; }
     //endregion
 
     //region Setter
     /**
      * * TODO: Funktionsname hat sich geändert
-     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+     * Ermittelt den Wert, wie oft die Walze gedreht werden muss, um die Eingangswalzenstellung
+     * zu erreichen.
      *
      * @param buchstabe : Character : Einstellung der Walze
      */
@@ -180,7 +175,7 @@ public class Walze {
     /**
      * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
      *
-     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     * @return Character am Index 0 des (verschobenen) Alphabets
      */
     public Character getPosition() {
         return this.alphabet.charAt(turns % 26);
diff --git a/src/main/java/projekt/enigma/threads/ThreadApp.java b/src/main/java/projekt/enigma/threads/ThreadApp.java
new file mode 100644
index 0000000..47cbfb2
--- /dev/null
+++ b/src/main/java/projekt/enigma/threads/ThreadApp.java
@@ -0,0 +1,17 @@
+package projekt.enigma.threads;
+
+import projekt.enigma.App;
+
+import java.sql.SQLException;
+
+public class ThreadApp implements Runnable {
+    private String[] args;
+
+    @Override
+    public void run() {
+        System.out.println("ThreadApp" + Thread.currentThread());
+        App app = new App();
+        app.main(args);
+
+    }
+}
diff --git a/src/main/java/projekt/enigma/threads/ThreadFunkraum.java b/src/main/java/projekt/enigma/threads/ThreadFunkraum.java
new file mode 100644
index 0000000..b4a978d
--- /dev/null
+++ b/src/main/java/projekt/enigma/threads/ThreadFunkraum.java
@@ -0,0 +1,26 @@
+package projekt.enigma.threads;
+
+import org.apache.http.HttpException;
+import projekt.enigma.model.Codierer;
+import projekt.enigma.model.Funkraum;
+
+import java.io.IOException;
+
+public class ThreadFunkraum implements Runnable {
+    String kenngruppe = new Codierer().getKenngruppe();
+//    String funkspruch;
+    @Override
+    public void run() {
+        Funkraum funkraum = new Funkraum();
+        System.out.println("Threadfunkraum"  + Thread.currentThread());
+        funkraum.empfangeFunkspruch(kenngruppe);
+
+//        try {
+//            funkraum.sendeFunkspruch(funkspruch, kenngruppe);
+//        } catch (HttpException he) {
+//            System.err.println("Error");
+//        } catch (IOException io) {
+//            System.err.println("Error");
+//        }
+    }
+}
-- 
GitLab