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