diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
index aacb58c97a1dfad19a89cd97cb8fe963aecf5371..9ded525e6d41617d76f148556b5c8f278bb88a63 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 51648acc3c23be9b528764252ab92f672c3e74a5..51bf3a8b377e37edaa1e303a21409f0dea83c87f 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -2,246 +2,267 @@ package projekt.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 {
- /**
- * Konstanten und Variablen der Klasse Walze
- * <p>
- * ringstellung : Bestimmt den Umspringpunkt der Walze
- * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
- */
- 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
- */
- 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);
- }
-
- /**
- * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
- *
- * @return walze : Character[] : gibt die gewaehlte Walze zurueck
- */
- 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
- *
- * @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.
- *
- * @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;
- }
+ /**
+ * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+ */
+ private Character[] alphabet;
/**
- * TODO: Dokumentieren
+ * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
*/
- 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;
- }
+ private char ringstellung;
/**
- * TODO: Dokumentieren
- * TODO: Ich glaube das kann weg?
- *
- * @return
+ * walzennr : int : Bestimmt, welche Walze genutzt wird
*/
- public char getAnzeige() {
- int temp = this.getArrayIndex('A', this.walzeAlpha);
-
- return this.alphabet[temp];
- }
+ private int walzennr;
/**
- * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
- * anhand der gewaehlten Walze.
- *
- * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
+ * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+ * aber immer wieder ueberschrieben.
*/
- 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.
+ 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 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
+ * 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 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.
+ * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
*
- * @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
+ * @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 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.
- * TODO: Funktionsname hat sich geändert
+ * @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) {
+ /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
+ uebertraegt den Index auf die gewaehlte Codierwalze*/
+ buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
+
+ 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[fetchArrayIndex(buchstabe, walzenNummer())];
+
+ return buchstabe;
+ }
+
+ /**
+ * TODO: Dokumentieren
+ * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
*
- * @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 : 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;
+ }
+ }
+
+ 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];
+ }
+
+ /**
+ * * 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));
+ }
+ }
+ }
}