From 880b762076ea616431b8da246f794932178b1e12 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:27:33 +0100
Subject: [PATCH 1/4] Fehler bei ueberpuefeVertauschungen behoben

---
 .../java/projekt/enigma/model/Codierer.java   |  2 +-
 .../java/projekt/enigma/model/Steckbrett.java | 44 +++++++------------
 2 files changed, 18 insertions(+), 28 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index f62108e..bccbda4 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -408,7 +408,7 @@ public class Codierer {
 	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
 	 * @param port          : int : Kabel Nummer welches am Steckbrett eingesteckt wird
 	 * @param verbindung    : String : Verbindung welche die vertauschten Buchstaben angibt
-	 * @return
+	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
 	 */
 	public boolean setSteckbrett(int port, String verbindung) {
 		return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index f1fbfcb..02decf2 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -10,7 +10,7 @@ package projekt.enigma.model;
 public class Steckbrett {
 
 	/**
-	 * zaehler: Int, der als Laufvariable genutzt wird
+	 * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
 	 */
 	private int zaehler;
 
@@ -44,8 +44,8 @@ public class Steckbrett {
 	 * <br>
 	 * Anschließend wird:
 	 * <p>
-	 *     buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
-	 *     buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
+	 * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
 	 * </p>
 	 *
 	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
@@ -54,17 +54,13 @@ public class Steckbrett {
 	 */
 	public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
 
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			return false;
-		} else {
-			if (zaehler < orginalBuchstaben.length) {
-				orginalBuchstaben[zaehler] = buchstabe1;
-				getauschteBuchstaben[zaehler++] = buchstabe2;
+		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
+			orginalBuchstaben[zaehler] = buchstabe1;
+			getauschteBuchstaben[zaehler++] = buchstabe2;
 
-				return true;
-			} else {
-				return false;
-			}
+			return true;
+		} else {
+			return false;
 		}
 	}
 
@@ -76,8 +72,8 @@ public class Steckbrett {
 	 * <br>
 	 * Anschließend wird:
 	 * <p>
-	 *     buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
-	 *     buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
+	 * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
 	 * </p>
 	 *
 	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
@@ -87,12 +83,13 @@ public class Steckbrett {
 	public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
 
 		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			return false;
-		} else {
 			orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
 			getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
 
 			return true;
+		} else {
+
+			return false;
 		}
 
 	}
@@ -108,20 +105,13 @@ public class Steckbrett {
 	 * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
 	 * Wenn er schon vorhanden ist, wird true zurück gegeben
 	 */
-	public boolean ueberpruefeVertauschungen(char buchstabe) {
+	public boolean ueberpruefeVertauschungen(Character buchstabe) {
 
 		boolean result = false;
 
-		for (char c : orginalBuchstaben) {
-			if (c == buchstabe) {
-				result = true;
-				break;
-			}
-		}
-		for (char c : getauschteBuchstaben) {
-			if (c == buchstabe) {
+		for (int n = 0; n < orginalBuchstaben.length; n++) {
+			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
 				result = true;
-				break;
 			}
 		}
 
-- 
GitLab


From bcb91f113aa30fd6ea0dc9b6b74f06be921c961c Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:28:25 +0100
Subject: [PATCH 2/4] Fehler bei ueberpuefeVertauschungen behoben

---
 src/main/java/projekt/enigma/model/Steckbrett.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index 02decf2..ec18c7a 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -112,6 +112,7 @@ public class Steckbrett {
 		for (int n = 0; n < orginalBuchstaben.length; n++) {
 			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
 				result = true;
+				break;
 			}
 		}
 
-- 
GitLab


From c2450f7f4e1badae1ebfb1be7ea3c778bc145968 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:40:58 +0100
Subject: [PATCH 3/4] Funktion letztesZeichenLoeschen im Codierer angelegt #12

---
 src/main/java/projekt/enigma/model/Codierer.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index bccbda4..b1389e0 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -464,4 +464,11 @@ public class Codierer {
 	public char[][] getSteckverbindungen() {
 		return this.codebuch.getSteckverbindung();
 	}
+
+	/**
+	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+	 */
+	public void letztesZeichenLoeschen() {
+
+	}
 }
-- 
GitLab


From bc35d2d91149c949e69ab04d5d86f70d7b57b8f7 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 22:55:28 +0100
Subject: [PATCH 4/4] Das drehen funktioniert, nur der Notch macht noch
 Probleme #12

---
 .../java/projekt/enigma/model/Codierer.java   |  13 +-
 src/main/java/projekt/enigma/model/Walze.java | 426 +++++++++---------
 2 files changed, 229 insertions(+), 210 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index b1389e0..17b1fc5 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -406,8 +406,9 @@ public class Codierer {
 
 	/**
 	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
-	 * @param port          : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-	 * @param verbindung    : String : Verbindung welche die vertauschten Buchstaben angibt
+	 *
+	 * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
 	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
 	 */
 	public boolean setSteckbrett(int port, String verbindung) {
@@ -469,6 +470,12 @@ public class Codierer {
 	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
 	 */
 	public void letztesZeichenLoeschen() {
-
+		if (this.hardware.getWalzen()[2].dreheWalze(-1)) {
+			System.out.println("Drehe W2");
+			if (this.hardware.getWalzen()[1].dreheWalze(-1)) {
+				System.out.println("Drehe W1");
+				this.hardware.getWalzen()[0].dreheWalze(-1);
+			}
+		}
 	}
 }
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 51bf3a8..e43959f 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,5 +1,11 @@
 package projekt.enigma.model;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
  * Klasse Walze
  * <br>
@@ -14,10 +20,10 @@ package projekt.enigma.model;
  */
 public class Walze {
 
-    /**
-     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
-     */
-    private Character[] alphabet;
+	/**
+	 * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+	 */
+	private Character[] alphabet;
 
 	/**
 	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
@@ -25,244 +31,250 @@ public class Walze {
 	private char ringstellung;
 
 	/**
-	 *  walzennr : int : Bestimmt, welche Walze genutzt wird
+	 * walzennr : int : Bestimmt, welche Walze genutzt wird
 	 */
-    private int walzennr;
+	private int walzennr;
 
 	/**
-	 *  alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
-	 *  aber immer wieder ueberschrieben.
+	 * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+	 * aber immer wieder ueberschrieben.
 	 */
-    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;
-        }
+	private Character[] walzeAlpha;
 
-        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.
+	/**
+	 * 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.
+	 * <p>
 	 * 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';
-        }
-    }
+	 * 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
+	/**
+	 * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
 	 * das Array alphabet mit der neuen Anordnung.
-	 *
+	 * <p>
 	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
 	 *
 	 * @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();
-            }
-        }
+	 * TODO: Doku
+	 */
+	public boolean dreheWalze(int... drehung) {
+		boolean checkRing = false;
+		int richtung = 1;
 
-        // gleicht die Ringstellung mit der aktuellen Position ab
-        if (this.getPosition().equals(this.ringstellung)) {
-            checkRing = true;
-        }
+		if (drehung.length > 0 && drehung[0] < 0) {
+			richtung = -1;
+		}
+
+		// fuehrt die Verschiebung des Alphabets um eine Stelle durch
+		verschiebung(richtung);
 
-        return checkRing;
-    }
+		// fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
+		if (drehung.length > 0) {
+			for (int i = 1; i < drehung[0]; i++) {
+				verschiebung(richtung);
+			}
+		}
 
-    /**
+		// 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];
+	 *
+	 * @param richtung : int : Wenn "normal" gedreht werden soll, wird 1 übergeben, reverse entspricht dann -1
+	 *                 TODO: Dokumentieren
+	 */
+	private void verschiebung(int richtung) {
 
-        for (int index = 0; index < neueWalze.length; index++) {
-            neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
+		if (richtung > 0) {
+            Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
+        } else {
+            Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
         }
+	}
 
-        this.walzeAlpha = neueWalze;
-    }
+	/**
+	 * TODO: Dokumentieren // dass selbe wie getPosition
+	 * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
+	 *
+	 * @return char an der Stelle temp des Alphabets
+	 */
+	public char getAnzeige() {
+		int temp = this.fetchArrayIndex('A', this.walzeAlpha);
+		return this.alphabet[temp];
+	}
 
-    /**
-     * TODO: Dokumentieren // dass selbe wie getPosition
-     * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
+	/**
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
 	 *
-     * @return char an der Stelle temp des Alphabets
-     */
-    public char getAnzeige() {
-        int temp = this.fetchArrayIndex('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) {
+	 * @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()[fetchArrayIndex(buchstabe, walzeAlpha)];
+		buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
 
-        return buchstabe;
-    }
+		return buchstabe;
+	}
 
-    /**
-     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
-     *
+	/**
+	 * 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) {
+	 * @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[fetchArrayIndex(buchstabe, walzenNummer())];
 
-        return buchstabe;
-    }
+		return buchstabe;
+	}
 
-    /**
-     * TODO: Dokumentieren
-     * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
+	/**
+	 * TODO: Dokumentieren
+	 * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
 	 *
-     * @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 fetchArrayIndex(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;
-            }
-        }
+	 * @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 fetchArrayIndex(Character buchstabe, Character[] array) {
+		// wird mit ungueltigem Wert initialisiert
+		int result = -1;
 
-        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");
-        }
-    }
+		for (int i = 0; i < array.length; i++) {
+			if (array[i].equals(buchstabe)) {
+				result = i;
+				break;
+			}
+		}
+
+		return result;
+	}
 
-    /**
-     * TODO: Dokumentieren // das selbe wie getAnzeig?
+	/**
+	 * 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];
-    }
-
-    /**
-     * 	 * 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.
-     *
-     * @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.fetchArrayIndex(buchstabe, this.walzeAlpha));
-            }
-        }
-    }
+	 *
+	 * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+	 */
+	public Character getPosition() {
+		return walzeAlpha[0];
+	}
+
+	/**
+	 * * 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.
+	 *
+	 * @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.fetchArrayIndex(buchstabe, this.walzeAlpha));
+			}
+		}
+	}
 }
-- 
GitLab