From 1aad276d6f40f7b70cdf6bfc45372ea5fe66a2f2 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 22:45:02 +0100 Subject: [PATCH 01/10] Gitlab-CI Test --- .gitlab-ci.yml | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 649bec9..9a8ae4f 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,11 +1,22 @@ image: maven:latest -java: +stages: + - build + - test + - deploy + +job build dependencies: + stage: build + script: make build dependencies + +job build artifacts: + stage: build + script: make build artifacts + +job test: stage: test - script: - - mvn verify - artifacts: - reports: - junit: - - target/surefire-reports/TEST-*.xml - - target/failsafe-reports/TEST-*.xml \ No newline at end of file + script: make test + +job deploy: + stage: deploy + script: make deploy -- GitLab From 6eb3f856e0f7294bbdce32fa758ee14b2b2edd48 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 22:46:29 +0100 Subject: [PATCH 02/10] Gitlab-CI Test --- .gitlab-ci.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 9a8ae4f..a052fdd 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,16 +7,16 @@ stages: job build dependencies: stage: build - script: make build dependencies + script: mvn build dependencies job build artifacts: stage: build - script: make build artifacts + script: mvn build artifacts job test: stage: test - script: make test + script: mvn test job deploy: stage: deploy - script: make deploy + script: mvn deploy -- GitLab From 7c22a3d8d6e913029989150b22161096d3c2cea9 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 22:48:52 +0100 Subject: [PATCH 03/10] Gitlab-CI Test --- .gitlab-ci.yml | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a052fdd..a6884d3 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,17 +1,18 @@ image: maven:latest stages: + - clean - build - test - deploy -job build dependencies: - stage: build - script: mvn build dependencies +job clean: + stage: clean + script: mvn clean -job build artifacts: +job compile: stage: build - script: mvn build artifacts + script: mvn compile job test: stage: test -- GitLab From 3947f267678c3af508619d4ab0434bc62ac077e5 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 22:54:52 +0100 Subject: [PATCH 04/10] Gitlab-CI Test --- .gitlab-ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a6884d3..6651f57 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -20,4 +20,4 @@ job test: job deploy: stage: deploy - script: mvn deploy + script: mvn assembly:assembly -- GitLab From 2a774853240319a0d0ca4e072d7e9cbd232bff5c Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 23:07:19 +0100 Subject: [PATCH 05/10] Gitlab-CI Test --- .gitlab-ci.yml | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 6651f57..1b9bfde 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -6,18 +6,23 @@ stages: - test - deploy -job clean: +Clean Project files: stage: clean script: mvn clean -job compile: +Compile new version: stage: build script: mvn compile -job test: +Run JUnit tests and verify: stage: test - script: mvn test + script: mvn verify + artifacts: + reports: + junit: + - target/surefire-reports/TEST-*.xml + - target/failsafe-reports/TEST-*.xml -job deploy: +Deploy new version as Release: stage: deploy script: mvn assembly:assembly -- GitLab From 7732b87f545ce075f66bbc8c2174c4868cc4ff32 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Tue, 26 Nov 2019 23:38:05 +0100 Subject: [PATCH 06/10] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index a0199f8..940811b 100644 --- a/README.md +++ b/README.md @@ -1 +1,3 @@ +[](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master) + Link zum [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home) \ No newline at end of file -- GitLab From 2ea318ce68db580af2130dfdd2ee3e7105a3200d Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Wed, 27 Nov 2019 00:04:19 +0100 Subject: [PATCH 07/10] Gitlab-CI Test --- .gitlab-ci.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 1b9bfde..a9cdd0d 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -25,4 +25,6 @@ Run JUnit tests and verify: Deploy new version as Release: stage: deploy - script: mvn assembly:assembly + script: + - mvn versions:set -DnewVersion=$CI_COMMIT_TAG + - mvn assembly:assembly -- GitLab From 2280ecc567fd1f3f19d9a8aab1fac593d88a3cdd Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Wed, 27 Nov 2019 09:28:06 +0100 Subject: [PATCH 08/10] =?UTF-8?q?Unit=20Tests=20f=C3=BCr=20Reflektor,=20Wl?= =?UTF-8?q?aze=20und=20Steckbrett?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/Enigma/model/ReflektorTest.java | 4 ---- .../java/Enigma/model/SteckbrettTest.java | 12 +++++------ src/test/java/Enigma/model/WalzeTest.java | 20 +++++++++---------- 3 files changed, 16 insertions(+), 20 deletions(-) diff --git a/src/test/java/Enigma/model/ReflektorTest.java b/src/test/java/Enigma/model/ReflektorTest.java index 74ab4f6..dbaaa52 100644 --- a/src/test/java/Enigma/model/ReflektorTest.java +++ b/src/test/java/Enigma/model/ReflektorTest.java @@ -7,7 +7,6 @@ public class ReflektorTest { @Test public void codiere() { - /* Reflektor r = new Reflektor(); Assert.assertEquals('E', r.codiere('A')); @@ -16,18 +15,15 @@ public class ReflektorTest { Assert.assertEquals('O', r.codiere('Q')); Assert.assertEquals('I', r.codiere('V')); //Assert.assertNull(null, r.codiere(null)); - */ } @Test public void codiere2() { - /* Reflektor r = new Reflektor(); Assert.assertEquals('A', r.codiere('E')); Assert.assertEquals('D', r.codiere('Z')); Assert.assertEquals('H', r.codiere('X')); Assert.assertEquals('Q', r.codiere('O')); Assert.assertEquals('V', r.codiere('I')); - */ } } \ No newline at end of file diff --git a/src/test/java/Enigma/model/SteckbrettTest.java b/src/test/java/Enigma/model/SteckbrettTest.java index df6051d..114294f 100644 --- a/src/test/java/Enigma/model/SteckbrettTest.java +++ b/src/test/java/Enigma/model/SteckbrettTest.java @@ -9,28 +9,28 @@ public class SteckbrettTest { @Test public void setzeVertauschung() { - /*Steckbrett sb = new Steckbrett(); + Steckbrett sb = new Steckbrett(); sb.setzeVertauschung('A', 'G'); sb.setzeVertauschung('C', 'H'); Assert.assertEquals('H', sb.codiere('C')); - Assert.assertEquals('G', sb.codiere('A'));*/ + Assert.assertEquals('G', sb.codiere('A')); } @Test public void codiere() { - /*Steckbrett sb = new Steckbrett(); + Steckbrett sb = new Steckbrett(); sb.setzeVertauschung('A', 'G'); sb.setzeVertauschung('C', 'H'); Assert.assertEquals('H', sb.codiere('C')); - Assert.assertEquals('G', sb.codiere('A'));*/ + Assert.assertEquals('G', sb.codiere('A')); } @Test public void codiere2() { - /*Steckbrett sb = new Steckbrett(); + Steckbrett sb = new Steckbrett(); sb.setzeVertauschung('A', 'G'); sb.setzeVertauschung('C', 'H'); Assert.assertEquals('C', sb.codiere2('H')); - Assert.assertEquals('A', sb.codiere2('G'));*/ + Assert.assertEquals('A', sb.codiere2('G')); } } \ No newline at end of file diff --git a/src/test/java/Enigma/model/WalzeTest.java b/src/test/java/Enigma/model/WalzeTest.java index 1c58136..5b526b6 100644 --- a/src/test/java/Enigma/model/WalzeTest.java +++ b/src/test/java/Enigma/model/WalzeTest.java @@ -9,37 +9,37 @@ public class WalzeTest { @Test public void setzeNotch() { - /*Walze w = new Walze(1); + Walze w = new Walze(1); w.setzeNotch('G'); - Assert.assertEquals('G', w.wlazenPosition());*/ + Assert.assertEquals('G', w.wlazenPosition()); } @Test public void dreheWalze() { - /*Walze w = new Walze(1); + Walze w = new Walze(1); w.setzeNotch('G'); w.dreheWalze(); - Assert.assertEquals('H', w.wlazenPosition());*/ + Assert.assertEquals('H', w.wlazenPosition()); } @Test public void walzenPoition() { - /*Walze w = new Walze(1); + Walze w = new Walze(1); w.setzeNotch('G'); - Assert.assertEquals('G', w.wlazenPosition());*/ + Assert.assertEquals('G', w.wlazenPosition()); } @Test public void codiere() { - /*Walze w = new Walze(1); + Walze w = new Walze(1); w.setzeNotch('A'); - Assert.assertEquals('E', w.codiere('A'));*/ + Assert.assertEquals('E', w.codiere('A')); } @Test public void codiere2() { - /*Walze w = new Walze(1); + Walze w = new Walze(1); w.setzeNotch('A'); - Assert.assertEquals('A', w.codiere('E'));*/ + Assert.assertEquals('A', w.codiere('E')); } } \ No newline at end of file -- GitLab From 8abc13fc02c80e5a99f290e6f475f783fb8d0fb8 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Wed, 27 Nov 2019 14:16:41 +0100 Subject: [PATCH 09/10] Hardware Klasse angelegt. --- src/main/java/Enigma/model/Hardware.java | 120 +++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 src/main/java/Enigma/model/Hardware.java diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java new file mode 100644 index 0000000..12f208e --- /dev/null +++ b/src/main/java/Enigma/model/Hardware.java @@ -0,0 +1,120 @@ +package Enigma.model; + +public class Hardware { + + private Walze[] walzen; + private Steckbrett steckbrett; + private Reflektor reflektor; + private String nachricht; + private String kenngruppe; + + /** + * Setzt eine Walze ein + * + * @param walze : int : Setzt die Walze mit der angegebenen Nummer ein + * @param walzenNr : int : Die Nummer der einzusetzenden Walze + */ + public void setzeWalzenNr(int walze, int walzenNr) { + } + + /** + * Setzt den Notch der Walze + * + * @param walze : int : Position der Walze + * @param position : int : Umspringpunkt auf der Walze + */ + public void setzeRing(int walze, int position) { + } + + /** + * Setzt den Startwert (position) der Walze (walze) + * + * @param walze + * @param buchstabe + */ + public void setzePosition(int walze, char buchstabe) { + } + + // Befehl die Nachricht an den Funker zu übergeben + public void sendeNachricht() { + new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe); + } + + /** + * Gibt die letzte empfangene Nachricht zurück + * <p> + * String[0] = Die verschlüsselte Nachricht + * String[1] = Nachricht im Klartext + */ + public String[] empfangeNachricht() { + String[] result = new String[2]; + + return result; + } + + /** + * Fügt die gedrückte Taste der Nachricht hinzu + * + * @param buchstabe char : Der zu verschlüsselnde Buchstabe + * @return char : Der verschlüsselte Buchstabe + */ + public char tippeBuchstabe(char buchstabe) { + buchstabe = this.steckbrett.codiere(buchstabe); + buchstabe = this.walzen[1].codiere(buchstabe); + buchstabe = this.walzen[2].codiere(buchstabe); + buchstabe = this.walzen[3].codiere(buchstabe); + buchstabe = this.reflektor.codiere(buchstabe); + buchstabe = this.walzen[3].codiere2(buchstabe); + buchstabe = this.walzen[2].codiere2(buchstabe); + buchstabe = this.walzen[1].codiere2(buchstabe); + buchstabe = this.steckbrett.codiere2(buchstabe); + + this.nachricht += buchstabe; + + return buchstabe; + } + + /** + * Nachricht entschlüsseln + * + * @param nachricht : String : Verschlüsselte Nachricht + * @return String : Die Klartext Nachricht + */ + private String decodiereNachricht(String nachricht) { + String result = ""; + + return result; + } + + public Walze[] getWalzen() { + return this.walzen; + } + + public void setWalzen(int walze, int position, char ringstellung) { + this.walzen[position] = new Walze(walze, ringstellung); + } + + public Steckbrett getSteckbrett() { + return steckbrett; + } + + public void setSteckbrett(Steckbrett steckbrett) { + this.steckbrett = steckbrett; + } + + public Reflektor getReflektor() { + return reflektor; + } + + public void setReflektor(Reflektor reflektor) { + this.reflektor = reflektor; + } + + public String getKenngruppe() { + return kenngruppe; + } + + public void setKenngruppe(String kenngruppe) { + this.kenngruppe = kenngruppe; + } +} -- GitLab From 14d6247514ffc859a436e86160a04ce84d7aa656 Mon Sep 17 00:00:00 2001 From: Dennis Eisold <de@itstall.de> Date: Wed, 27 Nov 2019 16:21:43 +0100 Subject: [PATCH 10/10] =?UTF-8?q?Fixes=20f=C3=BCr=20codier=20Funktionen=20?= =?UTF-8?q?und=20Tests=20f=C3=BCr=20Hardware=20Klasse?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Enigma/App.java | 37 +- src/main/java/Enigma/model/Hardware.java | 14 +- src/main/java/Enigma/model/Morsecode.java | 1 - src/main/java/Enigma/model/Walze.java | 416 +++++++++++----------- 4 files changed, 250 insertions(+), 218 deletions(-) diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java index 1e8c809..397e3da 100644 --- a/src/main/java/Enigma/App.java +++ b/src/main/java/Enigma/App.java @@ -1,5 +1,8 @@ package Enigma; +import Enigma.model.Codebuch; +import Enigma.model.DatenbankSqlite; +import Enigma.model.Hardware; import javafx.application.Application; import javafx.fxml.FXMLLoader; import javafx.scene.Parent; @@ -7,6 +10,9 @@ import javafx.scene.Scene; import javafx.stage.Stage; import java.io.IOException; +import java.sql.SQLException; +import java.util.Calendar; +import java.util.TimeZone; /** * JavaFX App @@ -14,13 +20,15 @@ import java.io.IOException; public class App extends Application { private static Scene scene; + private Codebuch cb; + private Hardware h; @Override public void start(Stage stage) throws IOException { scene = new Scene(loadFXML("gui")); stage.setScene(scene); stage.show(); - + holeCodebuch(); } static void setRoot(String fxml) throws IOException { @@ -36,4 +44,31 @@ public class App extends Application { Application.launch(); } + public void holeCodebuch() { + Calendar calendar = Calendar.getInstance(TimeZone.getDefault()); + + try { + this.cb = new DatenbankSqlite().getCodebuch(Calendar.DATE); + } catch (SQLException ignored) { } + + for(int i = 0; i < 3; i++) { + h.setWalzen(i + 1, Integer.parseInt(cb.getWalzenlage()[i]), cb.getRingstellung()[i].charAt(0)); + } + + /*Walze w1 = new Walze(3); + w1.setzeNotch(13); + Walze w2 = new Walze(5); + w2.setzeNotch(1); + Walze w3 = new Walze(1); + w3.setzeNotch(20); + Reflektor r = new Reflektor(); + Steckbrett sb = new Steckbrett(); + + if(w1.dreheWalze()) { + if(w2.dreheWalze()) { + w3.dreheWalze(); + } + }*/ + } + } \ No newline at end of file diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java index 12f208e..4280ddc 100644 --- a/src/main/java/Enigma/model/Hardware.java +++ b/src/main/java/Enigma/model/Hardware.java @@ -1,5 +1,9 @@ package Enigma.model; +import org.apache.http.HttpException; + +import java.io.IOException; + public class Hardware { private Walze[] walzen; @@ -8,6 +12,10 @@ public class Hardware { private String nachricht; private String kenngruppe; + public Hardware() { + this.walzen = new Walze[4]; + } + /** * Setzt eine Walze ein * @@ -36,7 +44,7 @@ public class Hardware { } // Befehl die Nachricht an den Funker zu übergeben - public void sendeNachricht() { + public void sendeNachricht() throws IOException, HttpException { new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe); } @@ -67,7 +75,7 @@ public class Hardware { buchstabe = this.walzen[3].codiere2(buchstabe); buchstabe = this.walzen[2].codiere2(buchstabe); buchstabe = this.walzen[1].codiere2(buchstabe); - buchstabe = this.steckbrett.codiere2(buchstabe); + buchstabe = this.steckbrett.codiere(buchstabe); this.nachricht += buchstabe; @@ -90,7 +98,7 @@ public class Hardware { return this.walzen; } - public void setWalzen(int walze, int position, char ringstellung) { + public void setWalzen(int walze, int position, int ringstellung) { this.walzen[position] = new Walze(walze, ringstellung); } diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java index f8c759c..38e2b1f 100644 --- a/src/main/java/Enigma/model/Morsecode.java +++ b/src/main/java/Enigma/model/Morsecode.java @@ -93,7 +93,6 @@ public class Morsecode { */ private String getBuchstabe(String morsecode) { // Initialisieren des Rückgabe Strings - // TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen? String result = null; // Loopt duch die Codemap und erstellt daraus ein Set diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java index 86cf8f4..f12de2a 100644 --- a/src/main/java/Enigma/model/Walze.java +++ b/src/main/java/Enigma/model/Walze.java @@ -1,246 +1,236 @@ package Enigma.model; +import java.time.Year; + /** * Klasse Walze - * + * <p> * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften: - * + * <p> * 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> * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt * den Drehzeitpunkt der linken Nachbarwalze) - * */ public class Walze { - /** - * Konstanten und Variablen der Klasse Walze - * - * buchstabe : Bestimmt den Buchstaben - * ringstellung : Bestimmt den Umspringpunkt der Walze - * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird) - * iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder. - * iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder. - * private Character[] walze : Character-Array der Walze - */ - - private Character buchstabe; - private Character ringstellung; - private int walzennr; - private int iPositionBuchstabe; - private int iPositionBuchstabeRe; - private Character[] walze; - - - - /** - * Gibt die Parameter der Walze mit - * - * @param walzennr : int : Nummer der gewaehlten Walze - * @param ringstellung : Character : Einstellung des Notch - */ - public Walze(int walzennr, Character ringstellung) { - this.walze = new Character[25]; - this.walzennr = walzennr; - this.buchstabe = 'A'; - this.ringstellung = ringstellung; - } - - - /** - * Sortiert den Walzennummern das passenden Character-Array mittels switch zu. - * - * @return walze : Character[] : gibt die gewaehlte Walze zurueck - */ - private Character[] walzenNummer() { - - /*Walze nach der Chiffrierung*/ - 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 (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; - } - - - - //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück - public int walzenPosition() { + /** + * Konstanten und Variablen der Klasse Walze + * <p> + * buchstabe : Bestimmt den Buchstaben + * ringstellung : Bestimmt den Umspringpunkt der Walze + * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird) + * iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder. + * iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder. + * private Character[] walze : Character-Array der Walze + */ + /*Alphawalze*/ + private final static Character[] walzeAlpha = {'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'}; + private Character buchstabe; + private int ringstellung; + private int walzennr; + private int iPositionBuchstabe; + private int iPositionBuchstabeRe; + private Character[] walze; + + + /** + * Gibt die Parameter der Walze mit + * + * @param walzennr : int : Nummer der gewaehlten Walze + * @param ringstellung : Character : Einstellung des Notch + */ + public Walze(int walzennr, int ringstellung) { + this.walze = new Character[25]; + this.walzennr = walzennr; + this.buchstabe = 'A'; + this.iPositionBuchstabe = 0; + this.ringstellung = ringstellung; + } + + + /** + * Sortiert den Walzennummern das passenden Character-Array mittels switch zu. + * + * @return walze : Character[] : gibt die gewaehlte Walze zurueck + */ + private Character[] walzenNummer() { + + 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; + } + + + //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück + public char walzenPosition() { /*Alphabetswalze*/ - Character[] walzeAlphabeth = {'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'}; - - /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/ - for(int index = 0; index < walzeAlphabeth.length; index++) { - if(getBuchstabe().equals(walzeAlphabeth[index])) { - iPositionBuchstabe = index; + Character[] walzeAlphabeth = {'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'}; + + return walzeAlphabeth[iPositionBuchstabe]; + } + + + //setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens + // Setter für Ringstellung + + /** + * @return ringstellung : Character : gibt die neue Ringstellung zurueck + */ + public int 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. + * + * @param ringstellung : Character : Punkt an dem die Walze umspringt + */ + public void setRingstellung(int ringstellung) { + + if (ringstellung > 0 && ringstellung <= 26) { + this.ringstellung = ringstellung; + } else { + this.ringstellung = 1; + } + } + + //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false + public boolean dreheWalze() { + + boolean checkRing; + + if (iPositionBuchstabe == 25) { + iPositionBuchstabe = 0; + } else { + iPositionBuchstabe += 1; + } + + if (iPositionBuchstabe == getRingstellung()) { + checkRing = true; + } else { + checkRing = false; + } + + return checkRing; + } + + + //codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück + + /** + * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe() + * anhand der gewaehlten Walze. + * + * @param + * @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 iPositionBuchstabe; - } - - - //setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens - // Setter für 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. - * - * @param ringstellung : Character : Punkt an dem die Walze umspringt - */ - public void setRingstellung(Character ringstellung) { - - if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) { - this.ringstellung = ringstellung; - } else { - this.ringstellung = '1'; - } - } - - /** - * @return ringstellung : Character : gibt die neue Ringstellung zurueck - */ - public Character getRingstellung() { - return ringstellung; - } - - - //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false - public boolean dreheWalze(){ - - boolean checkRing; - - if(iPositionBuchstabe == 25) { - - iPositionBuchstabe = 0; - - } else { - - iPositionBuchstabe += 1; - } + return buchstabe; + } - if (iPositionBuchstabe == getRingstellung()){ - checkRing = true; + //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse) - }else{ + /** + * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse() + * anhand der AlphaWalze. + * + * @param + * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe + */ + public char codiere2(char buchstabe) { - checkRing = false; - } - - return checkRing; - } - - - //codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück - /** - * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe() - * anhand der gewaehlten Walze. - * - * @param - * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe - */ - public Character codiere(Character buchstabe) { - setBuchstabe(buchstabe); - walzenPosition(); - Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe]; - return codierterBuchstabe; - } - - - //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse) - /** - * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse() - * anhand der AlphaWalze. - * - * @param - * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe - */ - public Character codiere2(char buchstabe) { - - /*Alphawalze*/ - Character[] walzeAlpha = {'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'}; - - setBuchstabe(buchstabe); - - /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/ - for(int index = 0; index < walzenNummer().length; index++) { - if(getBuchstabe().equals(walzenNummer()[index])) { - iPositionBuchstabeRe = index; + for(int i = 0; i < walzenNummer().length; i++) { + if(walzenNummer()[i].equals(buchstabe)) { + buchstabe = walzeAlpha[i]; break; } } - Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe]; - return codierterBuchstabeRe; - - - } + return buchstabe; + } //_________________________________________________________________________________________ - /** - * @return buchstabe : Character : gibt den neuen Buchstaben zurueck - */ - public Character getBuchstabe() { - return buchstabe; - } - - /** - * 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 : Grundeinstellung der Walze - */ - public void setBuchstabe(Character buchstabe) { - - if(Character.isLetter(buchstabe)) { - this.buchstabe = Character.toUpperCase(buchstabe); - } else { - this.buchstabe = 'A'; - } - } - - - //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt. - /** - * 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"); - } - } + /** + * @return buchstabe : Character : gibt den neuen Buchstaben zurueck + */ + public Character getBuchstabe() { + return buchstabe; + } + + /** + * 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 : Grundeinstellung der Walze + */ + public void setBuchstabe(Character buchstabe) { + + if (Character.isLetter(buchstabe)) { + this.buchstabe = Character.toUpperCase(buchstabe); + for(int i = 0; i < 25; i++) { + if(walzeAlpha[i].equals(buchstabe)) { + this.iPositionBuchstabe = i; + } + } + } else { + this.buchstabe = 'A'; + } + } + + + //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt. + + /** + * 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"); + } + } } -- GitLab